packages/shared/lib/helpers/humanSize.ts

   1 import { c, msgid } from 'ttag';
   2
   3 import { BASE_SIZE } from '../constants';
   4
   5 export const sizeUnits = {
   6     B: 1,
   7     KB: BASE_SIZE,
   8     MB: BASE_SIZE * BASE_SIZE,
   9     GB: BASE_SIZE * BASE_SIZE * BASE_SIZE,
  10     TB: BASE_SIZE * BASE_SIZE * BASE_SIZE * BASE_SIZE,
  11 };
  12
  13 export type SizeUnits = keyof typeof sizeUnits;
  14
  15 export const getSizeFormat = (key: SizeUnits, n: number) => {
  16     if (key === 'B') {
  17         return c('file size format').ngettext(msgid`byte`, `bytes`, n);
  18     }
  19     if (key === 'KB') {
  20         return c('file size format').t`KB`;
  21     }
  22     if (key === 'MB') {
  23         return c('file size format').t`MB`;
  24     }
  25     if (key === 'GB') {
  26         return c('file size format').t`GB`;
  27     }
  28     if (key === 'TB') {
  29         return c('file size format').t`TB`;
  30     }
  31     throw new Error('Unknown unit');
  32 };
  33
  34 export const getLongSizeFormat = (key: SizeUnits, n: number) => {
  35     if (key === 'B') {
  36         return c('file size format, long').ngettext(msgid`Byte`, `Bytes`, n);
  37     }
  38     if (key === 'KB') {
  39         return c('file size format, long').ngettext(msgid`Kilobyte`, `Kilobytes`, n);
  40     }
  41     if (key === 'MB') {
  42         return c('file size format, long').ngettext(msgid`Megabyte`, `Megabytes`, n);
  43     }
  44     if (key === 'GB') {
  45         return c('file size format, long').ngettext(msgid`Gigabyte`, `Gigabytes`, n);
  46     }
  47     if (key === 'TB') {
  48         return c('file size format, long').ngettext(msgid`Terabyte`, `Terabytes`, n);
  49     }
  50     throw new Error('Unknown unit');
  51 };
  52
  53 export const getUnit = (bytes: number): SizeUnits => {
  54     if (bytes < sizeUnits.KB) {
  55         return 'B';
  56     }
  57
  58     if (bytes < sizeUnits.MB) {
  59         return 'KB';
  60     }
  61
  62     if (bytes < sizeUnits.GB) {
  63         return 'MB';
  64     }
  65
  66     return 'GB';
  67 };
  68
  69 const transformTo = ({
  70     bytes,
  71     unit,
  72     withoutUnit,
  73     fractionDigits = 2,
  74     truncate,
  75 }: {
  76     bytes: number;
  77     unit: SizeUnits;
  78     withoutUnit?: boolean;
  79     fractionDigits?: number;
  80     truncate?: boolean;
  81 }) => {
  82     const completeValue = bytes / sizeUnits[unit];
  83     let value: string;
  84     if (fractionDigits === 0 && !truncate) {
  85         value = `${Number(completeValue.toFixed(1))}`;
  86     } else {
  87         value = completeValue.toFixed(fractionDigits);
  88     }
  89     const suffix = withoutUnit ? '' : ` ${getSizeFormat(unit, Number(value))}`;
  90
  91     return value + suffix;
  92 };
  93
  94 const humanSize = ({
  95     bytes = 0,
  96     unit: maybeUnit,
  97     fraction: maybeFraction,
  98     withoutUnit,
  99     truncate,
 100 }: {
 101     truncate?: boolean;
 102     bytes: number | undefined;
 103     unit?: SizeUnits;
 104     withoutUnit?: boolean;
 105     fraction?: number;
 106 }) => {
 107     const unit = maybeUnit || getUnit(bytes);
 108     const fractionDigits = maybeFraction === undefined && unit === 'B' ? 0 : maybeFraction;
 109     return transformTo({ bytes, unit, withoutUnit, fractionDigits, truncate });
 110 };
 111
 112 export default humanSize;
 113
 114 /**
 115  * shortHumanSize makes the compact size version to the bytes precision. It drops
 116  * the fractional part for sizes smaller than gigabyte--only for bigger files
 117  * it shows one fractional digit. Examples:
 118  *
 119  * 12 bytes -> 12 bytes
 120  * 567 bytes -> 1 KB
 121  * 12.34 MB -> 12 MB
 122  * 12.34 GB -> 12.3 GB
 123  */
 124 export const shortHumanSize = (bytes = 0) => {
 125     if (bytes < sizeUnits.KB) {
 126         return humanSize({ bytes, unit: 'B', truncate: true, fraction: 0 });
 127     }
 128     if (bytes < sizeUnits.GB) {
 129         return humanSize({ bytes, truncate: true, fraction: 0 });
 130     }
 131     return humanSize({ bytes, fraction: 1 });
 132 };
 133
 134 /**
 135  * Produces always readable version in bytes. Useful for titles where we
 136  * might want to display the exact size.
 137  */
 138 export const bytesSize = (bytes = 0) => {
 139     return `${bytes} ${getSizeFormat('B', bytes)}`;
 140 };