@utiliread/primitives 1.0.0-12 → 1.0.0-121

package/src/registers/relative-humidity.ts

@@ -0,0 +1,8 @@
+import { RegisterDefinition } from "../register-definition";
+
+export const relativeHumidity: RegisterDefinition = {
+    id: "relativeHumidity",
+    measure: "humidity",
+    aggregate: "instant",
+    units: ["percentage"],
+};

package/src/registers/remaining-battery-time.ts

@@ -0,0 +1,23 @@
+import { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/duration";
+
+export const remainingBatteryTime: RegisterDefinition = {
+    id: "remainingBatteryTime",
+    measure: "duration",
+    aggregate: "instant",
+    units,
+};
+
+export const diffRemainingBatteryTime: RegisterDefinition = {
+    id: "diffRemainingBatteryTime",
+    measure: "duration",
+    aggregate: "diff",
+    units,
+};
+
+export const cntRemainingBatteryTime: RegisterDefinition = {
+    id: "cntRemainingBatteryTime",
+    measure: "duration",
+    aggregate: "cnt",
+    units: ["unitless"],
+};

package/src/registers/time-last-exact-overhearing-arrived.ts

@@ -0,0 +1,19 @@
+import { RegisterDefinition } from "../register-definition";
+import { units as durationUnits } from "../measures/duration";
+import { units as timeUnits } from "../measures/time";
+
+export const timeAtLastExactOverhearingArrived: RegisterDefinition = {
+    id: "timeAtLastExactOverhearingArrived",
+    measure: "time",
+    aggregate: "instant",
+    units: timeUnits,
+    immediate: true,
+};
+
+export const timeSinceLastExactOverhearingArrived: RegisterDefinition = {
+    id: "timeSinceLastExactOverhearingArrived",
+    measure: "duration",
+    aggregate: "instant",
+    units: durationUnits,
+    immediate: true,
+};

package/src/registers/time-last-installation-mounted.ts

@@ -0,0 +1,19 @@
+import { RegisterDefinition } from "../register-definition";
+import { units as durationUnits } from "../measures/duration";
+import { units as timeUnits } from "../measures/time";
+
+export const timeAtLastInstallationMounted: RegisterDefinition = {
+    id: "timeAtLastInstallationMounted",
+    measure: "time",
+    aggregate: "instant",
+    units: timeUnits,
+    immediate: true,
+};
+
+export const timeSinceLastInstallationMounted: RegisterDefinition = {
+    id: "timeSinceLastInstallationMounted",
+    measure: "duration",
+    aggregate: "instant",
+    units: durationUnits,
+    immediate: true,
+};

package/src/registers/time-last-possible-candidate-overhearing-arrived.ts

@@ -0,0 +1,21 @@
+import { RegisterDefinition } from "../register-definition";
+import { units as durationUnits } from "../measures/duration";
+import { units as timeUnits } from "../measures/time";
+
+export const timeAtLastPossibleCandidateOverhearingArrived: RegisterDefinition =
+    {
+        id: "timeAtLastPossibleCandidateOverhearingArrived",
+        measure: "time",
+        aggregate: "instant",
+        units: timeUnits,
+        immediate: true,
+    };
+
+export const timeSinceLastPossibleCandidateOverhearingArrived: RegisterDefinition =
+    {
+        id: "timeSinceLastPossibleCandidateOverhearingArrived",
+        measure: "duration",
+        aggregate: "instant",
+        units: durationUnits,
+        immediate: true,
+    };

package/src/registers/time-last-sampled.ts

@@ -0,0 +1,19 @@
+import { RegisterDefinition } from "../register-definition";
+import { units as durationUnits } from "../measures/duration";
+import { units as timeUnits } from "../measures/time";
+
+export const timeAtLastSampled: RegisterDefinition = {
+    id: "timeAtLastSampled",
+    measure: "time",
+    aggregate: "instant",
+    units: timeUnits,
+    immediate: true,
+};
+
+export const timeSinceLastSampled: RegisterDefinition = {
+    id: "timeSinceLastSampled",
+    measure: "duration",
+    aggregate: "instant",
+    units: durationUnits,
+    immediate: true,
+};

package/src/registers/time.ts

@@ -0,0 +1,45 @@
+import { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/time";
+
+export const basetime: RegisterDefinition = {
+    id: "basetime",
+    measure: "time",
+    aggregate: "instant",
+    units,
+    immediate: true,
+};
+
+export const instantTime: RegisterDefinition = {
+    id: "instantTime",
+    measure: "time",
+    aggregate: "instant",
+    units,
+};
+
+export const periodStartTime: RegisterDefinition = {
+    id: "periodStartTime",
+    measure: "time",
+    aggregate: "instant",
+    units,
+};
+
+export const periodEndTime: RegisterDefinition = {
+    id: "periodEndTime",
+    measure: "time",
+    aggregate: "instant",
+    units,
+};
+
+export const instantOrPeriodStartTime: RegisterDefinition = {
+    id: "instantOrPeriodStartTime",
+    measure: "time",
+    aggregate: "instant",
+    units,
+};
+
+export const instantOrPeriodEndTime: RegisterDefinition = {
+    id: "instantOrPeriodEndTime",
+    measure: "time",
+    aggregate: "instant",
+    units,
+};

package/src/registers/volume-flow-inlet.ts

@@ -0,0 +1,52 @@
+import { sqUnits, units } from "../measures/volume-flow";
+
+import { RegisterDefinition } from "../register-definition";
+
+export const inletVolumeFlow: RegisterDefinition = {
+    id: "inletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "instant",
+    units,
+};
+
+export const minInletVolumeFlow: RegisterDefinition = {
+    id: "minInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "min",
+    units,
+};
+
+export const maxInletVolumeFlow: RegisterDefinition = {
+    id: "maxInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "max",
+    units,
+};
+
+export const avgInletVolumeFlow: RegisterDefinition = {
+    id: "avgInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "avg",
+    units,
+};
+
+export const sumInletVolumeFlow: RegisterDefinition = {
+    id: "sumInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "sum",
+    units,
+};
+
+export const cntInletVolumeFlow: RegisterDefinition = {
+    id: "cntInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+export const ssqInletVolumeFlow: RegisterDefinition = {
+    id: "ssqInletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "ssq",
+    units: sqUnits,
+};

package/src/registers/volume-flow-outlet.ts

@@ -0,0 +1,52 @@
+import { sqUnits, units } from "../measures/volume-flow";
+
+import { RegisterDefinition } from "../register-definition";
+
+export const outletVolumeFlow: RegisterDefinition = {
+    id: "outletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "instant",
+    units,
+};
+
+export const minOutletVolumeFlow: RegisterDefinition = {
+    id: "minOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "min",
+    units,
+};
+
+export const maxOutletVolumeFlow: RegisterDefinition = {
+    id: "maxOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "max",
+    units,
+};
+
+export const avgOutletVolumeFlow: RegisterDefinition = {
+    id: "avgOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "avg",
+    units,
+};
+
+export const sumOutletVolumeFlow: RegisterDefinition = {
+    id: "sumOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "sum",
+    units,
+};
+
+export const cntOutletVolumeFlow: RegisterDefinition = {
+    id: "cntOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+export const ssqOutletVolumeFlow: RegisterDefinition = {
+    id: "ssqOutletVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "ssq",
+    units: sqUnits,
+};

package/src/registers/volume-flow.ts

@@ -0,0 +1,52 @@
+import { sqUnits, units } from "../measures/volume-flow";
+
+import { RegisterDefinition } from "../register-definition";
+
+export const volumeFlow: RegisterDefinition = {
+    id: "volumeFlow",
+    measure: "volumeFlow",
+    aggregate: "instant",
+    units,
+};
+
+export const minVolumeFlow: RegisterDefinition = {
+    id: "minVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "min",
+    units,
+};
+
+export const maxVolumeFlow: RegisterDefinition = {
+    id: "maxVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "max",
+    units,
+};
+
+export const avgVolumeFlow: RegisterDefinition = {
+    id: "avgVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "avg",
+    units,
+};
+
+export const sumVolumeFlow: RegisterDefinition = {
+    id: "sumVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "sum",
+    units,
+};
+
+export const cntVolumeFlow: RegisterDefinition = {
+    id: "cntVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "cnt",
+    units: ["unitless"],
+};
+
+export const ssqVolumeFlow: RegisterDefinition = {
+    id: "ssqVolumeFlow",
+    measure: "volumeFlow",
+    aggregate: "ssq",
+    units: sqUnits,
+};

package/src/registers/volume-inlet.ts

@@ -0,0 +1,23 @@
+import { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/volume";
+
+export const inletVolume: RegisterDefinition = {
+    id: "inletVolume",
+    measure: "volume",
+    aggregate: "instant",
+    units,
+};
+
+export const diffInletVolume: RegisterDefinition = {
+    id: "diffInletVolume",
+    measure: "volume",
+    aggregate: "diff",
+    units,
+};
+
+export const cntInletVolume: RegisterDefinition = {
+    id: "cntInletVolume",
+    measure: "volume",
+    aggregate: "cnt",
+    units: ["unitless"],
+};

package/src/registers/volume-outlet.ts

@@ -0,0 +1,23 @@
+import { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/volume";
+
+export const outletVolume: RegisterDefinition = {
+    id: "outletVolume",
+    measure: "volume",
+    aggregate: "instant",
+    units,
+};
+
+export const diffOutletVolume: RegisterDefinition = {
+    id: "diffOutletVolume",
+    measure: "volume",
+    aggregate: "diff",
+    units,
+};
+
+export const cntOutletVolume: RegisterDefinition = {
+    id: "cntOutletVolume",
+    measure: "volume",
+    aggregate: "cnt",
+    units: ["unitless"],
+};

package/src/registers/volume-pulse-input-a.ts

@@ -0,0 +1,23 @@
+import { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/volume";
+
+export const pulseInputAVolume: RegisterDefinition = {
+    id: "pulseInputAVolume",
+    measure: "volume",
+    aggregate: "instant",
+    units,
+};
+
+export const diffPulseInputAVolume: RegisterDefinition = {
+    id: "diffPulseInputAVolume",
+    measure: "volume",
+    aggregate: "diff",
+    units,
+};
+
+export const cntPulseInputAVolume: RegisterDefinition = {
+    id: "cntPulseInputAVolume",
+    measure: "volume",
+    aggregate: "cnt",
+    units: ["unitless"],
+};

package/src/registers/volume-pulse-input-b.ts

@@ -0,0 +1,23 @@
+import { RegisterDefinition } from "../register-definition";
+import { units } from "../measures/volume";
+
+export const pulseInputBVolume: RegisterDefinition = {
+    id: "pulseInputBVolume",
+    measure: "volume",
+    aggregate: "instant",
+    units,
+};
+
+export const diffPulseInputBVolume: RegisterDefinition = {
+    id: "diffPulseInputBVolume",
+    measure: "volume",
+    aggregate: "diff",
+    units,
+};
+
+export const cntPulseInputBVolume: RegisterDefinition = {
+    id: "cntPulseInputBVolume",
+    measure: "volume",
+    aggregate: "cnt",
+    units: ["unitless"],
+};

package/src/registers/volume.ts

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

package/src/repository.spec.ts

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

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

package/src/step.ts

@@ -0,0 +1,46 @@
+import { DateTime } from "luxon";
+import { Duration } from "./luxon-local";
+
+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,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();
+    }
+}