@utiliread/primitives 1.0.0-14 → 1.0.0-141

package/src/register-library.spec.ts

@@ -1,34 +1,41 @@
-import { expect } from "chai";
-import { RegisterDefinition } from ".";
-import { RegisterLibrary } from "./register-library";
-
-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();
-    });
-});
+import type { 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/register-library.ts

@@ -1,41 +1,64 @@
-import { RegisterDefinition } from "./register-definition";
-import { RegisterId } from "./register-id";
-import { RegisterPack } from "./register-pack";
-
-class Library {
-    private definitions: Partial<{ [id in RegisterId]: RegisterDefinition }> = {};
-    public add(...definitions: (RegisterDefinition | RegisterPack)[]) {
-        for (const definition of definitions) {
-            if (isDefinition(definition)) {
-                this.definitions[definition.id] = definition;
-            }
-            else {
-                for (const definitionInPack of Object.values(definition)) {
-                    this.definitions[definitionInPack.id] = definitionInPack;
-                }
-            }
-        }
-    }
-
-    public tryGet(id: RegisterId) {
-        return this.definitions[id];
-    }
-
-    public get(id: RegisterId) {
-        const definition = this.definitions[id];
-        if (!definition) {
-            throw new Error(`Defintion was not loaded for register ${id}`);
-        }
-        return definition;
-    }
-
-    public reset() {
-        this.definitions = {};
-    }
-}
-
-function isDefinition(definitionOrPack: RegisterDefinition | RegisterPack): definitionOrPack is RegisterDefinition {
-    return !!(definitionOrPack.id && definitionOrPack.aggregate && definitionOrPack.units);
-}
-
-export const RegisterLibrary = new Library();
+import type { RegisterDefinition } from "./register-definition";
+import type { RegisterId } from "./register-id";
+import { RegisterPack } from "./register-pack";
+
+class Library {
+    private definitions: Partial<{ [id in RegisterId]: RegisterDefinition }> =
+        {};
+
+    public add(...definitions: (RegisterDefinition | RegisterPack)[]) {
+        for (const definition of definitions) {
+            if (isDefinition(definition)) {
+                this.tryAdd(definition);
+            } else {
+                for (const definitionInPack of Object.values(definition)) {
+                    this.tryAdd(definitionInPack);
+                }
+            }
+        }
+    }
+
+    private tryAdd(definition: RegisterDefinition) {
+        if (!this.definitions[definition.id]) {
+            this.definitions[definition.id] = definition;
+            return true;
+        }
+        return false;
+    }
+
+    public has(id: RegisterId) {
+        return !!this.definitions[id];
+    }
+
+    public tryGet(id: RegisterId) {
+        return this.definitions[id];
+    }
+
+    public get(id: RegisterId) {
+        const definition = this.definitions[id];
+        if (!definition) {
+            throw new Error(`Defintion was not loaded for register ${id}`);
+        }
+        return definition;
+    }
+
+    public all() {
+        return Object.values(this.definitions).map((x) => x!);
+    }
+
+    public reset() {
+        this.definitions = {};
+    }
+}
+
+function isDefinition(
+    definitionOrPack: RegisterDefinition | RegisterPack,
+): definitionOrPack is RegisterDefinition {
+    return !!(
+        definitionOrPack.id &&
+        definitionOrPack.aggregate &&
+        definitionOrPack.units
+    );
+}
+
+export const RegisterLibrary = new Library();

package/src/register-pack.ts

@@ -1,5 +1,5 @@
-import { RegisterDefinition } from "./register-definition";
-
-export interface RegisterPack {
-    [key: string]: RegisterDefinition;
-}
+import type { RegisterDefinition } from "./register-definition";
+
+export interface RegisterPack {
+    [key: string]: RegisterDefinition;
+}

package/src/register-utils.ts

@@ -1,6 +1,6 @@
-import { RegisterDefinition } from "./register-definition";
-import { RegisterId } from "./register-id";
-
-export function getRegisterId(register: RegisterId | RegisterDefinition) {
-    return typeof register === "string" ? register : register.id;
-}
+import type { RegisterDefinition } from "./register-definition";
+import type { RegisterId } from "./register-id";
+
+export function getRegisterId(register: RegisterId | RegisterDefinition) {
+    return typeof register === "string" ? register : register.id;
+}

package/src/registers/acoustic-noise.ts

@@ -0,0 +1,52 @@
+import { sqUnits, units } from "../measures/noise";
+
+import type { RegisterDefinition } from "../register-definition";
+
+export const acousticNoise: RegisterDefinition = {
+    id: "acousticNoise",
+    measure: "noise",
+    aggregate: "instant",
+    units,
+};
+
+export const minAcousticNoise: RegisterDefinition = {
+    id: "minAcousticNoise",
+    measure: "noise",
+    aggregate: "min",
+    units,
+};
+
+export const maxAcousticNoise: RegisterDefinition = {
+    id: "maxAcousticNoise",
+    measure: "noise",
+    aggregate: "max",
+    units,
+};
+
+export const avgAcousticNoise: RegisterDefinition = {
+    id: "avgAcousticNoise",
+    measure: "noise",
+    aggregate: "avg",
+    units,
+};
+
+export const sumAcousticNoise: RegisterDefinition = {
+    id: "sumAcousticNoise",
+    measure: "noise",
+    aggregate: "sum",
+    units,
+};
+
+export const cntAcousticNoise: RegisterDefinition = {
+    id: "cntAcousticNoise",
+    measure: "noise",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+export const ssqAcousticNoise: RegisterDefinition = {
+    id: "ssqAcousticNoise",
+    measure: "noise",
+    aggregate: "ssq",
+    units: sqUnits,
+};

package/src/registers/ambient-temperature.ts

@@ -0,0 +1,52 @@
+import { sqUnits, units } from "../measures/temperature";
+
+import type { RegisterDefinition } from "../register-definition";
+
+export const ambientTemperature: RegisterDefinition = {
+    id: "ambientTemperature",
+    measure: "temperature",
+    aggregate: "instant",
+    units,
+};
+
+export const minAmbientTemperature: RegisterDefinition = {
+    id: "minAmbientTemperature",
+    measure: "temperature",
+    aggregate: "min",
+    units,
+};
+
+export const maxAmbientTemperature: RegisterDefinition = {
+    id: "maxAmbientTemperature",
+    measure: "temperature",
+    aggregate: "max",
+    units,
+};
+
+export const avgAmbientTemperature: RegisterDefinition = {
+    id: "avgAmbientTemperature",
+    measure: "temperature",
+    aggregate: "avg",
+    units,
+};
+
+export const sumAmbientTemperature: RegisterDefinition = {
+    id: "sumAmbientTemperature",
+    measure: "temperature",
+    aggregate: "sum",
+    units,
+};
+
+export const cntAmbientTemperature: RegisterDefinition = {
+    id: "cntAmbientTemperature",
+    measure: "temperature",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+export const ssqAmbientTemperature: RegisterDefinition = {
+    id: "ssqAmbientTemperature",
+    measure: "temperature",
+    aggregate: "ssq",
+    units: sqUnits,
+};

package/src/registers/axioma-infocode.ts

@@ -0,0 +1,16 @@
+import type { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/infocode";
+
+export const axiomaInfocode: RegisterDefinition = {
+    id: "axiomaInfocode",
+    measure: "none",
+    aggregate: "instant",
+    units,
+};
+
+export const axiomaInfocodeType1: RegisterDefinition = {
+    id: "axiomaInfocodeType1",
+    measure: "none",
+    aggregate: "instant",
+    units,
+};

package/src/registers/consumer.ts

@@ -0,0 +1,17 @@
+import type { RegisterDefinition } from "../register-definition";
+
+export const consumer: RegisterDefinition = {
+    id: "consumer",
+    measure: "none",
+    aggregate: "instant",
+    units: ["unitless"],
+    immediate: true,
+};
+
+export interface Consumer {
+    id: number;
+    name: string;
+    consumerNumber: string;
+    emailAddress: string;
+    phoneNumber: string;
+}

package/src/registers/cooling-energy-inlet.ts

@@ -0,0 +1,23 @@
+import type { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/energy";
+
+export const coolingEnergyVolumeInInlet: RegisterDefinition = {
+    id: "coolingEnergyVolumeInInlet",
+    measure: "energy",
+    aggregate: "instant",
+    units,
+};
+
+export const diffCoolingEnergyVolumeInInlet: RegisterDefinition = {
+    id: "diffCoolingEnergyVolumeInInlet",
+    measure: "energy",
+    aggregate: "diff",
+    units,
+};
+
+export const cntCoolingEnergyVolumeInInlet: RegisterDefinition = {
+    id: "cntCoolingEnergyVolumeInInlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};

package/src/registers/cooling-energy-outlet.ts

@@ -0,0 +1,23 @@
+import type { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/energy";
+
+export const coolingEnergyVolumeInOutlet: RegisterDefinition = {
+    id: "coolingEnergyVolumeInOutlet",
+    measure: "energy",
+    aggregate: "instant",
+    units,
+};
+
+export const diffCoolingEnergyVolumeInOutlet: RegisterDefinition = {
+    id: "diffCoolingEnergyVolumeInOutlet",
+    measure: "energy",
+    aggregate: "diff",
+    units,
+};
+
+export const cntCoolingEnergyVolumeInOutlet: RegisterDefinition = {
+    id: "cntCoolingEnergyVolumeInOutlet",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};

package/src/registers/cooling-energy.ts

@@ -0,0 +1,23 @@
+import type { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/energy";
+
+export const coolingEnergy: RegisterDefinition = {
+    id: "coolingEnergy",
+    measure: "energy",
+    aggregate: "instant",
+    units,
+};
+
+export const diffCoolingEnergy: RegisterDefinition = {
+    id: "diffCoolingEnergy",
+    measure: "energy",
+    aggregate: "diff",
+    units,
+};
+
+export const cntCoolingEnergy: RegisterDefinition = {
+    id: "cntCoolingEnergy",
+    measure: "energy",
+    aggregate: "cnt",
+    units: ["unitless"],
+};

package/src/registers/cooling.ts

@@ -0,0 +1,113 @@
+import { sqUnits, units } from "../measures/temperature";
+
+import type { RegisterDefinition } from "../register-definition";
+
+export const inletMinusOutletFlowTemperatureDifference: RegisterDefinition = {
+    id: "inletMinusOutletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "instant",
+    units,
+};
+
+export const minInletMinusOutletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "minInletMinusOutletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "min",
+        units,
+    };
+
+export const maxInletMinusOutletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "maxInletMinusOutletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "max",
+        units,
+    };
+
+export const avgInletMinusOutletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "avgInletMinusOutletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "avg",
+        units,
+    };
+
+export const sumInletMinusOutletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "sumInletMinusOutletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "sum",
+        units,
+    };
+
+export const cntInletMinusOutletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "cntInletMinusOutletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "cnt",
+        units: ["unitless"],
+    };
+
+export const ssqInletMinusOutletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "ssqInletMinusOutletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "ssq",
+        units: sqUnits,
+    };
+
+export const outletMinusInletFlowTemperatureDifference: RegisterDefinition = {
+    id: "outletMinusInletFlowTemperatureDifference",
+    measure: "temperature",
+    aggregate: "instant",
+    units,
+};
+
+export const minOutletMinusInletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "minOutletMinusInletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "min",
+        units,
+    };
+
+export const maxOutletMinusInletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "maxOutletMinusInletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "max",
+        units,
+    };
+
+export const avgOutletMinusInletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "avgOutletMinusInletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "avg",
+        units,
+    };
+
+export const sumOutletMinusInletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "sumOutletMinusInletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "sum",
+        units,
+    };
+
+export const cntOutletMinusInletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "cntOutletMinusInletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "cnt",
+        units: ["unitless"],
+    };
+
+export const ssqOutletMinusInletFlowTemperatureDifference: RegisterDefinition =
+    {
+        id: "ssqOutletMinusInletFlowTemperatureDifference",
+        measure: "temperature",
+        aggregate: "ssq",
+        units: sqUnits,
+    };

package/src/registers/device-addresses-kamdraft.ts

@@ -0,0 +1,14 @@
+import type { RegisterDefinition } from "../register-definition";
+
+export const kamdraftDeviceAddresses: RegisterDefinition = {
+    id: "kamdraftDeviceAddresses",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+export interface KamdraftDeviceAddress {
+    _t: "kamdraft";
+    serialNumber: number;
+}

package/src/registers/device-addresses-msisdn.ts

@@ -0,0 +1,14 @@
+import type { RegisterDefinition } from "../register-definition";
+
+export const msisdnDeviceAddresses: RegisterDefinition = {
+    id: "msisdnDeviceAddresses",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+export interface MsisdnDeviceAddress {
+    _t: "msisdn";
+    msisdn: number;
+}

package/src/registers/device-addresses-tchlr.ts

@@ -0,0 +1,14 @@
+import type { RegisterDefinition } from "../register-definition";
+
+export const tchlrDeviceAddresses: RegisterDefinition = {
+    id: "tchlrDeviceAddresses",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+export interface TchlrDeviceAddress {
+    _t: "tchlr";
+    serialNumber: number;
+}

package/src/registers/device-addresses-wmbus.ts

@@ -0,0 +1,17 @@
+import type { RegisterDefinition } from "../register-definition";
+
+export const wMBusDeviceAddresses: RegisterDefinition = {
+    id: "wMBusDeviceAddresses",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};
+
+export interface WMBusDeviceAddress {
+    _t: "wmbus";
+    manufacturerCode: number;
+    serialNumber: number;
+    version: number;
+    type: number;
+}

package/src/registers/device-date-time.ts

@@ -0,0 +1,9 @@
+import type { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/time";
+
+export const deviceDateTime: RegisterDefinition = {
+    id: "deviceDateTime",
+    measure: "time",
+    aggregate: "instant",
+    units,
+};

package/src/registers/device-date.ts

@@ -0,0 +1,9 @@
+import type { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/time";
+
+export const deviceDate: RegisterDefinition = {
+    id: "deviceDate",
+    measure: "time",
+    aggregate: "instant",
+    units,
+};

package/src/registers/device-nominal-diameter.ts

@@ -0,0 +1,9 @@
+import type { RegisterDefinition } from "../register-definition";
+
+export const deviceNominalDiameter: RegisterDefinition = {
+    id: "deviceNominalDiameter",
+    measure: "none",
+    aggregate: "instant",
+    units: ["unitless"],
+    immediate: true,
+};

package/src/registers/device-permanent-volume-flow.ts

@@ -0,0 +1,9 @@
+import type { RegisterDefinition } from "../register-definition";
+
+export const devicePermanentVolumeFlow: RegisterDefinition = {
+    id: "devicePermanentVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "instant",
+    units: ["cubicMetersPerHour"],
+    immediate: true,
+};

package/src/registers/device-registers.ts

@@ -0,0 +1,9 @@
+import type { RegisterDefinition } from "../register-definition";
+
+export const deviceRegisters: RegisterDefinition = {
+    id: "deviceRegisters",
+    measure: "none",
+    aggregate: "instant",
+    units: ["json"],
+    immediate: true,
+};