@keplr-wallet/unit 0.9.10-rc.0 → 0.9.11-rc.3

package/src/price-pretty.spec.ts

@@ -16,14 +16,38 @@ describe("Test PricePretty", () => {
     expect(pretty.toString()).toBe("$12.1");
     expect(pretty.increasePrecision(1).toString()).toBe("$1.21");
     expect(pretty.decreasePrecision(1).toString()).toBe("$121");
-    expect(pretty.precision(0).toString()).toBe("$121,234");
-    expect(pretty.precision(-2).toString()).toBe("$12,123,400");
+    expect(pretty.moveDecimalPointLeft(1).toString()).toBe("$1.21");
+    expect(pretty.moveDecimalPointRight(1).toString()).toBe("$121");
 
     expect(pretty.add(new Dec("0.1")).toString()).toBe("$12.2");
     expect(pretty.sub(new Dec("0.1")).toString()).toBe("$12");
     expect(pretty.mul(new Dec("0.1")).toString()).toBe("$1.21");
     expect(pretty.quo(new Dec("0.1")).toString()).toBe("$121");
 
+    expect(
+      new PricePretty(
+        {
+          currency: "usd",
+          symbol: "$",
+          maxDecimals: 2,
+          locale: "en-US",
+        },
+        new Dec("0")
+      ).toString()
+    ).toBe("$0");
+
+    expect(
+      new PricePretty(
+        {
+          currency: "usd",
+          symbol: "$",
+          maxDecimals: 2,
+          locale: "en-US",
+        },
+        new Dec("-0")
+      ).toString()
+    ).toBe("$0");
+
     expect(
       new PricePretty(
         {
@@ -35,5 +59,85 @@ describe("Test PricePretty", () => {
         new Dec("0.001")
       ).toString()
     ).toBe("< $0.01");
+
+    expect(
+      new PricePretty(
+        {
+          currency: "usd",
+          symbol: "$",
+          maxDecimals: 2,
+          locale: "en-US",
+        },
+        new Dec("0.001")
+      )
+        .inequalitySymbol(false)
+        .toString()
+    ).toBe("$0");
+
+    expect(
+      new PricePretty(
+        {
+          currency: "usd",
+          symbol: "$",
+          maxDecimals: 2,
+          locale: "en-US",
+        },
+        new Dec("-0.001")
+      ).toString()
+    ).toBe("> -$0.01");
+
+    expect(
+      new PricePretty(
+        {
+          currency: "usd",
+          symbol: "$",
+          maxDecimals: 2,
+          locale: "en-US",
+        },
+        new Dec("-0.001")
+      )
+        .inequalitySymbol(false)
+        .toString()
+      // TODO: Delete the case of "-0". Return "0"
+    ).toBe("-$0");
+
+    expect(
+      new PricePretty(
+        {
+          currency: "usd",
+          symbol: "$",
+          maxDecimals: 3,
+          locale: "en-US",
+        },
+        new Dec("0.001")
+      ).toString()
+    ).toBe("$0.001");
+
+    expect(
+      new PricePretty(
+        {
+          currency: "usd",
+          symbol: "$",
+          maxDecimals: 3,
+          locale: "en-US",
+        },
+        new Dec("-0.001")
+      ).toString()
+    ).toBe("-$0.001");
+
+    // PricePretty's maxDecimals behave differently than IntPretty.
+    expect(
+      new PricePretty(
+        {
+          currency: "usd",
+          symbol: "$",
+          maxDecimals: 4,
+          locale: "en-US",
+        },
+        new Dec("0.001")
+      )
+        .trim(false)
+        .toString()
+    ).toBe("$0.001");
   });
 });

package/src/price-pretty.ts

@@ -3,6 +3,7 @@ import { Dec } from "./decimal";
 import { FiatCurrency } from "@keplr-wallet/types";
 import { DeepReadonly } from "utility-types";
 import { DecUtils } from "./dec-utils";
+import bigInteger from "big-integer";
 
 export type PricePrettyOptions = {
   separator: string;
@@ -23,19 +24,14 @@ export class PricePretty {
 
   constructor(
     protected _fiatCurrency: FiatCurrency,
-    protected amount: Dec | { toDec(): Dec }
+    protected amount: Dec | { toDec(): Dec } | bigInteger.BigNumber
   ) {
-    if ("toDec" in amount) {
-      this.intPretty = new IntPretty(amount.toDec());
-    } else {
-      this.intPretty = new IntPretty(amount);
-    }
-
-    this.intPretty = this.intPretty
+    this.intPretty = new IntPretty(amount)
       .maxDecimals(_fiatCurrency.maxDecimals)
       .shrink(true)
       .trim(true)
-      .locale(false);
+      .locale(false)
+      .inequalitySymbol(true);
 
     this._options.locale = _fiatCurrency.locale;
   }
@@ -77,22 +73,30 @@ export class PricePretty {
     return pretty;
   }
 
-  precision(prec: number): PricePretty {
+  moveDecimalPointLeft(delta: number): PricePretty {
     const pretty = this.clone();
-    pretty.intPretty = pretty.intPretty.precision(prec);
+    pretty.intPretty = pretty.intPretty.moveDecimalPointLeft(delta);
     return pretty;
   }
 
-  increasePrecision(delta: number): PricePretty {
+  moveDecimalPointRight(delta: number): PricePretty {
     const pretty = this.clone();
-    pretty.intPretty = pretty.intPretty.increasePrecision(delta);
+    pretty.intPretty = pretty.intPretty.moveDecimalPointRight(delta);
     return pretty;
   }
 
+  /**
+   * @deprecated Use`moveDecimalPointLeft`
+   */
+  increasePrecision(delta: number): PricePretty {
+    return this.moveDecimalPointLeft(delta);
+  }
+
+  /**
+   * @deprecated Use`moveDecimalPointRight`
+   */
   decreasePrecision(delta: number): PricePretty {
-    const pretty = this.clone();
-    pretty.intPretty = pretty.intPretty.decreasePrecision(delta);
-    return pretty;
+    return this.moveDecimalPointRight(delta);
   }
 
   maxDecimals(max: number): PricePretty {
@@ -101,6 +105,18 @@ export class PricePretty {
     return pretty;
   }
 
+  inequalitySymbol(bool: boolean): PricePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.inequalitySymbol(bool);
+    return pretty;
+  }
+
+  inequalitySymbolSeparator(str: string): PricePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.inequalitySymbolSeparator(str);
+    return pretty;
+  }
+
   trim(bool: boolean): PricePretty {
     const pretty = this.clone();
     pretty.intPretty = pretty.intPretty.trim(bool);
@@ -175,29 +191,33 @@ export class PricePretty {
 
     const dec = this.toDec();
     const options = this.options;
-    if (dec.gt(new Dec(0))) {
-      const precision = new Dec(1).quo(
-        DecUtils.getPrecisionDec(this.options.maxDecimals)
+
+    if (
+      options.inequalitySymbol &&
+      !dec.isZero() &&
+      dec.abs().lt(DecUtils.getTenExponentN(-options.maxDecimals))
+    ) {
+      return this.intPretty.toStringWithSymbols(
+        `${symbol}${this._options.separator}`,
+        ""
       );
-      if (dec.lt(precision)) {
-        const precisionLocaleString = parseFloat(
-          precision.toString(options.maxDecimals)
-        ).toLocaleString(options.locale, {
-          maximumFractionDigits: options.maxDecimals,
-        });
-
-        return `< ${symbol}${this._options.separator}${precisionLocaleString}`;
-      }
     }
 
-    const localeString = parseFloat(this.intPretty.toString()).toLocaleString(
+    let localeString = parseFloat(this.intPretty.toString()).toLocaleString(
       options.locale,
       {
         maximumFractionDigits: options.maxDecimals,
       }
     );
 
-    return `${symbol}${this._options.separator}${localeString}`;
+    const isNeg = localeString.charAt(0) === "-";
+    if (isNeg) {
+      localeString = localeString.slice(1);
+    }
+
+    return `${isNeg ? "-" : ""}${symbol}${
+      this._options.separator
+    }${localeString}`;
   }
 
   clone(): PricePretty {

package/src/rate-pretty.spec.ts

@@ -0,0 +1,52 @@
+import { RatePretty } from "./rate-pretty";
+import { Dec } from "./decimal";
+
+describe("Test RatePretty", () => {
+  it("Basic test for RatePretty", () => {
+    const pretty = new RatePretty(new Dec("0.3"));
+
+    expect(pretty.toDec().equals(new Dec("0.3"))).toBe(true);
+    expect(pretty.toDec().toString(1)).toBe("0.3");
+
+    expect(pretty.toString()).toBe("30%");
+    expect(pretty.moveDecimalPointLeft(1).toString()).toBe("3%");
+    expect(pretty.moveDecimalPointRight(1).toString()).toBe("300%");
+
+    expect(pretty.add(new Dec("0.1")).toString()).toBe("40%");
+    expect(pretty.add(new Dec("0.1")).toDec().toString(1)).toBe("0.4");
+    expect(pretty.sub(new Dec("0.1")).toString()).toBe("20%");
+    expect(pretty.sub(new Dec("0.1")).toDec().toString(1)).toBe("0.2");
+    expect(pretty.mul(new Dec("0.1")).toString()).toBe("3%");
+    expect(pretty.mul(new Dec("0.1")).toDec().toString(2)).toBe("0.03");
+    expect(pretty.quo(new Dec("0.1")).toString()).toBe("300%");
+    expect(pretty.quo(new Dec("0.1")).toDec().toString(1)).toBe("3.0");
+
+    expect(new RatePretty(new Dec("0.001")).toString()).toBe("0.1%");
+    expect(new RatePretty(new Dec("0.00001")).toString()).toBe("0.001%");
+    expect(new RatePretty(new Dec("0.000001")).toString()).toBe("< 0.001%");
+
+    expect(new RatePretty(new Dec("0")).toString()).toBe("0%");
+    expect(new RatePretty(new Dec("-0")).toString()).toBe("0%");
+
+    expect(
+      new RatePretty(new Dec("0.000001")).separator(" ").symbol("?").toString()
+    ).toBe("< 0.001 ?");
+
+    expect(
+      new RatePretty(new Dec("0.000001")).inequalitySymbol(false).toString()
+    ).toBe("0%");
+    expect(
+      new RatePretty(new Dec("0.000001"))
+        .inequalitySymbol(false)
+        .maxDecimals(4)
+        .toString()
+    ).toBe("0.0001%");
+
+    expect(new RatePretty(new Dec("-0.000001")).toString()).toBe("> -0.001%");
+
+    expect(
+      new RatePretty(new Dec("-0.000001")).inequalitySymbol(false).toString()
+      // TODO: Delete the case of "-0". Return "0"
+    ).toBe("-0%");
+  });
+});

package/src/rate-pretty.ts

@@ -0,0 +1,165 @@
+import { IntPretty, IntPrettyOptions } from "./int-pretty";
+import { Dec } from "./decimal";
+import { DeepReadonly } from "utility-types";
+import bigInteger from "big-integer";
+
+export type RatePrettyOptions = {
+  separator: string;
+  symbol: string;
+};
+
+/**
+ * RatePretty treats `Dec` in rate form for easy calculation, and displays it as a percentage to the user by using toString().
+ * By default, if the value is less than maxDeciamls, it is displayed using an inequality sign (Ex. < 0.001%)
+ */
+export class RatePretty {
+  protected intPretty: IntPretty;
+
+  protected _options: RatePrettyOptions = {
+    separator: "",
+    symbol: "%",
+  };
+
+  constructor(protected amount: Dec | { toDec(): Dec } | bigInteger.BigNumber) {
+    this.intPretty = new IntPretty(amount);
+
+    this.intPretty = this.intPretty
+      .maxDecimals(3)
+      .shrink(false)
+      .trim(true)
+      .locale(true)
+      .inequalitySymbol(true);
+  }
+
+  get options(): DeepReadonly<
+    Omit<IntPrettyOptions, "locale"> & RatePrettyOptions
+  > {
+    return {
+      ...this.intPretty.options,
+      ...this._options,
+    };
+  }
+
+  separator(str: string): RatePretty {
+    const pretty = this.clone();
+    pretty._options.separator = str;
+    return pretty;
+  }
+
+  symbol(str: string): RatePretty {
+    const pretty = this.clone();
+    pretty._options.symbol = str;
+    return pretty;
+  }
+
+  moveDecimalPointLeft(delta: number): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.moveDecimalPointLeft(delta);
+    return pretty;
+  }
+
+  moveDecimalPointRight(delta: number): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.moveDecimalPointRight(delta);
+    return pretty;
+  }
+
+  maxDecimals(max: number): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.maxDecimals(max);
+    return pretty;
+  }
+
+  inequalitySymbol(bool: boolean): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.inequalitySymbol(bool);
+    return pretty;
+  }
+
+  inequalitySymbolSeparator(str: string): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.inequalitySymbolSeparator(str);
+    return pretty;
+  }
+
+  trim(bool: boolean): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.trim(bool);
+    return pretty;
+  }
+
+  shrink(bool: boolean): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.shrink(bool);
+    return pretty;
+  }
+
+  locale(locale: boolean): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.locale(locale);
+    return pretty;
+  }
+
+  /**
+   * Ready indicates the actual value is ready to show the users.
+   * Even if the ready option is false, it expects that the value can be shown to users (probably as 0).
+   * The method that returns prettied value may return `undefined` or `null` if the value is not ready.
+   * But, alternatively, it can return the 0 value that can be shown the users anyway, but indicates that the value is not ready.
+   * @param bool
+   */
+  ready(bool: boolean): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.ready(bool);
+    return pretty;
+  }
+
+  get isReady(): boolean {
+    return this.intPretty.isReady;
+  }
+
+  add(target: Dec | { toDec(): Dec }): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.add(target);
+    return pretty;
+  }
+
+  sub(target: Dec | { toDec(): Dec }): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.sub(target);
+    return pretty;
+  }
+
+  mul(target: Dec | { toDec(): Dec }): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.mul(target);
+    return pretty;
+  }
+
+  quo(target: Dec | { toDec(): Dec }): RatePretty {
+    const pretty = this.clone();
+    pretty.intPretty = pretty.intPretty.quo(target);
+    return pretty;
+  }
+
+  toDec(): Dec {
+    return this.intPretty.toDec();
+  }
+
+  toString(): string {
+    return this.intPretty
+      .moveDecimalPointRight(2)
+      .toStringWithSymbols(
+        "",
+        `${this._options.separator}${this._options.symbol}`
+      );
+  }
+
+  clone(): RatePretty {
+    const pretty = new RatePretty(this.amount);
+    pretty._options = {
+      ...this._options,
+    };
+    pretty.intPretty = this.intPretty.clone();
+    return pretty;
+  }
+}