@utiliread/primitives 1.0.0-14 → 1.0.0-140

package/src/number-formatter.ts

@@ -1,50 +1,118 @@
-const invariantDecimalSeparator = (0.1).toString()[1];
-const localeDecimalSeparator = (0.1).toLocaleString()[1];
-
-class Formatter {
-    public toLocalePrecision(value: number, precision: number) {
-        const absValue = Math.abs(value);
-        if (absValue < 1) {
-            return toPrecision(value, precision);
-        }
-
-        const noOfIntegerDigits = Math.round(absValue).toString().length;
-        return precision >= noOfIntegerDigits
-            ? toFixed(value, precision - noOfIntegerDigits)
-            : toPrecision(value, precision);
-    }
-
-    public toLocaleFixed(value: number, precision: number) {
-        const formatted = this.toLocalePrecision(value, precision);
-        const match = /(.*)e\+(\d)$/.exec(formatted);
-        if (match) {
-            let number = match[1];
-            let exponent = parseInt(match[2]);
-            const decimalSeparatorIndex = number.indexOf(localeDecimalSeparator);
-            if (decimalSeparatorIndex === -1) {
-                return `${number}${"0".repeat(exponent)}`;
-            }
-            else if (decimalSeparatorIndex >= 0) {
-                const noOfDecimals = number.length - decimalSeparatorIndex - 1;
-                if (noOfDecimals < exponent) {
-                    number = number.replace(localeDecimalSeparator, "");
-                    exponent -= noOfDecimals;
-                    return `${number}${"0".repeat(exponent)}`;
-                }
-            }
-        }
-        return formatted;
-    }
-}
-
-function toFixed(value: number, fractionDigits: number) {
-    const formatted = value.toFixed(fractionDigits);
-    return formatted.replace(invariantDecimalSeparator, localeDecimalSeparator);
-}
-
-function toPrecision(value: number, precision: number) {
-    const formatted = value.toPrecision(precision);
-    return formatted.replace(invariantDecimalSeparator, localeDecimalSeparator);
-}
-
-export const NumberFormatter = new Formatter();
+export const invariantDecimalSeparator = (0.1).toString()[1];
+export const localeDecimalSeparator = (0.1).toLocaleString()[1];
+
+export interface Parts {
+    invariantPrecisionString: string;
+    invariantCoefficientString: string;
+    exponent: number;
+    noOfCoefficientDecimals: number;
+}
+
+class Formatter {
+    public toPrecision(value: number, precision: number, maxDecimals?: number) {
+        const absValue = Math.abs(value);
+        const noOfIntegerDigits = Math.round(absValue).toString().length;
+
+        // Adjust precision to maxDecimals
+        if (maxDecimals !== undefined) {
+            precision = Math.min(precision, noOfIntegerDigits + maxDecimals);
+        }
+
+        if (value === 0) {
+            // (0).toPrecision(1) == "0"
+            // (0).toPrecision(2) == "0.0"
+            // (0).toPrecision(3) == "0.00"
+            // However, we want:
+            // Formatter.toPrecision(0, 0) == "0"
+            // Formatter.toPrecision(0, 1) == "0.0"
+            // Formatter.toPrecision(0, 2) == "0.00"
+            return value.toPrecision(precision + 1);
+        }
+
+        if (absValue < 1) {
+            return value.toPrecision(precision);
+        }
+
+        return precision >= noOfIntegerDigits
+            ? value.toFixed(precision - noOfIntegerDigits)
+            : value.toPrecision(precision);
+    }
+
+    public toLocalePrecision(
+        value: number,
+        precision: number,
+        maxDecimals?: number,
+    ) {
+        return this.toPrecision(value, precision, maxDecimals).replace(
+            invariantDecimalSeparator,
+            localeDecimalSeparator,
+        );
+    }
+
+    public toFixed(value: number, precision: number, maxDecimals?: number) {
+        const parts = this.getParts(value, precision, maxDecimals);
+        if (parts.noOfCoefficientDecimals < parts.exponent) {
+            const number = parts.invariantCoefficientString.replace(
+                invariantDecimalSeparator,
+                "",
+            );
+            const zeros = parts.exponent - parts.noOfCoefficientDecimals;
+            return `${number}${"0".repeat(zeros)}`;
+        } else {
+            return parts.invariantPrecisionString;
+        }
+    }
+
+    public toLocaleFixed(
+        value: number,
+        precision: number,
+        maxDecimals?: number,
+    ) {
+        return this.toFixed(value, precision, maxDecimals).replace(
+            invariantDecimalSeparator,
+            localeDecimalSeparator,
+        );
+    }
+
+    public getParts(
+        value: number,
+        precision: number,
+        maxDecimals?: number,
+    ): Parts {
+        const precisionString = this.toPrecision(value, precision, maxDecimals);
+        if (precisionString.indexOf("e") >= 0) {
+            const match = /(.*)e([\+-]\d+)$/.exec(precisionString)!;
+            const coefficientString = match[1];
+            const exponent = parseInt(match[2]);
+            const decimalSeparatorIndex = coefficientString.indexOf(
+                invariantDecimalSeparator,
+            );
+            const noOfCoefficientDecimals =
+                decimalSeparatorIndex >= 0
+                    ? coefficientString.length - decimalSeparatorIndex - 1
+                    : 0;
+            return {
+                invariantPrecisionString: precisionString,
+                invariantCoefficientString: coefficientString,
+                exponent,
+                noOfCoefficientDecimals,
+            };
+        } else {
+            const decimalSeparatorIndex = precisionString.indexOf(
+                invariantDecimalSeparator,
+            );
+            const noOfCoefficientDecimals =
+                decimalSeparatorIndex >= 0
+                    ? precisionString.length - decimalSeparatorIndex - 1
+                    : 0;
+            return {
+                invariantPrecisionString: precisionString,
+                invariantCoefficientString: precisionString,
+                exponent: 0,
+                noOfCoefficientDecimals,
+            };
+        }
+    }
+}
+
+export const NumberFormatter = new Formatter();

package/src/optional.ts

@@ -0,0 +1 @@
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;

package/src/precision-number.spec.ts

@@ -0,0 +1,251 @@
+import { PrecisionNumber } from "./precision-number";
+import { expect } from "chai";
+
+describe("new", () => {
+    it("should create 0", () => {
+        const number = new PrecisionNumber(0);
+        expect(number.value).to.equal(0);
+        expect(number.precision).to.equal(1);
+    });
+
+    it("should create 0.5", () => {
+        const number = new PrecisionNumber(0.5);
+        expect(number.value).to.equal(0.5);
+        expect(number.precision).to.equal(1);
+    });
+
+    it("should create 0.05", () => {
+        const number = new PrecisionNumber(0.05);
+        expect(number.value).to.equal(0.05);
+        expect(number.precision).to.equal(2);
+    });
+
+    it("should create 1.05", () => {
+        const number = new PrecisionNumber(1.05);
+        expect(number.value).to.equal(1.05);
+        expect(number.precision).to.equal(3);
+    });
+
+    it("should create 100", () => {
+        const number = new PrecisionNumber(100);
+        expect(number.value).to.equal(100);
+        expect(number.precision).to.equal(3);
+    });
+});
+
+describe("parse", () => {
+    it("should not parse ''", () => {
+        const number = PrecisionNumber.parse("");
+        expect(Number.isNaN(number.value)).to.equal(true);
+        expect(number.precision).to.equal(0);
+    });
+
+    it("should parse '0'", () => {
+        const number = PrecisionNumber.parse("0");
+        expect(number.value).to.equal(0);
+        expect(number.precision).to.equal(1);
+    });
+
+    it("should parse '0.0'", () => {
+        const number = PrecisionNumber.parse("0.0");
+        expect(number.value).to.equal(0);
+        expect(number.precision).to.equal(1);
+    });
+
+    it("should parse '1'", () => {
+        const number = PrecisionNumber.parse("1");
+        expect(number.value).to.equal(1);
+        expect(number.precision).to.equal(1);
+    });
+
+    it("should parse '1.'", () => {
+        const number = PrecisionNumber.parse("1.");
+        expect(number.value).to.equal(1);
+        expect(number.precision).to.equal(2);
+    });
+
+    it("should parse '1.0'", () => {
+        const number = PrecisionNumber.parse("1.0");
+        expect(number.value).to.equal(1);
+        expect(number.precision).to.equal(2);
+    });
+
+    it("should parse '0.6'", () => {
+        const number = PrecisionNumber.parse("0.6");
+        expect(number.value).to.equal(0.6);
+        expect(number.precision).to.equal(1);
+    });
+
+    it("should parse '.6'", () => {
+        const number = PrecisionNumber.parse(".6");
+        expect(number.value).to.equal(0.6);
+        expect(number.precision).to.equal(1);
+    });
+
+    it("should parse '.06'", () => {
+        const number = PrecisionNumber.parse(".06");
+        expect(number.value).to.equal(0.06);
+        expect(number.precision).to.equal(1);
+    });
+
+    it("should parse with leading zeros '00012'", () => {
+        const number = PrecisionNumber.parse("00012");
+        expect(number.value).to.equal(12);
+        expect(number.precision).to.equal(2);
+    });
+
+    it("should parse with leading zeros '000.12'", () => {
+        const number = PrecisionNumber.parse("000.12");
+        expect(number.value).to.equal(0.12);
+        expect(number.precision).to.equal(2);
+    });
+
+    it("should parse with leading zeros '000.012'", () => {
+        const number = PrecisionNumber.parse("000.012");
+        expect(number.value).to.equal(0.012);
+        expect(number.precision).to.equal(2);
+    });
+
+    it("should parse with leading zeros '00012.3'", () => {
+        const number = PrecisionNumber.parse("00012.3");
+        expect(number.value).to.equal(12.3);
+        expect(number.precision).to.equal(3);
+    });
+});
+
+describe("plus", () => {
+    const data = [
+        [
+            new PrecisionNumber(2, 1),
+            new PrecisionNumber(10, 2),
+            new PrecisionNumber(12, 2),
+        ],
+        [
+            new PrecisionNumber(2, 1),
+            new PrecisionNumber(-10, 2),
+            new PrecisionNumber(-8, 1),
+        ],
+        [
+            new PrecisionNumber(-2, 1),
+            new PrecisionNumber(10, 2),
+            new PrecisionNumber(8, 1),
+        ],
+        [
+            new PrecisionNumber(-2, 1),
+            new PrecisionNumber(-10, 2),
+            new PrecisionNumber(-12, 2),
+        ],
+        [
+            new PrecisionNumber(2, 1),
+            new PrecisionNumber(10, 3),
+            new PrecisionNumber(12, 2),
+        ],
+        [
+            new PrecisionNumber(2, 3),
+            new PrecisionNumber(10, 3),
+            new PrecisionNumber(12, 3),
+        ],
+        [
+            new PrecisionNumber(0.12, 2),
+            new PrecisionNumber(1, 2),
+            new PrecisionNumber(1.12, 2),
+        ],
+        [
+            new PrecisionNumber(0.12, 2),
+            new PrecisionNumber(1, 3),
+            new PrecisionNumber(1.12, 3),
+        ],
+        [
+            new PrecisionNumber(123456, 6),
+            new PrecisionNumber(1, 2),
+            new PrecisionNumber(123457, 6),
+        ],
+        [
+            new PrecisionNumber(1, 1),
+            new PrecisionNumber(1024, 3),
+            new PrecisionNumber(1025, 3),
+        ],
+        [
+            new PrecisionNumber(0, 0),
+            new PrecisionNumber(1024, 3),
+            new PrecisionNumber(1024, 3),
+        ],
+        [
+            new PrecisionNumber(0, 1),
+            new PrecisionNumber(1024, 3),
+            new PrecisionNumber(1024, 3),
+        ],
+    ];
+
+    it("should plus correctly", () => {
+        for (const [left, right, expected] of data) {
+            const result = left.plus(right);
+            expect(result.value).to.equal(expected.value);
+            expect(result.precision).to.equal(expected.precision);
+        }
+    });
+});
+
+describe("minus", () => {
+    const data = [
+        [
+            new PrecisionNumber(132900, 4),
+            new PrecisionNumber(132892, 6),
+            new PrecisionNumber(8, 1),
+        ],
+        [
+            new PrecisionNumber(123, 2),
+            new PrecisionNumber(0, 0),
+            new PrecisionNumber(123, 2),
+        ],
+        [
+            new PrecisionNumber(123, 2),
+            new PrecisionNumber(0, 1),
+            new PrecisionNumber(123, 2),
+        ],
+    ];
+
+    it("should minus correctly", () => {
+        for (const [left, right, expected] of data) {
+            const result = left.minus(right);
+            expect(result.value).to.equal(expected.value);
+            expect(result.precision).to.equal(expected.precision);
+        }
+    });
+});
+
+describe("toString", () => {
+    it("should return a rounded version in toFixed", () => {
+        expect(new PrecisionNumber(2474.581, 6).toFixed()).to.equal("2474.58");
+        expect(new PrecisionNumber(2474.589, 6).toFixed()).to.equal("2474.59");
+        expect(new PrecisionNumber(-2474.581, 6).toFixed()).to.equal(
+            "-2474.58",
+        );
+        expect(new PrecisionNumber(-2474.589, 6).toFixed()).to.equal(
+            "-2474.59",
+        );
+    });
+});
+
+describe("compare", () => {
+    it("should return a rounded version in valueOf", () => {
+        expect(new PrecisionNumber(2474.581, 6).valueOf()).to.equal(2474.58);
+        expect(new PrecisionNumber(2474.589, 6).valueOf()).to.equal(2474.59);
+        expect(new PrecisionNumber(-2474.581, 6).valueOf()).to.equal(-2474.58);
+        expect(new PrecisionNumber(-2474.589, 6).valueOf()).to.equal(-2474.59);
+    });
+
+    it("should compare leq and geq, precision with decimals", () => {
+        const value = new PrecisionNumber(2474.58, 6);
+        expect(value.toPrecision()).to.equal("2474.58");
+        expect(new PrecisionNumber(2474.580078125, 6) <= value).to.equal(true);
+        expect(new PrecisionNumber(2474.580078125, 6) >= value).to.equal(true);
+    });
+
+    it("should compare leq and geq, precision without decimals", () => {
+        const value = new PrecisionNumber(2474.58, 2);
+        expect(value.toPrecision()).to.equal("2.5e+3");
+        expect(new PrecisionNumber(2474.580078125, 2) <= value).to.equal(true);
+        expect(new PrecisionNumber(2474.580078125, 2) >= value).to.equal(true);
+    });
+});

package/src/precision-number.ts

@@ -0,0 +1,129 @@
+import {
+    NumberFormatter,
+    invariantDecimalSeparator,
+    localeDecimalSeparator,
+} from "./number-formatter";
+
+export class PrecisionNumber {
+    public value: number;
+    public precision: number;
+    constructor(value: number, precision?: number) {
+        this.value = value;
+        this.precision = precision ?? getPrecision(value);
+    }
+
+    static parse(input: string) {
+        let normalized = input
+            .trim()
+            .replace(",", ".")
+            .replace(localeDecimalSeparator, invariantDecimalSeparator);
+
+        if (normalized.endsWith(invariantDecimalSeparator)) {
+            normalized += "0";
+        }
+
+        const value = parseFloat(normalized);
+        const precision =
+            value === 0
+                ? 1
+                : normalized
+                      .replace(".", "")
+                      .replace("+", "")
+                      .replace("-", "")
+                      .replace(/^0+/, "").length;
+        return new PrecisionNumber(value, precision);
+    }
+
+    abs() {
+        return new PrecisionNumber(Math.abs(this.value), this.precision);
+    }
+
+    plus(rhs: PrecisionNumber) {
+        // The result should have the same number of decimal places as the minimum of the two inputs
+        const lhs = this;
+        const value = lhs.value + rhs.value;
+        const decimals = Math.min(
+            getNumberOfDecimalDigits(lhs.value, lhs.precision),
+            getNumberOfDecimalDigits(rhs.value, rhs.precision),
+        );
+        const precision = getPrecision(value, decimals);
+        return new PrecisionNumber(value, precision);
+    }
+
+    minus(rhs: PrecisionNumber) {
+        // The result should have the same number of decimal places as the minimum of the two inputs
+        const lhs = this;
+        const value = lhs.value - rhs.value;
+        const decimals = Math.min(
+            getNumberOfDecimalDigits(lhs.value, lhs.precision),
+            getNumberOfDecimalDigits(rhs.value, rhs.precision),
+        );
+        const precision = getPrecision(value, decimals);
+        return new PrecisionNumber(value, precision);
+    }
+
+    valueOf() {
+        const decimals = getNumberOfDecimalDigits(this.value, this.precision);
+        const scale = Math.pow(10, decimals);
+        const integer = Math.round(this.value * scale);
+        const value = integer / scale;
+        return value;
+    }
+
+    toString() {
+        return this.valueOf().toString();
+    }
+
+    toFixed() {
+        return NumberFormatter.toFixed(this.valueOf(), this.precision);
+    }
+
+    toPrecision() {
+        return NumberFormatter.toPrecision(this.valueOf(), this.precision);
+    }
+
+    toLocaleFixed() {
+        return NumberFormatter.toLocaleFixed(this.valueOf(), this.precision);
+    }
+
+    toLocalePrecision() {
+        return NumberFormatter.toLocalePrecision(
+            this.valueOf(),
+            this.precision,
+        );
+    }
+}
+
+function getPrecision(number: number, decimals?: number) {
+    decimals ??= number.toString().split(".", 2)[1]?.length ?? 0;
+
+    if (number == 0) {
+        return 1;
+    } else if (number > -1 && number < 1) {
+        return decimals;
+    } else {
+        return Math.max(getNumberOfIntegralDigits(number) + decimals, 1);
+    }
+}
+
+function getNumberOfDecimalDigits(number: number, precision: number) {
+    if (number > -1 && number < 1) {
+        return precision;
+    } else {
+        return precision - getNumberOfIntegralDigits(number);
+    }
+}
+
+function getNumberOfIntegralDigits(number: number) {
+    const abs = Math.abs(number);
+    if (abs < 10) return 1;
+    if (abs < 100) return 2;
+    if (abs < 1000) return 3;
+    if (abs < 10000) return 4;
+    if (abs < 100000) return 5;
+    if (abs < 1000000) return 6;
+    if (abs < 10000000) return 7;
+    if (abs < 100000000) return 8;
+    if (abs < 1000000000) return 9;
+    return Math.floor(Math.log10(abs) + 1);
+}

package/src/register-convention.spec.ts

@@ -1,43 +1,52 @@
-import { expect } from "chai";
-import { RegisterConvention } from "./register-convention";
-
-describe("getAggregate", () => {
-    it("instant register is instant", () => {
-        const result = RegisterConvention.getAggregate("flowTemperature");
-        expect(result).to.equal("instant");
-    });
-
-    it("avg register is avg", () => {
-        const result = RegisterConvention.getAggregate("avgFlowTemperature");
-        expect(result).to.equal("avg");
-    });
-});
-
-describe("toInstant", () => {
-    it("should convert instant", () => {
-        const registerId = RegisterConvention.toInstant("flowTemperature");
-        expect(registerId).to.equal("flowTemperature");
-    });
-
-    it("should convert aggregate", () => {
-        const registerId = RegisterConvention.toInstant("avgFlowTemperature");
-        expect(registerId).to.equal("flowTemperature");
-    });
-});
-
-describe("toAggregate", () => {
-    it("should convert instant to aggregate", () => {
-        const registerId = RegisterConvention.toAggregate("flowTemperature", "avg");
-        expect(registerId).to.equal("avgFlowTemperature");
-    });
-
-    it("should convert aggregate to same aggregate", () => {
-        const registerId = RegisterConvention.toAggregate("avgFlowTemperature", "avg");
-        expect(registerId).to.equal("avgFlowTemperature");
-    });
-
-    it("should convert aggregate to other aggregate", () => {
-        const registerId = RegisterConvention.toAggregate("avgFlowTemperature", "min");
-        expect(registerId).to.equal("minFlowTemperature");
-    });
-});
+import { RegisterConvention } from "./register-convention";
+import { expect } from "chai";
+
+describe("getAggregate", () => {
+    it("instant register is instant", () => {
+        const result = RegisterConvention.getAggregate("flowTemperature");
+        expect(result).to.equal("instant");
+    });
+
+    it("avg register is avg", () => {
+        const result = RegisterConvention.getAggregate("avgFlowTemperature");
+        expect(result).to.equal("avg");
+    });
+});
+
+describe("toInstant", () => {
+    it("should convert instant", () => {
+        const registerId = RegisterConvention.toInstant("flowTemperature");
+        expect(registerId).to.equal("flowTemperature");
+    });
+
+    it("should convert aggregate", () => {
+        const registerId = RegisterConvention.toInstant("avgFlowTemperature");
+        expect(registerId).to.equal("flowTemperature");
+    });
+});
+
+describe("toAggregate", () => {
+    it("should convert instant to aggregate", () => {
+        const registerId = RegisterConvention.toAggregate(
+            "flowTemperature",
+            "avg",
+        );
+        expect(registerId).to.equal("avgFlowTemperature");
+    });
+
+    it("should convert aggregate to same aggregate", () => {
+        const registerId = RegisterConvention.toAggregate(
+            "avgFlowTemperature",
+            "avg",
+        );
+        expect(registerId).to.equal("avgFlowTemperature");
+    });
+
+    it("should convert aggregate to other aggregate", () => {
+        const registerId = RegisterConvention.toAggregate(
+            "avgFlowTemperature",
+            "min",
+        );
+        expect(registerId).to.equal("minFlowTemperature");
+    });
+});