@utiliread/primitives 1.0.0-7 → 1.0.0-71

package/src/register-convention.spec.ts

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

package/src/register-convention.ts

@@ -0,0 +1,61 @@
+import { RegisterDefinition } from ".";
+import { AggregateId } from "./aggregate-id";
+import { RegisterId } from "./register-id";
+import { getRegisterId } from "./register-utils";
+
+export const aggregatePrefixes: { [aggregateId in AggregateId]: string } = {
+    instant: "",
+    diff: "diff",
+    min: "min",
+    max: "max",
+    avg: "avg",
+    sum: "sum",
+    cnt: "cnt",
+    ssq: "ssq",
+};
+
+class Convention {
+    public getAggregate(register: RegisterId | RegisterDefinition) {
+        const registerId = getRegisterId(register);
+        // Brute force all prefixes - if none of them, then it must be instant.
+        for (const aggregateString of Object.keys(aggregatePrefixes)) {
+            const aggregate = <AggregateId>aggregateString;
+            const prefix = aggregatePrefixes[aggregate];
+            if (prefix.length && isPrefix(registerId, prefix)) {
+                // Not instant - it was any of the others.
+                return aggregate;
+            }
+        }
+        return "instant";
+    }
+
+    toInstant(register: RegisterId | RegisterDefinition) {
+        const registerId = getRegisterId(register);
+        for (const prefix of Object.values(aggregatePrefixes)) {
+            if (prefix.length && isPrefix(registerId, prefix)) {
+                const tail = registerId.substr(prefix.length);
+                return <RegisterId>(tail[0].toLowerCase() + tail.substr(1));
+            }
+        }
+        return registerId;
+    }
+
+    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));
+    }
+}
+
+export function isPrefix(registerId: RegisterId, prefix: string) {
+    return registerId.startsWith(prefix) && isUppercase(registerId[prefix.length]);
+}
+
+function isUppercase(input: string) {
+    return input.toUpperCase() === input;
+}
+
+export const RegisterConvention = new Convention();

package/src/register-definition.ts

@@ -1,10 +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;
+}

package/src/register-id.ts

@@ -1,146 +1,250 @@
 export type RegisterId =
     "none" |
-    
+
     "heatEnergy" |
     "diffHeatEnergy" |
+    "cntHeatEnergy" |
 
     "heatEnergyVolumeInInlet" |
     "diffHeatEnergyVolumeInInlet" |
+    "cntHeatEnergyVolumeInInlet" |
 
     "heatEnergyVolumeInOutlet" |
     "diffHeatEnergyVolumeInOutlet" |
+    "cntHeatEnergyVolumeInOutlet" |
 
     "coolingEnergy" |
     "diffCoolingEnergy" |
+    "cntCoolingEnergy" |
 
     "coolingEnergyVolumeInInlet" |
     "diffCoolingEnergyVolumeInInlet" |
+    "cntCoolingEnergyVolumeInInlet" |
 
     "coolingEnergyVolumeInOutlet" |
     "diffCoolingEnergyVolumeInOutlet" |
+    "cntCoolingEnergyVolumeInOutlet" |
 
     "electricalEnergy" |
     "diffElectricalEnergy" |
+    "cntElectricalEnergy" |
 
     "reactiveEnergy" |
     "diffReactiveEnergy" |
+    "cntReactiveEnergy" |
 
     "volume" |
     "diffVolume" |
+    "cntVolume" |
 
     "inletVolume" |
     "diffInletVolume" |
+    "cntInletVolume" |
 
     "outletVolume" |
     "diffOutletVolume" |
+    "cntOutletVolume" |
 
     "pulseInputAVolume" |
     "diffPulseInputAVolume" |
+    "cntPulseInputAVolume" |
 
     "pulseInputBVolume" |
     "diffPulseInputBVolume" |
+    "cntPulseInputBVolume" |
 
     "mass" |
     "diffMass" |
+    "cntMass" |
 
     "inletMass" |
     "diffInletMass" |
+    "cntInletMass" |
 
     "outletMass" |
     "diffOutletMass" |
+    "cntOutletMass" |
+
+    "pressure" |
+    "maxPressure" |
+    "minPressure" |
+    "avgPressure" |
+    "sumPressure" |
+    "cntPressure" |
+    "ssqPressure" |
+
+    "inletPressure" |
+    "maxInletPressure" |
+    "minInletPressure" |
+    "avgInletPressure" |
+    "sumInletPressure" |
+    "cntInletPressure" |
+    "ssqInletPressure" |
+
+    "outletPressure" |
+    "maxOutletPressure" |
+    "minOutletPressure" |
+    "avgOutletPressure" |
+    "sumOutletPressure" |
+    "cntOutletPressure" |
+    "ssqOutletPressure" |
 
     "power" |
     "maxPower" |
     "minPower" |
     "avgPower" |
+    "sumPower" |
+    "cntPower" |
+    "ssqPower" |
 
     "inletPower" |
     "maxInletPower" |
     "minInletPower" |
     "avgInletPower" |
+    "sumInletPower" |
+    "cntInletPower" |
+    "ssqInletPower" |
 
     "outletPower" |
     "maxOutletPower" |
     "minOutletPower" |
     "avgOutletPower" |
+    "sumOutletPower" |
+    "cntOutletPower" |
+    "ssqOutletPower" |
 
     "volumeFlow" |
     "maxVolumeFlow" |
     "minVolumeFlow" |
     "avgVolumeFlow" |
+    "sumVolumeFlow" |
+    "cntVolumeFlow" |
+    "ssqVolumeFlow" |
 
     "inletVolumeFlow" |
     "maxInletVolumeFlow" |
     "minInletVolumeFlow" |
     "avgInletVolumeFlow" |
+    "sumInletVolumeFlow" |
+    "cntInletVolumeFlow" |
+    "ssqInletVolumeFlow" |
 
     "outletVolumeFlow" |
     "maxOutletVolumeFlow" |
     "minOutletVolumeFlow" |
     "avgOutletVolumeFlow" |
+    "sumOutletVolumeFlow" |
+    "cntOutletVolumeFlow" |
+    "ssqOutletVolumeFlow" |
 
     "massFlow" |
     "maxMassFlow" |
     "minMassFlow" |
     "avgMassFlow" |
+    "sumMassFlow" |
+    "cntMassFlow" |
+    "ssqMassFlow" |
 
     "inletMassFlow" |
     "maxInletMassFlow" |
     "minInletMassFlow" |
     "avgInletMassFlow" |
+    "sumInletMassFlow" |
+    "cntInletMassFlow" |
+    "ssqInletMassFlow" |
 
     "outletMassFlow" |
     "maxOutletMassFlow" |
     "minOutletMassFlow" |
     "avgOutletMassFlow" |
+    "sumOutletMassFlow" |
+    "cntOutletMassFlow" |
+    "ssqOutletMassFlow" |
 
     "flowTemperature" |
     "maxFlowTemperature" |
     "minFlowTemperature" |
     "avgFlowTemperature" |
+    "sumFlowTemperature" |
+    "cntFlowTemperature" |
+    "ssqFlowTemperature" |
 
     "inletFlowTemperature" |
     "maxInletFlowTemperature" |
     "minInletFlowTemperature" |
     "avgInletFlowTemperature" |
+    "sumInletFlowTemperature" |
+    "cntInletFlowTemperature" |
+    "ssqInletFlowTemperature" |
 
     "outletFlowTemperature" |
     "maxOutletFlowTemperature" |
     "minOutletFlowTemperature" |
     "avgOutletFlowTemperature" |
+    "sumOutletFlowTemperature" |
+    "cntOutletFlowTemperature" |
+    "ssqOutletFlowTemperature" |
 
     "inletMinusOutletFlowTemperatureDifference" |
     "maxInletMinusOutletFlowTemperatureDifference" |
     "minInletMinusOutletFlowTemperatureDifference" |
     "avgInletMinusOutletFlowTemperatureDifference" |
+    "sumInletMinusOutletFlowTemperatureDifference" |
+    "cntInletMinusOutletFlowTemperatureDifference" |
+    "ssqInletMinusOutletFlowTemperatureDifference" |
 
     "outletMinusInletFlowTemperatureDifference" |
     "maxOutletMinusInletFlowTemperatureDifference" |
     "minOutletMinusInletFlowTemperatureDifference" |
     "avgOutletMinusInletFlowTemperatureDifference" |
+    "sumOutletMinusInletFlowTemperatureDifference" |
+    "cntOutletMinusInletFlowTemperatureDifference" |
+    "ssqOutletMinusInletFlowTemperatureDifference" |
 
     "ambientTemperature" |
     "maxAmbientTemperature" |
     "minAmbientTemperature" |
     "avgAmbientTemperature" |
+    "sumAmbientTemperature" |
+    "cntAmbientTemperature" |
+    "ssqAmbientTemperature" |
 
     "radiatorTemperature" |
     "maxRadiatorTemperature" |
     "minRadiatorTemperature" |
     "avgRadiatorTemperature" |
+    "sumRadiatorTemperature" |
+    "cntRadiatorTemperature" |
+    "ssqRadiatorTemperature" |
+
+    "auxFlowTemperature" |
+    "maxAuxFlowTemperature" |
+    "minAuxFlowTemperature" |
+    "avgAuxFlowTemperature" |
+    "sumAuxFlowTemperature" |
+    "cntAuxFlowTemperature" |
+    "ssqAuxFlowTemperature" |
 
     "relativeHumidity" |
 
     "kamstrupE8Inlet" |
     "diffKamstrupE8Inlet" |
+    "cntKamstrupE8Inlet" |
     "kamstrupE9Outlet" |
     "diffKamstrupE9Outlet" |
+    "cntKamstrupE9Outlet" |
 
     "operatingTime" |
     "diffOperatingTime" |
+    "cntOperatingTime" |
+
+    "errorOperatingTime" |
+    "diffErrorOperatingTime" |
+    "cntErrorOperatingTime" |
 
     "remainingBatteryTime" |
     "diffRemainingBatteryTime" |
+    "cntRemainingBatteryTime" |
 
     "deviceDate" |
     "deviceTime" |
@@ -151,14 +255,19 @@ export type RegisterId =
 
     "timeSinceLastPossibleCandidateOverhearingArrived" |
     "timeAtLastPossibleCandidateOverhearingArrived" |
-    
+
     "timeSinceLastSampled" |
     "timeAtLastSampled" |
-    
+
     "timeSinceLastInstallationMounted" |
     "timeAtLastInstallationMounted" |
 
     "basetime" |
+    "instantTime" |
+    "periodStartTime" |
+    "periodEndTime" |
+    "instantOrPeriodStartTime" |
+    "instantOrPeriodEndTime" |
 
     "device" |
     "wMBusDeviceAddresses" |
@@ -166,10 +275,13 @@ export type RegisterId =
     "tchlrDeviceAddresses" |
     "kamdaDeviceAddresses" |
     "msisdnDeviceAddresses" |
+
     "deviceRegisters" |
-    "consumptionZone" |
+
+    "place" |
 
     "mBusFormatStringSignature" |
+    "deviceSoftwareVersion" |
 
     "kamstrupMulticalInfocodeType1" |
     "kamstrupMulticalInfocodeType2" |
@@ -177,7 +289,7 @@ export type RegisterId =
     "kamstrupMulticalInfocodeType4" |
     "kamstrupMulticalInfocode" |
     "kamstrupModuleType" |
-    
+
     "diehlInfocodeType1" |
     "diehlInfocode" |
 
@@ -187,5 +299,5 @@ export type RegisterId =
     "landisGyrInfocodeType1" |
     "landisGyrInfocodeType2" |
     "landisGyrInfocode" |
-    
-    "infocode";
+
+    "infocode";

package/src/register-library.spec.ts

@@ -1,33 +1,41 @@
-import { expect } from "chai";
-import { RegisterDefinition } from ".";
-import { RegisterLibrary } from "./register-library";
-
-const volume: RegisterDefinition = {
-    id: "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 { 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();
+    });
+
+    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,37 +1,57 @@
-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 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 { 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.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 { RegisterDefinition } from "./register-definition";
+
+export interface RegisterPack {
+    [key: string]: RegisterDefinition;
+}

package/src/register-utils.ts

@@ -0,0 +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;
+}

package/src/repository.spec.ts

@@ -0,0 +1,20 @@
+import { expect } from "chai";
+import { Repository } from "./repository";
+
+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/repository.ts

@@ -0,0 +1,24 @@
+// This is clearly not correct but it provides some amazing type safety
+export type Repository = "some/repo";
+
+export function Repository(repo: string): Repository;
+export function Repository(team: string, name: string): Repository;
+export function Repository(repoOrTeam: string, name?: string): Repository {
+    if (name) {
+        return <Repository>`${repoOrTeam}/${name}`;
+    } else if (repoOrTeam.indexOf("/") > 0) {
+        return <Repository>repoOrTeam;
+    } else {
+        throw new TypeError("Invalid repository format");
+    }
+}
+
+export namespace Repository {
+    export function split(repo: Repository) {
+        const parts = repo.split("/");
+        return {
+            team: parts[0],
+            name: parts[1],
+        };
+    }
+}