@utiliread/primitives 1.0.0-74 → 1.0.0-76

package/src/number-formatter.ts

@@ -38,50 +38,73 @@ class Formatter {
             : value.toPrecision(precision);
     }
 
-    public toLocalePrecision(value: number, precision: number, maxDecimals?: number) {
-        return this.toPrecision(value, precision, maxDecimals)
-            .replace(invariantDecimalSeparator, localeDecimalSeparator);
+    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 number = parts.invariantCoefficientString.replace(
+                invariantDecimalSeparator,
+                "",
+            );
             const zeros = parts.exponent - parts.noOfCoefficientDecimals;
             return `${number}${"0".repeat(zeros)}`;
-        }
-        else {
+        } else {
             return parts.invariantPrecisionString;
         }
     }
 
-    public toLocaleFixed(value: number, precision: number, maxDecimals?: number) {
-        return this.toFixed(value, precision, maxDecimals)
-            .replace(invariantDecimalSeparator, localeDecimalSeparator);
+    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 {
+    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;
+            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;
+        } else {
+            const decimalSeparatorIndex = precisionString.indexOf(
+                invariantDecimalSeparator,
+            );
+            const noOfCoefficientDecimals =
+                decimalSeparatorIndex >= 0
+                    ? precisionString.length - decimalSeparatorIndex - 1
+                    : 0;
             return {
                 invariantPrecisionString: precisionString,
                 invariantCoefficientString: precisionString,

package/src/optional.ts

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

package/src/precision-number.spec.ts

@@ -1,28 +1,28 @@
-import { expect } from "chai";
-import { PrecisionNumber } from "./precision-number";
-
-describe("precision-number", () => {
-    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 '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);
-    });
-});
+import { PrecisionNumber } from "./precision-number";
+import { expect } from "@esm-bundle/chai";
+
+describe("precision-number", () => {
+    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 '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);
+    });
+});

package/src/precision-number.ts

@@ -1,36 +1,44 @@
-import { invariantDecimalSeparator } from ".";
-import { localeDecimalSeparator, NumberFormatter } from "./number-formatter";
-
-export class PrecisionNumber {
-    constructor(public value: number, public precision: number) {
-    }
-
-    static parse(input: string) {
-        let normalized = input.trim().replace(",", ".").replace(localeDecimalSeparator, invariantDecimalSeparator);
-        if (normalized.endsWith(invariantDecimalSeparator)) {
-            normalized += "0";
-        }
-        const precision = normalized.replace(".", "").replace("+", "").replace("-", "").length;
-        return new PrecisionNumber(parseFloat(normalized), precision);
-    }
-
-    toString() {
-        return this.value.toString();
-    }
-
-    toFixed() {
-        return NumberFormatter.toFixed(this.value, this.precision);
-    }
-
-    toPrecision() {
-        return NumberFormatter.toPrecision(this.value, this.precision);
-    }
-
-    toLocaleFixed() {
-        return NumberFormatter.toLocaleFixed(this.value, this.precision);
-    }
-
-    toLocalePrecision() {
-        return NumberFormatter.toLocalePrecision(this.value, this.precision);
-    }
-}
+import { invariantDecimalSeparator } from ".";
+import { localeDecimalSeparator, NumberFormatter } from "./number-formatter";
+
+export class PrecisionNumber {
+    constructor(
+        public value: number,
+        public precision: number,
+    ) {}
+
+    static parse(input: string) {
+        let normalized = input
+            .trim()
+            .replace(",", ".")
+            .replace(localeDecimalSeparator, invariantDecimalSeparator);
+        if (normalized.endsWith(invariantDecimalSeparator)) {
+            normalized += "0";
+        }
+        const precision = normalized
+            .replace(".", "")
+            .replace("+", "")
+            .replace("-", "").length;
+        return new PrecisionNumber(parseFloat(normalized), precision);
+    }
+
+    toString() {
+        return this.value.toString();
+    }
+
+    toFixed() {
+        return NumberFormatter.toFixed(this.value, this.precision);
+    }
+
+    toPrecision() {
+        return NumberFormatter.toPrecision(this.value, this.precision);
+    }
+
+    toLocaleFixed() {
+        return NumberFormatter.toLocaleFixed(this.value, this.precision);
+    }
+
+    toLocalePrecision() {
+        return NumberFormatter.toLocalePrecision(this.value, this.precision);
+    }
+}

package/src/register-convention.spec.ts

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

package/src/register-convention.ts

@@ -1,4 +1,4 @@
-import { RegisterDefinition } from ".";
+import { RegisterDefinition } from "./register-definition";
 import { AggregateId } from "./aggregate-id";
 import { RegisterId } from "./register-id";
 import { getRegisterId } from "./register-utils";
@@ -40,22 +40,31 @@ class Convention {
         return registerId;
     }
 
-    toAggregate(register: RegisterId | RegisterDefinition, aggregate: AggregateId) {
+    toAggregate(
+        register: RegisterId | RegisterDefinition,
+        aggregate: AggregateId,
+    ) {
         const instantRegisterId = this.toInstant(register);
         if (aggregate === "instant") {
             return instantRegisterId;
         }
         const prefix = aggregatePrefixes[aggregate];
-        return <RegisterId>(prefix + instantRegisterId[0].toUpperCase() + instantRegisterId.substr(1));
+        return <RegisterId>(
+            (prefix +
+                instantRegisterId[0].toUpperCase() +
+                instantRegisterId.substr(1))
+        );
     }
 }
 
 export function isPrefix(registerId: RegisterId, prefix: string) {
-    return registerId.startsWith(prefix) && isUppercase(registerId[prefix.length]);
+    return (
+        registerId.startsWith(prefix) && isUppercase(registerId[prefix.length])
+    );
 }
 
 function isUppercase(input: string) {
     return input.toUpperCase() === input;
 }
 
-export const RegisterConvention = new Convention();
+export const RegisterConvention = new Convention();

package/src/register-definition.ts

@@ -1,23 +1,23 @@
-import { UnitId } from ".";
-import { AggregateId } from "./aggregate-id";
-import { MeasureId } from "./measure-id";
-import { RegisterId } from "./register-id";
-
-export interface RegisterDefinition {
-    /// The id of the register
-    id: RegisterId;
-    /// The register measure
-    measure: MeasureId;
-    /// The aggregate of the register
-    aggregate: AggregateId;
-    /// The possible register units
-    units: ReadonlyArray<UnitId>;
-    /// Whether the register can only be resolved by "present value".
-    immediate?: true;
-    /// An optional concise register name.
-    /// Only used for custom registers as locales exist for standard registers.
-    name?: string;
-    /// An optional register description.
-    /// Only used for custom registers as locales exist for standard registers.
-    description?: string;
-}
+import { AggregateId } from "./aggregate-id";
+import { MeasureId } from "./measure-id";
+import { RegisterId } from "./register-id";
+import { UnitId } from "./unit-id";
+
+export interface RegisterDefinition {
+    /// The id of the register
+    id: RegisterId;
+    /// The register measure
+    measure: MeasureId;
+    /// The aggregate of the register
+    aggregate: AggregateId;
+    /// The possible register units
+    units: ReadonlyArray<UnitId>;
+    /// Whether the register can only be resolved by "present value".
+    immediate?: true;
+    /// An optional concise register name.
+    /// Only used for custom registers as locales exist for standard registers.
+    name?: string;
+    /// An optional register description.
+    /// Only used for custom registers as locales exist for standard registers.
+    description?: string;
+}