@utiliread/primitives 1.0.0-144 → 1.0.0-146

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utiliread/primitives",
-  "version": "1.0.0-144",
+  "version": "1.0.0-146",
   "source": "src/index.ts",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/aggregate-id.ts

@@ -1,9 +1,9 @@
-export type AggregateId =
-    | "instant"
-    | "diff"
-    | "min"
-    | "max"
-    | "avg"
-    | "sum"
-    | "cnt"
-    | "ssq";
+export type AggregateId =
+    | "instant"
+    | "diff"
+    | "min"
+    | "max"
+    | "avg"
+    | "sum"
+    | "cnt"
+    | "ssq";

package/src/breakdown-rule.spec.ts

@@ -1,61 +1,61 @@
-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,58 +1,58 @@
-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/csv.spec.ts

@@ -1,34 +1,42 @@
-import { expect } from "chai";
-
-import { csv, type Csv } from "./csv";
-
-type Equal<A, B> =
-    (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2
-        ? true
-        : false;
-type Expect<T extends true> = T;
-
-describe("csv", () => {
-    it("should join values with commas", () => {
-        expect(csv(["a", "b", "c"])).to.equal("a,b,c");
-    });
-
-    it("should return empty string for empty array", () => {
-        expect(csv([])).to.equal("");
-    });
-
-    it("should infer Csv type from tuple values", () => {
-        const value = csv(["hello", "world"] as const);
-
-        const _typeCheck: Expect<Equal<typeof value, Csv<"hello" | "world">>> =
-            true;
-        expect(_typeCheck).to.equal(true);
-    });
-
-    it("should allow assignment to matching Csv union", () => {
-        const value = csv(["x", "y"] as const);
-        const accepted: Csv<"x" | "y"> = value;
-
-        expect(accepted).to.equal("x,y");
-    });
-});
+import { expect } from "chai";
+
+import { csv, type Csv } from "./csv";
+
+type Equal<A, B> =
+    (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2
+        ? true
+        : false;
+type Expect<T extends true> = T;
+
+describe("csv", () => {
+    it("should infer Csv type from single value", () => {
+        // single value "hello" is implicitly assignable to Csv<"hello" | "world">
+        const _wider: Csv<"hello" | "world"> = "hello";
+
+        // @ts-expect-error - "invalid" is not assignable to Csv<"hello" | "world">
+        const _invalid: Csv<"hello" | "world"> = "invalid";
+    });
+
+    it("should join values with commas", () => {
+        expect(csv(["a", "b", "c"])).to.equal("a,b,c");
+    });
+
+    it("should return empty string for empty array", () => {
+        expect(csv([])).to.equal("");
+    });
+
+    it("should infer Csv type from tuple values", () => {
+        const value = csv(["hello", "world"] as const);
+
+        const _typeCheck: Expect<Equal<typeof value, Csv<"hello" | "world">>> =
+            true;
+        expect(_typeCheck).to.equal(true);
+    });
+
+    it("should allow assignment to matching Csv union", () => {
+        const value = csv(["x", "y"] as const);
+        const accepted: Csv<"x" | "y"> = value;
+
+        expect(accepted).to.equal("x,y");
+    });
+});

package/src/csv.ts

@@ -1,9 +1,9 @@
-export type Csv<T extends string = string> = string & {
-    readonly __csvValuesBrand?: T;
-};
-
-export function csv<const T extends readonly string[]>(
-    values: T,
-): Csv<T[number]> {
-    return values.join(",") as Csv<T[number]>;
-}
+export type Csv<T extends string = string> =
+  | T
+  | (string & { readonly __csvValuesBrand: T });
+
+export function csv<const T extends readonly string[]>(
+  values: T,
+): Csv<T[number]> {
+  return values.join(",") as Csv<T[number]>;
+}