@utiliread/primitives 1.0.0-100 → 1.0.0-101

package/locales/da/registers.json

@@ -860,24 +860,24 @@
     "name": "Kørselstidspunkt"
   },
   "instantTime": {
-    "brief": "Forespørgelsestid, tidspunkt",
-    "name": "Forespørgelsestid, tidspunkt"
+    "brief": "Tidspunkt",
+    "name": "Tidspunkt"
   },
   "periodStartTime": {
-    "brief": "Forespørgelsestid, fra",
-    "name": "Forespørgelsestid, fra"
+    "brief": "Periode fra-tidspunkt",
+    "name": "Periode fra-tidspunkt"
   },
   "periodEndTime": {
-    "brief": "Forespørgelsestid, til",
-    "name": "Forespørgelsestid, til"
+    "brief": "Periode til-tidspunkt",
+    "name": "Periode til-tidspunkt"
   },
   "instantOrPeriodStartTime": {
-    "brief": "Forespørgelsestid, tidspunkt eller fra",
-    "name": "Forespørgelsestid, tidspunkt eller fra"
+    "brief": "Tidspunkt eller periode fra-tidspunkt",
+    "name": "Tidspunkt eller periode fra-tidspunkt"
   },
   "instantOrPeriodEndTime": {
-    "brief": "Forespørgelsestid, tidspunkt eller til",
-    "name": "Forespørgelsestid, tidspunkt eller til"
+    "brief": "Tidspunkt eller periode til-tidspunkt",
+    "name": "Tidspunkt eller periode til-tidspunkt"
   },
   "device": {
     "brief": "Enhed",

package/locales/en/registers.json

@@ -860,24 +860,24 @@
     "name": "Run time"
   },
   "instantTime": {
-    "brief": "Forespørgelsestid, tidspunkt",
-    "name": "Forespørgelsestid, tidspunkt"
+    "brief": "Time",
+    "name": "Time"
   },
   "periodStartTime": {
-    "brief": "Forespørgelsestid, fra",
-    "name": "Forespørgelsestid, fra"
+    "brief": "Period from-time",
+    "name": "Period from-time"
   },
   "periodEndTime": {
-    "brief": "Forespørgelsestid, til",
-    "name": "Forespørgelsestid, til"
+    "brief": "Period to-time",
+    "name": "Period to-time"
   },
   "instantOrPeriodStartTime": {
-    "brief": "Forespørgelsestid, tidspunkt eller fra",
-    "name": "Forespørgelsestid, tidspunkt eller fra"
+    "brief": "Time or period from-time",
+    "name": "Time or period from-time"
   },
   "instantOrPeriodEndTime": {
-    "brief": "Forespørgelsestid, tidspunkt eller til",
-    "name": "Forespørgelsestid, tidspunkt eller til"
+    "brief": "Time or period to-time",
+    "name": "Time or period to-time"
   },
   "device": {
     "brief": "Device",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utiliread/primitives",
-  "version": "1.0.0-100",
+  "version": "1.0.0-101",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",

package/src/breakdown-rule.spec.ts

@@ -1,63 +1,63 @@
-import { BreakdownRule } from "./breakdown-rule";
-import { DateTime } from "luxon";
-import { TimeOrRule } from ".";
-import { expect } from "chai";
-
-describe("ctor", () => {
-    it("creates", () => {
-        expect(
-            BreakdownRule({ origin: "", count: 1, period: "hour" }),
-        ).to.equal("/1hour");
-        expect(
-            BreakdownRule({ origin: "", count: 2, period: "hour" }),
-        ).to.equal("/2hours");
-        expect(
-            BreakdownRule({ origin: "day", count: 1, period: "hour" }),
-        ).to.equal("day/1hour");
-        expect(
-            BreakdownRule({ origin: "day", count: 2, period: "hour" }),
-        ).to.equal("day/2hours");
-
-        expect(BreakdownRule("", 1, "hour")).to.equal("/1hour");
-        expect(BreakdownRule("", 2, "hour")).to.equal("/2hours");
-        expect(BreakdownRule("day", 1, "hour")).to.equal("day/1hour");
-        expect(BreakdownRule("day", 2, "hour")).to.equal("day/2hours");
-    });
-});
-
-describe("split", () => {
-    it("splits without origin", () => {
-        const { origin, count, period } = BreakdownRule.split("/1hour");
-        expect(origin).to.equal("");
-        expect(count).to.equal(1);
-        expect(period).to.equal("hour");
-    });
-
-    it("splits with simple origin", () => {
-        const { origin, count, period } = BreakdownRule.split("day/1hour");
-        expect(origin).to.equal("day");
-        expect(count).to.equal(1);
-        expect(period).to.equal("hour");
-    });
-
-    it("splits with complex origin and plural count", () => {
-        const { origin, count, period } = BreakdownRule.split(
-            "day+PT1H_year^month/10hours",
-        );
-        expect(origin).to.equal("day+PT1H_year^month");
-        expect(count).to.equal(10);
-        expect(period).to.equal("hour");
-    });
-
-    it("splits with time origin", () => {
-        const { origin, count, period } = BreakdownRule.split(
-            "2024-01-25T00:00:00.000+01:00/1hour",
-        );
-        expect(TimeOrRule.isTime(origin)).to.equal(true);
-        expect(+origin).to.equal(
-            +DateTime.local(2024, 1, 25),
-        );
-        expect(count).to.equal(1);
-        expect(period).to.equal("hour");
-    });
-});
+import { BreakdownRule } from "./breakdown-rule";
+import { DateTime } from "luxon";
+import { TimeOrRule } from ".";
+import { expect } from "chai";
+
+describe("ctor", () => {
+    it("creates", () => {
+        expect(
+            BreakdownRule({ origin: "", count: 1, period: "hour" }),
+        ).to.equal("/1hour");
+        expect(
+            BreakdownRule({ origin: "", count: 2, period: "hour" }),
+        ).to.equal("/2hours");
+        expect(
+            BreakdownRule({ origin: "day", count: 1, period: "hour" }),
+        ).to.equal("day/1hour");
+        expect(
+            BreakdownRule({ origin: "day", count: 2, period: "hour" }),
+        ).to.equal("day/2hours");
+
+        expect(BreakdownRule("", 1, "hour")).to.equal("/1hour");
+        expect(BreakdownRule("", 2, "hour")).to.equal("/2hours");
+        expect(BreakdownRule("day", 1, "hour")).to.equal("day/1hour");
+        expect(BreakdownRule("day", 2, "hour")).to.equal("day/2hours");
+    });
+});
+
+describe("split", () => {
+    it("splits without origin", () => {
+        const { origin, count, period } = BreakdownRule.split("/1hour");
+        expect(origin).to.equal("");
+        expect(count).to.equal(1);
+        expect(period).to.equal("hour");
+    });
+
+    it("splits with simple origin", () => {
+        const { origin, count, period } = BreakdownRule.split("day/1hour");
+        expect(origin).to.equal("day");
+        expect(count).to.equal(1);
+        expect(period).to.equal("hour");
+    });
+
+    it("splits with complex origin and plural count", () => {
+        const { origin, count, period } = BreakdownRule.split(
+            "day+PT1H_year^month/10hours",
+        );
+        expect(origin).to.equal("day+PT1H_year^month");
+        expect(count).to.equal(10);
+        expect(period).to.equal("hour");
+    });
+
+    it("splits with time origin", () => {
+        const { origin, count, period } = BreakdownRule.split(
+            "2024-01-25T00:00:00.000+01:00/1hour",
+        );
+        expect(TimeOrRule.isTime(origin)).to.equal(true);
+        expect(+origin).to.equal(
+            +DateTime.local(2024, 1, 25),
+        );
+        expect(count).to.equal(1);
+        expect(period).to.equal("hour");
+    });
+});

package/src/breakdown-rule.ts

@@ -1,60 +1,60 @@
-import { TimeOrRule } from "./time-or-rule";
-
-export type BreakdownRule = string;
-export type BreakdownPeriod = "hour" | "day" | "week" | "month" | "year";
-
-interface BreakdownRuleInit {
-    origin: TimeOrRule;
-    count: number;
-    period: BreakdownPeriod;
-}
-
-export function BreakdownRule(init: BreakdownRuleInit): BreakdownRule;
-export function BreakdownRule(
-    origin: TimeOrRule,
-    count: number,
-    period: BreakdownPeriod,
-): BreakdownRule;
-export function BreakdownRule(...params: any[]): BreakdownRule {
-    let init: BreakdownRuleInit;
-    switch (params.length) {
-        case 1:
-            init = params[0];
-            break;
-        case 3:
-            init = {
-                origin: params[0],
-                count: params[1],
-                period: params[2],
-            };
-            break;
-        default:
-            throw new TypeError("Invalid breakdown rule format");
-    }
-    const periodName =
-        Math.abs(init.count) == 1 ? init.period : (init.period + "s");
-    return `${init.origin}/${init.count}${periodName}`;
-}
-
-export namespace BreakdownRule {
-    const regex = new RegExp(
-        "(.*)/([-+]?[0-9]+)(hour|day|week|month|year)s?",
-    );
-    export function split(rule: BreakdownRule) {
-        const match = regex.exec(rule);
-        if (!match) {
-            throw new Error("Invalid breakdown rule format");
-        }
-        const origin = match[1];
-        const count = parseInt(match[2]);
-        let period = match[3];
-        if (period.endsWith("s")) {
-            period = period.substring(0, period.length - 1);
-        }
-        return {
-            origin: TimeOrRule.parse(origin),
-            count,
-            period: period as BreakdownPeriod,
-        };
-    }
-}
+import { TimeOrRule } from "./time-or-rule";
+
+export type BreakdownRule = string;
+export type BreakdownPeriod = "hour" | "day" | "week" | "month" | "year";
+
+interface BreakdownRuleInit {
+    origin: TimeOrRule;
+    count: number;
+    period: BreakdownPeriod;
+}
+
+export function BreakdownRule(init: BreakdownRuleInit): BreakdownRule;
+export function BreakdownRule(
+    origin: TimeOrRule,
+    count: number,
+    period: BreakdownPeriod,
+): BreakdownRule;
+export function BreakdownRule(...params: any[]): BreakdownRule {
+    let init: BreakdownRuleInit;
+    switch (params.length) {
+        case 1:
+            init = params[0];
+            break;
+        case 3:
+            init = {
+                origin: params[0],
+                count: params[1],
+                period: params[2],
+            };
+            break;
+        default:
+            throw new TypeError("Invalid breakdown rule format");
+    }
+    const periodName =
+        Math.abs(init.count) == 1 ? init.period : (init.period + "s");
+    return `${init.origin}/${init.count}${periodName}`;
+}
+
+export namespace BreakdownRule {
+    const regex = new RegExp(
+        "(.*)/([-+]?[0-9]+)(hour|day|week|month|year)s?",
+    );
+    export function split(rule: BreakdownRule) {
+        const match = regex.exec(rule);
+        if (!match) {
+            throw new Error("Invalid breakdown rule format");
+        }
+        const origin = match[1];
+        const count = parseInt(match[2]);
+        let period = match[3];
+        if (period.endsWith("s")) {
+            period = period.substring(0, period.length - 1);
+        }
+        return {
+            origin: TimeOrRule.parse(origin),
+            count,
+            period: period as BreakdownPeriod,
+        };
+    }
+}

package/src/time-or-rule.ts

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