@utiliread/primitives 1.0.0-103 → 1.0.0-105

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utiliread/primitives",
-  "version": "1.0.0-103",
+  "version": "1.0.0-105",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",
@@ -36,7 +36,7 @@
     "luxon": "^3.0.4",
     "mocha": "^10.0.0",
     "prettier": "^3.1.0",
-    "rimraf": "^5.0.1",
+    "rimraf": "^6.0.1",
     "typescript": "^5.1.6"
   },
   "peerDependencies": {

package/src/breakdown-rule.spec.ts

@@ -1,63 +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,60 +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/measures/energy.ts

@@ -9,4 +9,5 @@ export const units: ReadonlyArray<UnitId> = [
     "calorie",
     "kiloCalorie",
     "megaCalorie",
+    "gigaCalorie",
 ];

package/src/measures/pressure.ts

@@ -2,4 +2,8 @@ import { UnitId } from "../unit-id";
 
 export const units: ReadonlyArray<UnitId> = ["bar", "pascal", "kiloPascal"];
 
-export const sqUnits: ReadonlyArray<UnitId> = ["bar2", "pascal2", "kiloPascal2"];
+export const sqUnits: ReadonlyArray<UnitId> = [
+    "bar2",
+    "pascal2",
+    "kiloPascal2",
+];