@utiliread/primitives 1.0.0-6 → 1.0.0-60

package/src/register-definition.ts

@@ -1,10 +1,23 @@
-import { UnitId } from ".";
-import { AggregateId } from "./aggregate-id";
-import { RegisterId } from "./register-id";
-
-export interface RegisterDefinition {
-    id: RegisterId;
-    aggregate: AggregateId;
-    units: ReadonlyArray<UnitId>;
-    immediate?: true;
-}
+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,214 @@
 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" |
 
     "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" |
 
     "relativeHumidity" |
 
     "kamstrupE8Inlet" |
     "diffKamstrupE8Inlet" |
+    "cntKamstrupE8Inlet" |
     "kamstrupE9Outlet" |
     "diffKamstrupE9Outlet" |
+    "cntKamstrupE9Outlet" |
 
     "operatingTime" |
     "diffOperatingTime" |
+    "cntOperatingTime" |
 
     "remainingBatteryTime" |
     "diffRemainingBatteryTime" |
+    "cntRemainingBatteryTime" |
 
     "deviceDate" |
     "deviceTime" |
@@ -151,14 +219,19 @@ export type RegisterId =
 
     "timeSinceLastPossibleCandidateOverhearingArrived" |
     "timeAtLastPossibleCandidateOverhearingArrived" |
-    
+
     "timeSinceLastSampled" |
     "timeAtLastSampled" |
-    
+
     "timeSinceLastInstallationMounted" |
     "timeAtLastInstallationMounted" |
 
     "basetime" |
+    "instantTime" |
+    "periodStartTime" |
+    "periodEndTime" |
+    "instantOrPeriodStartTime" |
+    "instantOrPeriodEndTime" |
 
     "device" |
     "wMBusDeviceAddresses" |
@@ -170,6 +243,7 @@ export type RegisterId =
     "consumptionZone" |
 
     "mBusFormatStringSignature" |
+    "deviceSoftwareVersion" |
 
     "kamstrupMulticalInfocodeType1" |
     "kamstrupMulticalInfocodeType2" |
@@ -177,7 +251,7 @@ export type RegisterId =
     "kamstrupMulticalInfocodeType4" |
     "kamstrupMulticalInfocode" |
     "kamstrupModuleType" |
-    
+
     "diehlInfocodeType1" |
     "diehlInfocode" |
 
@@ -187,5 +261,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],
+        };
+    }
+}

package/src/step.spec.ts

@@ -0,0 +1,30 @@
+import { expect } from "chai";
+import { DateTime } from "luxon";
+import { DayOfWeek, Step } from "./step";
+
+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/step.ts

@@ -0,0 +1,37 @@
+import { DateTime, Duration } from "luxon";
+
+export type Step = "hour" | "day" | "week" | "month" | "year";
+
+export enum DayOfWeek {
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6,
+    Sunday = 7,
+};
+
+export namespace Step {
+    export function startOf(dateTime: DateTime, step: Step, firstDayOfWeek?: DayOfWeek): DateTime {
+        if (step === "week") {
+            const value = dateTime.startOf("day").set({ weekday: firstDayOfWeek ?? DayOfWeek.Monday });
+            return value > dateTime
+                ? value.minus({ days: 7 })
+                : value;
+        }
+        else {
+            return dateTime.startOf(step);
+        }
+    }
+
+    export function asDuration(step: Step, amount = 1): Duration {
+        switch (step) {
+            case "hour": return Duration.fromObject({ hours: amount });
+            case "day": return Duration.fromObject({ days: amount });
+            case "week": return Duration.fromObject({ days: 7 * amount });
+            case "month": return Duration.fromObject({ months: amount });
+            case "year": return Duration.fromObject({ years: amount });
+        }
+    }
+}

package/src/time-or-rule.ts

@@ -0,0 +1,17 @@
+import { DateTime } from "luxon";
+
+export type TimeOrRule = Date | DateTime | string;
+
+export namespace TimeOrRule {
+    export function isTime(input: TimeOrRule): input is Date | DateTime {
+        return typeof input !== "string";
+    }
+
+    export function isRule(input: TimeOrRule): input is string {
+        return typeof input === "string";
+    }
+
+    export function asJSON(input: TimeOrRule) {
+        return isRule(input) ? input : input.toJSON();
+    }
+}