@utiliread/primitives 1.0.0-102 → 1.0.0-104

package/src/precision-number.spec.ts

@@ -1,28 +1,28 @@
-import { PrecisionNumber } from "./precision-number";
-import { expect } from "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);
-    });
-});
+import { PrecisionNumber } from "./precision-number";
+import { expect } from "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/register-convention.spec.ts

@@ -1,52 +1,52 @@
-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");
-    });
-});
+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");
+    });
+});

package/src/register-id.ts

@@ -263,6 +263,8 @@ export type RegisterId =
     | "kamstrupMulticalInfocodeType3"
     | "kamstrupMulticalInfocodeType4"
     | "kamstrupMulticalInfocodeType5"
+    | "kamstrupMulticalInfocodeType6"
+    | "kamstrupMulticalInfocodeType7"
     | "kamstrupMulticalInfocode"
     | "kamstrupModuleType"
     | "diehlInfocodeType1"

package/src/register-library.spec.ts

@@ -1,41 +1,41 @@
-import { RegisterDefinition } from ".";
-import { RegisterLibrary } from "./register-library";
-import { expect } from "chai";
-
-const volume: RegisterDefinition = {
-    id: "volume",
-    measure: "volume",
-    aggregate: "instant",
-    units: ["cubicMeter"],
-};
-
-describe("library", () => {
-    beforeEach(() => {
-        RegisterLibrary.reset();
-    });
-
-    it("should get added definition", () => {
-        RegisterLibrary.add(volume);
-        const definition = RegisterLibrary.get("volume");
-        expect(definition.id).to.equal("volume");
-    });
-
-    it("should add all definitions in pack", () => {
-        RegisterLibrary.add({
-            someRandomKey: volume,
-        });
-        const definition = RegisterLibrary.get("volume");
-        expect(definition.id).to.equal("volume");
-    });
-
-    it("should throw when getting not added register", () => {
-        expect(() => RegisterLibrary.get("volume")).to.throw();
-    });
-
-    it("should return all definitions when invoking all()", () => {
-        RegisterLibrary.add(volume);
-        RegisterLibrary.add(volume); // Only added once.
-        const all = RegisterLibrary.all();
-        expect(all.length).to.equal(1);
-    });
-});
+import { RegisterDefinition } from ".";
+import { RegisterLibrary } from "./register-library";
+import { expect } from "chai";
+
+const volume: RegisterDefinition = {
+    id: "volume",
+    measure: "volume",
+    aggregate: "instant",
+    units: ["cubicMeter"],
+};
+
+describe("library", () => {
+    beforeEach(() => {
+        RegisterLibrary.reset();
+    });
+
+    it("should get added definition", () => {
+        RegisterLibrary.add(volume);
+        const definition = RegisterLibrary.get("volume");
+        expect(definition.id).to.equal("volume");
+    });
+
+    it("should add all definitions in pack", () => {
+        RegisterLibrary.add({
+            someRandomKey: volume,
+        });
+        const definition = RegisterLibrary.get("volume");
+        expect(definition.id).to.equal("volume");
+    });
+
+    it("should throw when getting not added register", () => {
+        expect(() => RegisterLibrary.get("volume")).to.throw();
+    });
+
+    it("should return all definitions when invoking all()", () => {
+        RegisterLibrary.add(volume);
+        RegisterLibrary.add(volume); // Only added once.
+        const all = RegisterLibrary.all();
+        expect(all.length).to.equal(1);
+    });
+});

package/src/registers/kamstrup-multical-infocode.ts

@@ -42,3 +42,17 @@ export const kamstrupMulticalInfocodeType5: RegisterDefinition = {
     aggregate: "instant",
     units,
 };
+
+export const kamstrupMulticalInfocodeType6: RegisterDefinition = {
+    id: "kamstrupMulticalInfocodeType6",
+    measure: "none",
+    aggregate: "instant",
+    units,
+};
+
+export const kamstrupMulticalInfocodeType7: RegisterDefinition = {
+    id: "kamstrupMulticalInfocodeType7",
+    measure: "none",
+    aggregate: "instant",
+    units,
+};

package/src/repository.spec.ts

@@ -1,20 +1,20 @@
-import { Repository } from "./repository";
-import { expect } from "chai";
-
-describe("ctor", () => {
-    it("creates", () => {
-        expect(Repository("gpkv", "gjoel")).to.equal("gpkv/gjoel");
-        expect(Repository("gpkv/gjoel")).to.equal("gpkv/gjoel");
-    });
-    it("throws if wrong format", () => {
-        expect(() => Repository("invalid")).to.throw();
-    });
-});
-
-describe("split", () => {
-    it("splits into correct parts", () => {
-        const { team, name } = Repository.split(Repository("gpkv", "gjoel"));
-        expect(team).to.equal("gpkv");
-        expect(name).to.equal("gjoel");
-    });
-});
+import { Repository } from "./repository";
+import { expect } from "chai";
+
+describe("ctor", () => {
+    it("creates", () => {
+        expect(Repository("gpkv", "gjoel")).to.equal("gpkv/gjoel");
+        expect(Repository("gpkv/gjoel")).to.equal("gpkv/gjoel");
+    });
+    it("throws if wrong format", () => {
+        expect(() => Repository("invalid")).to.throw();
+    });
+});
+
+describe("split", () => {
+    it("splits into correct parts", () => {
+        const { team, name } = Repository.split(Repository("gpkv", "gjoel"));
+        expect(team).to.equal("gpkv");
+        expect(name).to.equal("gjoel");
+    });
+});

package/src/step.spec.ts

@@ -1,37 +1,37 @@
-import { DayOfWeek, Step } from "./step";
-
-import { DateTime } from "luxon";
-import { expect } from "chai";
-
-describe("startOf", () => {
-    it("returns start of day", () => {
-        const dt = DateTime.fromISO("2020-01-11T05:00:00+01:00");
-        const result = Step.startOf(dt, "day");
-        expect(+result).to.equal(
-            +DateTime.fromISO("2020-01-11T00:00:00+01:00"),
-        );
-    });
-
-    it("returns previous monday from saturday", () => {
-        const dt = DateTime.fromISO("2020-01-11T05:00:00+01:00");
-        const result = Step.startOf(dt, "week", DayOfWeek.Monday);
-        expect(+result).to.equal(
-            +DateTime.fromISO("2020-01-06T00:00:00+01:00"),
-        );
-    });
-
-    it("returns same monday from monday with hour", () => {
-        const dt = DateTime.fromISO("2020-01-13T05:00:00+01:00");
-        const result = Step.startOf(dt, "week", DayOfWeek.Monday);
-        expect(+result).to.equal(
-            +DateTime.fromISO("2020-01-13T00:00:00+01:00"),
-        );
-    });
-});
-
-describe("asDuration", () => {
-    it("should return equivalent duration", () => {
-        const duration = Step.asDuration("week");
-        expect(duration.days).to.equal(7);
-    });
-});
+import { DayOfWeek, Step } from "./step";
+
+import { DateTime } from "luxon";
+import { expect } from "chai";
+
+describe("startOf", () => {
+    it("returns start of day", () => {
+        const dt = DateTime.fromISO("2020-01-11T05:00:00+01:00");
+        const result = Step.startOf(dt, "day");
+        expect(+result).to.equal(
+            +DateTime.fromISO("2020-01-11T00:00:00+01:00"),
+        );
+    });
+
+    it("returns previous monday from saturday", () => {
+        const dt = DateTime.fromISO("2020-01-11T05:00:00+01:00");
+        const result = Step.startOf(dt, "week", DayOfWeek.Monday);
+        expect(+result).to.equal(
+            +DateTime.fromISO("2020-01-06T00:00:00+01:00"),
+        );
+    });
+
+    it("returns same monday from monday with hour", () => {
+        const dt = DateTime.fromISO("2020-01-13T05:00:00+01:00");
+        const result = Step.startOf(dt, "week", DayOfWeek.Monday);
+        expect(+result).to.equal(
+            +DateTime.fromISO("2020-01-13T00:00:00+01:00"),
+        );
+    });
+});
+
+describe("asDuration", () => {
+    it("should return equivalent duration", () => {
+        const duration = Step.asDuration("week");
+        expect(duration.days).to.equal(7);
+    });
+});

package/src/time-or-rule.ts

@@ -1,44 +1,42 @@
-import { DateTime } from "luxon";
-
-export type TimeOrRule = Date | DateTime<true> | string;
-
-export function TimeOrRule(
-    timeOrRule: Date | DateTime<true> | string,
-): TimeOrRule {
-    return timeOrRule;
-}
-
-export namespace TimeOrRule {
-    export function parse(input: string): TimeOrRule {
-        const time = DateTime.fromISO(input, { setZone: true });
-        return time.isValid ? time : input;
-    }
-
-    export function isTime(input: TimeOrRule): input is Date | DateTime<true> {
-        return typeof input !== "string";
-    }
-
-    export function isRule(input: TimeOrRule): input is string {
-        return typeof input === "string";
-    }
-
-    export function asDateTime(input: TimeOrRule): DateTime<true> | undefined {
-        if (isRule(input)) {
-            return;
-        }
-        else if (DateTime.isDateTime(input)) {
-            return input;
-        }
-        else {
-            const dateTime = DateTime.fromJSDate(input);
-            if (!dateTime.isValid) {
-                throw new Error("Unable to convert from Date to DateTime");
-            }
-            return dateTime;
-        }
-    }
-
-    export function toJSON(input: TimeOrRule) {
-        return isRule(input) ? input : input.toJSON();
-    }
-}
+import { DateTime } from "luxon";
+
+export type TimeOrRule = Date | DateTime<true> | string;
+
+export function TimeOrRule(
+    timeOrRule: Date | DateTime<true> | string,
+): TimeOrRule {
+    return timeOrRule;
+}
+
+export namespace TimeOrRule {
+    export function parse(input: string): TimeOrRule {
+        const time = DateTime.fromISO(input, { setZone: true });
+        return time.isValid ? time : input;
+    }
+
+    export function isTime(input: TimeOrRule): input is Date | DateTime<true> {
+        return typeof input !== "string";
+    }
+
+    export function isRule(input: TimeOrRule): input is string {
+        return typeof input === "string";
+    }
+
+    export function asDateTime(input: TimeOrRule): DateTime<true> | undefined {
+        if (isRule(input)) {
+            return;
+        } else if (DateTime.isDateTime(input)) {
+            return input;
+        } else {
+            const dateTime = DateTime.fromJSDate(input);
+            if (!dateTime.isValid) {
+                throw new Error("Unable to convert from Date to DateTime");
+            }
+            return dateTime;
+        }
+    }
+
+    export function toJSON(input: TimeOrRule) {
+        return isRule(input) ? input : input.toJSON();
+    }
+}

package/src/unit-id.ts

@@ -8,6 +8,7 @@ export type UnitId =
     | "calorie"
     | "kiloCalorie"
     | "megaCalorie"
+    | "gigaCalorie"
     | "joule"
     | "kiloJoule"
     | "megaJoule"