@bgord/tools 1.4.0 → 1.4.2

package/dist/tests/url-with-slash.vo.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { UrlWithSlash } from "../src/url-with-slash.vo";
-describe("UrlWithSlash", () => {
-    test("happy path", () => {
-        expect(v.safeParse(UrlWithSlash, "https://example.com/").success).toEqual(true);
-        expect(v.safeParse(UrlWithSlash, "http://localhost/foo/bar/").success).toEqual(true);
-    });
-    test("rejects empty", () => {
-        expect(() => v.parse(UrlWithSlash, "")).toThrow("url.with.slash.invalid");
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(UrlWithSlash, null)).toThrow("url.with.slash.invalid");
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(UrlWithSlash, 123)).toThrow("url.with.slash.invalid");
-    });
-    test("rejects invalid url", () => {
-        expect(() => v.parse(UrlWithSlash, "not-a-url")).toThrow("url.with.slash.invalid");
-    });
-    test("rejects url without slash", () => {
-        expect(() => v.parse(UrlWithSlash, "https://example.com")).toThrow("url.with.slash.invalid");
-    });
-});

package/dist/tests/url-without-slash.vo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/url-without-slash.vo.test.js

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { UrlWithoutSlash } from "../src/url-without-slash.vo";
-describe("UrlWithoutSlash", () => {
-    test("happy path", () => {
-        expect(v.safeParse(UrlWithoutSlash, "https://example.com").success).toEqual(true);
-        expect(v.safeParse(UrlWithoutSlash, "http://localhost/foo/bar").success).toEqual(true);
-        expect(v.safeParse(UrlWithoutSlash, "http://localhost:3000").success).toEqual(true);
-    });
-    test("rejects empty", () => {
-        expect(() => v.parse(UrlWithoutSlash, "")).toThrow("url.without.slash.invalid");
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(UrlWithoutSlash, null)).toThrow("url.without.slash.invalid");
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(UrlWithoutSlash, 123)).toThrow("url.without.slash.invalid");
-    });
-    test("rejects invalid url", () => {
-        expect(() => v.parse(UrlWithoutSlash, "not-a-url")).toThrow("url.without.slash.invalid");
-    });
-    test("rejects url with slash", () => {
-        expect(() => v.parse(UrlWithoutSlash, "https://example.com/")).toThrow("url.without.slash.invalid");
-    });
-});

package/dist/tests/visually-unambiguous-characters-generator.service.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/visually-unambiguous-characters-generator.service.test.js

@@ -1,89 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { describe, expect, spyOn, test } from "bun:test";
-import { Random } from "../src/random.service";
-import { VisuallyUnambiguousCharactersGenerator } from "../src/visually-unambiguous-characters-generator.service";
-describe("VisuallyUnambiguousCharactersGenerator", () => {
-    test("default length", () => {
-        expect(VisuallyUnambiguousCharactersGenerator.chars).toContain(VisuallyUnambiguousCharactersGenerator.generate());
-    });
-    test("length of 5", () => {
-        const result = VisuallyUnambiguousCharactersGenerator.generate(5);
-        expect(result.length).toEqual(5);
-        result.split("").forEach((character) => {
-            expect(VisuallyUnambiguousCharactersGenerator.chars).toContain(character);
-        });
-    });
-    test("single charactes allowed", () => {
-        VisuallyUnambiguousCharactersGenerator.chars.forEach((character) => expect(character.length).toEqual(1));
-        expect(VisuallyUnambiguousCharactersGenerator.chars.length).toBeGreaterThan(0);
-    });
-    test("correct random bounds", () => {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const randomSpy = __addDisposableResource(env_1, spyOn(Random, "generate").mockReturnValue(0), false);
-            VisuallyUnambiguousCharactersGenerator.generate();
-            expect(randomSpy).toHaveBeenCalledWith({
-                min: 0,
-                max: VisuallyUnambiguousCharactersGenerator.chars.length - 1,
-            });
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    });
-});

package/dist/tests/week-iso-id.vo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/week-iso-id.vo.test.js

@@ -1,37 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { WeekIsoId } from "../src/week-iso-id.vo";
-describe("WeekIsoId", () => {
-    test("happy path", () => {
-        expect(v.safeParse(WeekIsoId, "2025-W30").success).toEqual(true);
-        expect(v.safeParse(WeekIsoId, "2026-W01").success).toEqual(true);
-        expect(v.safeParse(WeekIsoId, "2020-W53").success).toEqual(true);
-    });
-    test("rejects prefix", () => {
-        expect(() => v.parse(WeekIsoId, "prefix2025-W01")).toThrow("week.iso.id.bad.chars");
-    });
-    test("rejects suffix", () => {
-        expect(() => v.parse(WeekIsoId, "2025-W01suffix")).toThrow("week.iso.id.bad.chars");
-    });
-    test("rejects empty", () => {
-        expect(() => v.parse(WeekIsoId, "")).toThrow("week.iso.id.bad.chars");
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(WeekIsoId, null)).toThrow("week.iso.id.type");
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(WeekIsoId, 123)).toThrow("week.iso.id.type");
-    });
-    test("rejects strings not matching the format", () => {
-        expect(() => v.parse(WeekIsoId, "2025-30")).toThrow("week.iso.id.bad.chars");
-        expect(() => v.parse(WeekIsoId, "25-W30")).toThrow("week.iso.id.bad.chars");
-        expect(() => v.parse(WeekIsoId, "2025-W3")).toThrow("week.iso.id.bad.chars");
-    });
-    test("rejects week numbers < 1 or > 53", () => {
-        expect(() => v.parse(WeekIsoId, "2025-W00")).toThrow("week.iso.id.invalid");
-        expect(() => v.parse(WeekIsoId, "2025-W54")).toThrow("week.iso.id.invalid");
-    });
-    test("rejects week 53 in a year that only has 52 ISO weeks", () => {
-        expect(() => v.parse(WeekIsoId, "2021-W53")).toThrow("week.iso.id.invalid");
-    });
-});

package/dist/tests/week.vo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/week.vo.test.js

@@ -1,64 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { endOfISOWeek, startOfISOWeek } from "date-fns";
-import * as v from "valibot";
-import { Duration } from "../src/duration.service";
-import { Integer } from "../src/integer.vo";
-import { Timestamp } from "../src/timestamp.vo";
-import { Week } from "../src/week.vo";
-import { WeekIsoId } from "../src/week-iso-id.vo";
-import * as mocks from "./mocks";
-const w46 = v.parse(WeekIsoId, "2023-W46");
-describe("Week", () => {
-    test("happy path", () => {
-        const week = Week.fromTimestamp(mocks.TIME_ZERO);
-        const expectedStart = Timestamp.fromNumber(startOfISOWeek(mocks.TIME_ZERO.ms).getTime());
-        const expectedEnd = Timestamp.fromNumber(endOfISOWeek(mocks.TIME_ZERO.ms).getTime());
-        expect(week.getStart()).toEqual(expectedStart);
-        expect(week.getEnd()).toEqual(expectedEnd);
-        expect(week.toIsoId()).toEqual(w46);
-        expect(week.contains(mocks.TIME_ZERO)).toEqual(true);
-    });
-    test("happy path - ISO week spills into the next year", () => {
-        const timestamp = Timestamp.fromDateLike("2025-12-31T23:59:59Z");
-        const week = Week.fromTimestamp(timestamp);
-        expect(week.toIsoId()).toEqual(v.parse(WeekIsoId, "2026-W01"));
-        expect(week.getStart()).toEqual(Timestamp.fromNumber(startOfISOWeek(timestamp.ms).getTime()));
-        expect(week.getEnd()).toEqual(Timestamp.fromNumber(endOfISOWeek(timestamp.ms).getTime()));
-    });
-    test("fromNow", () => {
-        expect(Week.fromNow(mocks.TIME_ZERO).toIsoId()).toEqual(w46);
-    });
-    test("fromTimestamp", () => {
-        expect(Week.fromTimestamp(mocks.TIME_ZERO).toIsoId()).toEqual(w46);
-    });
-    test("fromTimestampValue", () => {
-        expect(Week.fromTimestampValue(mocks.TIME_ZERO.ms).toIsoId()).toEqual(w46);
-    });
-    test("fromIsoId", () => {
-        expect(Week.fromIsoId(w46).toIsoId()).toEqual(w46);
-    });
-    test("next", () => {
-        expect(Week.fromTimestamp(mocks.TIME_ZERO).next().toIsoId()).toEqual(v.parse(WeekIsoId, "2023-W47"));
-    });
-    test("previous", () => {
-        expect(Week.fromTimestamp(mocks.TIME_ZERO).previous().toIsoId()).toEqual(v.parse(WeekIsoId, "2023-W45"));
-    });
-    test("shift", () => {
-        expect(Week.fromTimestamp(mocks.TIME_ZERO).shift(v.parse(Integer, 2)).toIsoId()).toEqual(v.parse(WeekIsoId, "2023-W48"));
-        expect(Week.fromTimestamp(mocks.TIME_ZERO).shift(v.parse(Integer, -2)).toIsoId()).toEqual(v.parse(WeekIsoId, "2023-W44"));
-    });
-    test("round-trips", () => {
-        expect(Week.fromIsoId(w46).toIsoId()).toEqual(w46);
-    });
-    test("contains", () => {
-        const week = Week.fromTimestamp(mocks.TIME_ZERO);
-        expect(week.contains(week.getStart().subtract(Duration.Ms(1)))).toEqual(false);
-        expect(week.contains(week.getEnd().add(Duration.Ms(1)))).toEqual(false);
-    });
-    test("toString", () => {
-        expect(Week.fromIsoId(w46).toString()).toEqual(w46);
-    });
-    test("toJSON", () => {
-        expect(Week.fromIsoId(w46).toJSON()).toEqual({ start: 1699833600000, end: 1700438399999 });
-    });
-});

package/dist/tests/weekday-iso-id.vo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/weekday-iso-id.vo.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { WeekdayIsoId } from "../src/weekday-iso-id.vo";
-describe("WeekdayIsoId VO", () => {
-    test("happy path", () => {
-        expect(v.safeParse(WeekdayIsoId, 1).success).toEqual(true);
-        expect(v.safeParse(WeekdayIsoId, 7).success).toEqual(true);
-    });
-    test("rejects non-number - null", () => {
-        expect(() => v.parse(WeekdayIsoId, null)).toThrow("weekday.iso.id.type");
-    });
-    test("rejects non-number - string", () => {
-        expect(() => v.parse(WeekdayIsoId, "100")).toThrow("weekday.iso.id.type");
-    });
-    test("rejects fraction", () => {
-        expect(() => v.parse(WeekdayIsoId, 100.5)).toThrow("weekday.iso.id.type");
-    });
-    test("rejects too small", () => {
-        expect(() => v.parse(WeekdayIsoId, 0)).toThrow("weekday.iso.id.invalid");
-    });
-    test("rejects too big", () => {
-        expect(() => v.parse(WeekdayIsoId, 8)).toThrow("weekday.iso.id.invalid");
-    });
-});

package/dist/tests/weekday.vo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/weekday.vo.test.js

@@ -1,51 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Timestamp } from "../src/timestamp.vo";
-import { Weekday } from "../src/weekday.vo";
-import { WeekdayIsoId } from "../src/weekday-iso-id.vo";
-import * as mocks from "./mocks";
-describe("Weekday", () => {
-    test("predefined", () => {
-        expect(Weekday.MONDAY.isMonday()).toEqual(true);
-        expect(Weekday.fromIsoId(v.parse(WeekdayIsoId, 1)).get()).toEqual(v.parse(WeekdayIsoId, 1));
-        expect(Weekday.TUESDAY.isTuesday()).toEqual(true);
-        expect(Weekday.fromIsoId(v.parse(WeekdayIsoId, 2)).get()).toEqual(v.parse(WeekdayIsoId, 2));
-        expect(Weekday.WEDNESDAY.isWednesday()).toEqual(true);
-        expect(Weekday.fromIsoId(v.parse(WeekdayIsoId, 3)).get()).toEqual(v.parse(WeekdayIsoId, 3));
-        expect(Weekday.THURSDAY.isThursday()).toEqual(true);
-        expect(Weekday.fromIsoId(v.parse(WeekdayIsoId, 4)).get()).toEqual(v.parse(WeekdayIsoId, 4));
-        expect(Weekday.FRIDAY.isFriday()).toEqual(true);
-        expect(Weekday.fromIsoId(v.parse(WeekdayIsoId, 5)).get()).toEqual(v.parse(WeekdayIsoId, 5));
-        expect(Weekday.SATURDAY.isSaturday()).toEqual(true);
-        expect(Weekday.fromIsoId(v.parse(WeekdayIsoId, 6)).get()).toEqual(v.parse(WeekdayIsoId, 6));
-        expect(Weekday.SUNDAY.isSunday()).toEqual(true);
-        expect(Weekday.fromIsoId(v.parse(WeekdayIsoId, 7)).get()).toEqual(v.parse(WeekdayIsoId, 7));
-    });
-    test("fromTimestamp", () => {
-        const weekday = Weekday.fromTimestamp(mocks.TIME_ZERO);
-        expect(weekday.isTuesday()).toEqual(true);
-    });
-    test("fromTimestamp - sunday", () => {
-        const timestamp = Timestamp.fromDateLike("2026-02-08T12:00:00.000Z");
-        const weekday = Weekday.fromTimestamp(timestamp);
-        expect(weekday.isSunday()).toEqual(true);
-    });
-    test("fromTimestampValue", () => {
-        const weekday = Weekday.fromTimestampValue(mocks.TIME_ZERO.ms);
-        expect(weekday.isTuesday()).toEqual(true);
-    });
-    test("fromIsoId", () => {
-        const weekday = Weekday.fromIsoId(v.parse(WeekdayIsoId, 1));
-        expect(weekday.isMonday()).toEqual(true);
-    });
-    test("equals", () => {
-        expect(Weekday.MONDAY.equals(Weekday.MONDAY)).toEqual(true);
-        expect(Weekday.MONDAY.equals(Weekday.WEDNESDAY)).toEqual(false);
-    });
-    test("toString", () => {
-        expect(Weekday.MONDAY.toString()).toEqual("1");
-    });
-    test("toJSON", () => {
-        expect(Weekday.MONDAY.toJSON()).toEqual(1);
-    });
-});

package/dist/tests/weight-grams.vo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/weight-grams.vo.test.js

@@ -1,21 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { WeightGrams } from "../src/weight-grams.vo";
-describe("WeightGrams", () => {
-    test("happy path", () => {
-        expect(v.safeParse(WeightGrams, 0).success).toEqual(true);
-        expect(v.safeParse(WeightGrams, 130).success).toEqual(true);
-    });
-    test("rejects non-number - null", () => {
-        expect(() => v.parse(WeightGrams, null)).toThrow("weight.grams.type");
-    });
-    test("rejects non-number - string", () => {
-        expect(() => v.parse(WeightGrams, "123")).toThrow("weight.grams.type");
-    });
-    test("rejects negative numbers", () => {
-        expect(() => v.parse(WeightGrams, -1)).toThrow("weight.grams.invalid");
-    });
-    test("rejects fractions", () => {
-        expect(() => v.parse(WeightGrams, 1.5)).toThrow("weight.grams.type");
-    });
-});

package/dist/tests/weight.vo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/weight.vo.test.js

@@ -1,66 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { DivisionFactor } from "../src/division-factor.vo";
-import { MultiplicationFactor } from "../src/multiplication-factor.vo";
-import { RoundingDecimalStrategy } from "../src/rounding-decimal.strategy";
-import { Weight } from "../src/weight.vo";
-const twoDecimals = new RoundingDecimalStrategy(2);
-const threeDecimals = new RoundingDecimalStrategy(3);
-const factor = v.parse(DivisionFactor, 3);
-describe("Weight", () => {
-    test("fromKilograms", () => {
-        expect(Weight.fromKilograms(0.1).get()).toEqual(100);
-        expect(Weight.fromKilograms(0.333).get()).toEqual(333);
-        expect(Weight.fromKilograms(20).get()).toEqual(20_000);
-    });
-    test("fromGrams", () => {
-        expect(Weight.fromGrams(5).get()).toEqual(5);
-    });
-    test("guards invalid inputs", () => {
-        expect(() => Weight.fromKilograms(-1)).toThrow("weight.grams.invalid");
-    });
-    test("toKilograms", () => {
-        expect(Weight.fromKilograms(10, threeDecimals).toKilograms()).toEqual(10.0);
-    });
-    test("format", () => {
-        expect(Weight.fromKilograms(12.5, twoDecimals).format()).toEqual("12500 g");
-    });
-    test("operations", () => {
-        const a = Weight.fromGrams(19_600);
-        const b = a.add(Weight.fromKilograms(0.7));
-        expect(b.get()).toEqual(20_300);
-        expect(Weight.fromGrams(1_000).subtract(Weight.fromGrams(2_000)).get()).toEqual(0);
-        expect(Weight.fromGrams(1_000).subtract(Weight.fromGrams(1_000)).get()).toEqual(0);
-        expect(Weight.fromGrams(1_001).multiply(v.parse(MultiplicationFactor, 0.5)).get()).toEqual(501);
-        expect(Weight.fromGrams(1_999).divide(factor).get()).toEqual(666);
-    });
-    test("equals", () => {
-        const a = Weight.fromGrams(1800);
-        const b = Weight.fromGrams(180);
-        expect(a.equals(a)).toEqual(true);
-        expect(a.equals(b)).toEqual(false);
-    });
-    test("greaterThan", () => {
-        const a = Weight.fromGrams(1800);
-        const b = Weight.fromGrams(180);
-        expect(a.greaterThan(a)).toEqual(false);
-        expect(a.greaterThan(b)).toEqual(true);
-    });
-    test("lessThan", () => {
-        const a = Weight.fromGrams(180);
-        const b = Weight.fromGrams(1800);
-        expect(a.lessThan(a)).toEqual(false);
-        expect(a.lessThan(b)).toEqual(true);
-    });
-    test("isZero", () => {
-        const a = Weight.fromGrams(10);
-        expect(Weight.zero().isZero()).toEqual(true);
-        expect(a.isZero()).toEqual(false);
-    });
-    test("toString", () => {
-        expect(Weight.fromGrams(1804).toString()).toEqual("1804 g");
-    });
-    test("toJSON", () => {
-        expect(Weight.fromGrams(1804).toJSON()).toEqual(1804);
-    });
-});

package/dist/tests/year-iso-id.vo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/year-iso-id.vo.test.js

@@ -1,23 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { YearIsoId } from "../src/year-iso-id.vo";
-describe("YearIsoId", () => {
-    test("happy path", () => {
-        const valid = ["0000", "1970", "1999", "2024", "2025", "9999"];
-        for (const year of valid) {
-            expect(v.safeParse(YearIsoId, year).success).toEqual(true);
-        }
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(YearIsoId, null)).toThrow("year.iso.id.type");
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(YearIsoId, 123)).toThrow("year.iso.id.type");
-    });
-    test("rejects invalid year", () => {
-        expect(() => v.parse(YearIsoId, "202A")).toThrow("year.iso.id.bad.chars");
-    });
-    test("rejects 5 digits year", () => {
-        expect(() => v.parse(YearIsoId, "202A")).toThrow("year.iso.id.bad.chars");
-    });
-});

package/dist/tests/year.vo.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/year.vo.test.js

@@ -1,79 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { endOfYear, startOfYear } from "date-fns";
-import * as v from "valibot";
-import { Duration } from "../src/duration.service";
-import { Integer } from "../src/integer.vo";
-import { Timestamp } from "../src/timestamp.vo";
-import { Year } from "../src/year.vo";
-import { YearIsoId } from "../src/year-iso-id.vo";
-import * as mocks from "./mocks";
-const twentyTwentyThree = v.parse(YearIsoId, "2023");
-describe("Year", () => {
-    test("happy path", () => {
-        const year = Year.fromTimestamp(mocks.TIME_ZERO);
-        expect(year.getStart()).toEqual(Timestamp.fromNumber(startOfYear(mocks.TIME_ZERO.ms).getTime()));
-        expect(year.getEnd()).toEqual(Timestamp.fromNumber(endOfYear(mocks.TIME_ZERO.ms).getTime()));
-        expect(year.toIsoId()).toEqual(twentyTwentyThree);
-        expect(year.contains(mocks.TIME_ZERO)).toEqual(true);
-    });
-    test("happy path - near year boundary", () => {
-        const timestamp = Timestamp.fromDateLike("2025-12-31T23:59:59Z");
-        const year = Year.fromTimestamp(timestamp);
-        expect(year.getStart()).toEqual(Timestamp.fromNumber(startOfYear(timestamp.ms).getTime()));
-        expect(year.getEnd()).toEqual(Timestamp.fromNumber(endOfYear(timestamp.ms).getTime()));
-        expect(year.toIsoId()).toEqual(v.parse(YearIsoId, "2025"));
-    });
-    test("fromNumber rejects invalid inputs", () => {
-        expect(() => Year.fromNumber(-1)).toThrow("year.iso.id.bad.chars");
-        expect(() => Year.fromNumber(10000)).toThrow("year.iso.id.bad.chars");
-        expect(() => Year.fromNumber(2025.5)).toThrow("year.iso.id.bad.chars");
-        expect(() => Year.fromNumber(Number.NaN)).toThrow("year.iso.id.bad.chars");
-    });
-    test("fromNumber", () => {
-        const valid = [1970, 1999, 2024, 2025, 2026];
-        for (const value of valid) {
-            expect(Year.fromNumber(value).toIsoId()).toEqual(v.parse(YearIsoId, value.toString()));
-        }
-    });
-    test("fromNow", () => {
-        expect(Year.fromNow(mocks.TIME_ZERO).toIsoId()).toEqual(twentyTwentyThree);
-    });
-    test("fromTimestampValue", () => {
-        expect(Year.fromTimestampValue(mocks.TIME_ZERO.ms).toIsoId()).toEqual(twentyTwentyThree);
-    });
-    test("fromIsoId", () => {
-        expect(Year.fromIsoId(twentyTwentyThree).toIsoId()).toEqual(twentyTwentyThree);
-    });
-    test("next", () => {
-        expect(Year.fromTimestamp(mocks.TIME_ZERO).next().toIsoId()).toEqual(v.parse(YearIsoId, "2024"));
-    });
-    test("previous", () => {
-        expect(Year.fromTimestamp(mocks.TIME_ZERO).previous().toIsoId()).toEqual(v.parse(YearIsoId, "2022"));
-    });
-    test("shift", () => {
-        expect(Year.fromTimestamp(mocks.TIME_ZERO).shift(v.parse(Integer, 2)).toIsoId()).toEqual(v.parse(YearIsoId, "2025"));
-        expect(Year.fromTimestamp(mocks.TIME_ZERO).shift(v.parse(Integer, -2)).toIsoId()).toEqual(v.parse(YearIsoId, "2021"));
-    });
-    test("round-trips", () => {
-        const ids = ["1970", "1999", "2024", "2025", "2026"].map((value) => v.parse(YearIsoId, value));
-        for (const id of ids) {
-            expect(Year.fromIsoId(id).toIsoId()).toEqual(id);
-        }
-    });
-    test("contains", () => {
-        const year = Year.fromTimestamp(mocks.TIME_ZERO);
-        expect(year.contains(year.getStart().subtract(Duration.Ms(1)))).toEqual(false);
-        expect(year.contains(year.getEnd().add(Duration.Ms(1)))).toEqual(false);
-    });
-    test("leap year check for 2000", () => expect(Year.fromNumber(2000).isLeapYear()).toEqual(true));
-    test("leap year check for 2010", () => expect(Year.fromNumber(2010).isLeapYear()).toEqual(false));
-    test("leap year check for 2024", () => expect(Year.fromNumber(2024).isLeapYear()).toEqual(true));
-    test("leap year check for 2400", () => expect(Year.fromNumber(2400).isLeapYear()).toEqual(true));
-    test("leap year check for 2100", () => expect(Year.fromNumber(2100).isLeapYear()).toEqual(false));
-    test("toString", () => {
-        expect(Year.fromIsoId(twentyTwentyThree).toString()).toEqual("2023");
-    });
-    test("toJSON", () => {
-        expect(Year.fromIsoId(twentyTwentyThree).toJSON()).toEqual({ start: 1672531200000, end: 1704067199999 });
-    });
-});

package/dist/tests/z-score.service.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/z-score.service.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { RoundingToNearestStrategy } from "../src/rounding-to-nearest.strategy";
-import { ZScore } from "../src/z-score.service";
-describe("Z-score", () => {
-    test("throws for empty values array", () => {
-        expect(() => new ZScore([])).toThrow("z.score.not.enough.values");
-    });
-    test("works for all zeros", () => {
-        expect(new ZScore([0, 0, 0]).calculate(1)).toEqual(Number.POSITIVE_INFINITY);
-    });
-    test("throws for one value", () => {
-        expect(() => new ZScore([1])).toThrow("z.score.not.enough.values");
-    });
-    test("works for two values", () => {
-        expect(new ZScore([1, 2]).calculate(1)).toEqual(-1);
-    });
-    test("works for two values", () => {
-        expect(new ZScore([1, 2]).calculate(2)).toEqual(1);
-    });
-    test("works for a set of values", () => {
-        expect(new ZScore([1, 1, 1, 2, 2, 3, 3, 3, 10]).calculate(2)).toEqual(-0.34);
-    });
-    test("non-default rounding", () => {
-        expect(new ZScore([1, 1, 1, 2, 2, 3, 3, 3, 10], new RoundingToNearestStrategy()).calculate(1)).toEqual(-1);
-    });
-});