@utiliread/primitives 1.0.0-147 → 1.0.0-148

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

@@ -1,23 +1,23 @@
-import type { 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"],
-};
+import type { 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

@@ -1,23 +1,23 @@
-import type { 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"],
-};
+import type { 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

@@ -1,30 +1,30 @@
-import { Repository } from "./repository";
-import { expect } from "chai";
-
-describe("ctor", () => {
-    it.only("creates", () => {
-        expect(Repository("gpkv", "gjoel")).to.equal("gpkv/gjoel");
-        expect(Repository("gpkv/gjoel")).to.equal("gpkv/gjoel");
-    });
-    it.only("throws if wrong format", () => {
-        expect(() => Repository("invalid")).to.throw();
-        expect(() => Repository("[object%20Object]", "dashboard")).to.throw();
-    });
-});
-
-describe("isRepository", () => {
-    it("should correctly determine if input is a Repository", () => {
-        expect(Repository.isRepository("some/test")).to.equal(true);
-        expect(Repository.isRepository("so-me/te-st")).to.equal(true);
-        expect(Repository.isRepository("NOT/REPO")).to.equal(false);
-        expect(Repository.isRepository("notarepo")).to.equal(false);
-    });
-});
-
-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.only("creates", () => {
+        expect(Repository("gpkv", "gjoel")).to.equal("gpkv/gjoel");
+        expect(Repository("gpkv/gjoel")).to.equal("gpkv/gjoel");
+    });
+    it.only("throws if wrong format", () => {
+        expect(() => Repository("invalid")).to.throw();
+        expect(() => Repository("[object%20Object]", "dashboard")).to.throw();
+    });
+});
+
+describe("isRepository", () => {
+    it("should correctly determine if input is a Repository", () => {
+        expect(Repository.isRepository("some/test")).to.equal(true);
+        expect(Repository.isRepository("so-me/te-st")).to.equal(true);
+        expect(Repository.isRepository("NOT/REPO")).to.equal(false);
+        expect(Repository.isRepository("notarepo")).to.equal(false);
+    });
+});
+
+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

@@ -1,26 +1,26 @@
-// 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 {
-    const repo = name ? `${repoOrTeam}/${name}` : repoOrTeam;
-    if (!Repository.isRepository(repo)) {
-        throw new TypeError("Invalid repository format");
-    }
-    return repo;
-}
-
-export namespace Repository {
-    export function isRepository(input: string): input is Repository {
-        return /^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/.test(input);
-    }
-
-    export function split(repo: Repository) {
-        const parts = repo.split("/");
-        return {
-            team: parts[0],
-            name: parts[1],
-        };
-    }
-}
+// 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 {
+    const repo = name ? `${repoOrTeam}/${name}` : repoOrTeam;
+    if (!Repository.isRepository(repo)) {
+        throw new TypeError("Invalid repository format");
+    }
+    return repo;
+}
+
+export namespace Repository {
+    export function isRepository(input: string): input is Repository {
+        return /^[a-z][a-z0-9-]*\/[a-z][a-z0-9-]*$/.test(input);
+    }
+
+    export function split(repo: Repository) {
+        const parts = repo.split("/");
+        return {
+            team: parts[0],
+            name: parts[1],
+        };
+    }
+}

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/step.ts

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

@@ -1,42 +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();
+    }
+}