human-format/index.d.ts at master · JsCommunity/human-format · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
declare module "human-format" {
  export type BinaryPrefix =
    | ""
    | "Ki"
    | "Mi"
    | "Gi"
    | "Ti"
    | "Pi"
    | "Ei"
    | "Zi"
    | "Yi";

  export type SIPrefix =
    | "y"
    | "z"
    | "a"
    | "f"
    | "p"
    | "n"
    | "µ"
    | "m"
    | ""
    | "k"
    | "M"
    | "G"
    | "T"
    | "P"
    | "E"
    | "Z"
    | "Y";

  export type ScaleName = "binary" | "SI";

  export type ScaleLike = Scale<string> | ScaleName;

  export type Prefix<TScale extends ScaleLike> = TScale extends Scale<
    infer TPrefix
  >
    ? TPrefix
    : TScale extends "binary"
    ? BinaryPrefix
    : TScale extends "SI"
    ? SIPrefix
    : never;

  export interface Options<TScale extends ScaleLike> {
    maxDecimals?: number | "auto";
    separator?: string;
    unit?: string;
    scale?: TScale;
    strict?: boolean;
    prefix?: Prefix<TScale>;
    decimals?: number;
  }

  export interface Info<TScale extends ScaleLike> {
    value: number;
    prefix: Prefix<TScale>;
    unit?: string;
  }

  export interface ParsedInfo<TScale extends ScaleLike> {
    value: number;
    factor: number;
    prefix: Prefix<TScale>;
    unit?: string;
  }

  export class Scale<TPrefix extends string> {
    constructor(prefixes: Record<TPrefix, number>);
    static create<TPrefix extends string>(
      prefixes: TPrefix[],
      base: number,
      initExp?: number
    ): Scale<TPrefix>;
    findPrefix(value: number): { factor: number; prefix: TPrefix };
    parse<TScale extends ScaleLike>(
      str: string,
      strict?: boolean
    ): ParsedInfo<TScale>;
  }

  interface HumanFormat {
    <TScale extends ScaleLike>(
      value: number,
      options?: Options<TScale>
    ): string;
    bytes<TScale extends ScaleLike>(
      value: number,
      options?: Options<TScale>
    ): string;
    parse: {
      <TScale extends ScaleLike>(
        str: string,
        options?: Options<TScale>
      ): number;
      raw<TScale extends ScaleLike>(
        str: string,
        strict?: boolean
      ): ParsedInfo<TScale>;
    };
    raw<TScale extends ScaleLike>(
      value: number,
      options?: Options<TScale>
    ): Info<TScale>;
    Scale: typeof Scale;
  }

  const humanFormat: HumanFormat;

  export = humanFormat;
}