@bgord/tools 1.3.23 → 1.4.0

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

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Duration } from "../src/duration.service";
+import { Timestamp } from "../src/timestamp.vo";
+import { TimestampValue } from "../src/timestamp-value.vo";
+import * as mocks from "./mocks";
+describe("Timestamp", () => {
+    test("fromValue - success", () => {
+        expect(Timestamp.fromValue(mocks.TIME_ZERO.ms));
+    });
+    test("fromValue - error", () => {
+        expect(() => Timestamp.fromValue(v.parse(TimestampValue, -1))).toThrow("timestamp.invalid");
+    });
+    test("fromNumber - success", () => {
+        expect(Timestamp.fromNumber(mocks.TIME_ZERO.ms));
+    });
+    test("fromNumber - error", () => {
+        expect(() => Timestamp.fromNumber(-1)).toThrow("timestamp.invalid");
+    });
+    test("fromDate - success", () => {
+        expect(Timestamp.fromDate(mocks.TIME_ZERO_DATE));
+    });
+    test("fromDate - error", () => {
+        expect(() => Timestamp.fromDate(new Date("invalid"))).toThrow("timestamp.invalid");
+    });
+    test("fromDateLike - success", () => {
+        expect(Timestamp.fromDateLike(mocks.TIME_ZERO_DATE_LIKE));
+    });
+    test("fromDateLike - error", () => {
+        expect(() => Timestamp.fromDateLike("invalid")).toThrow("timestamp.invalid");
+    });
+    test("add", () => {
+        expect(mocks.TIME_ZERO.add(Duration.Ms(500)).ms).toEqual(v.parse(TimestampValue, mocks.TIME_ZERO.ms + 500));
+    });
+    test("subtract", () => {
+        expect(mocks.TIME_ZERO.subtract(Duration.Ms(500)).ms).toEqual(v.parse(TimestampValue, mocks.TIME_ZERO.ms - 500));
+    });
+    test("difference", () => {
+        expect(mocks.TIME_ZERO.difference(mocks.TIME_ZERO.subtract(Duration.Minutes(30)))).toEqual(Duration.Minutes(30));
+    });
+    test("isBefore", () => {
+        expect(mocks.TIME_ZERO.isBefore(Timestamp.fromNumber(Date.now()))).toEqual(true);
+        expect(mocks.TIME_ZERO.isBefore(Timestamp.fromNumber(0))).toEqual(false);
+        expect(mocks.TIME_ZERO.isBefore(mocks.TIME_ZERO)).toEqual(false);
+    });
+    test("isBeforeOrEqual", () => {
+        expect(mocks.TIME_ZERO.isBeforeOrEqual(Timestamp.fromNumber(Date.now()))).toEqual(true);
+        expect(mocks.TIME_ZERO.isBeforeOrEqual(Timestamp.fromNumber(0))).toEqual(false);
+        expect(mocks.TIME_ZERO.isBeforeOrEqual(mocks.TIME_ZERO)).toEqual(true);
+    });
+    test("isAfter", () => {
+        expect(mocks.TIME_ZERO.isAfter(Timestamp.fromNumber(0))).toEqual(true);
+        expect(mocks.TIME_ZERO.isAfter(Timestamp.fromNumber(Date.now()))).toEqual(false);
+        expect(mocks.TIME_ZERO.isAfter(mocks.TIME_ZERO)).toEqual(false);
+    });
+    test("isAfterOrEqual", () => {
+        expect(mocks.TIME_ZERO.isAfterOrEqual(Timestamp.fromNumber(Date.now()))).toEqual(false);
+        expect(mocks.TIME_ZERO.isAfterOrEqual(Timestamp.fromNumber(0))).toEqual(true);
+        expect(mocks.TIME_ZERO.isAfterOrEqual(mocks.TIME_ZERO)).toEqual(true);
+    });
+    test("equals", () => {
+        expect(mocks.TIME_ZERO.equals(mocks.TIME_ZERO)).toEqual(true);
+    });
+    test("get", () => {
+        expect(mocks.TIME_ZERO.ms).toEqual(mocks.TIME_ZERO.ms);
+    });
+    test("toJSON", () => {
+        expect(mocks.TIME_ZERO.toJSON()).toEqual(mocks.TIME_ZERO.ms);
+    });
+    test("toString", () => {
+        expect(mocks.TIME_ZERO.toString()).toEqual(mocks.TIME_ZERO.ms.toString());
+    });
+});

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

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

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

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Timezone } from "../src/timezone.vo";
+describe("Timezone", () => {
+    test("happy path", () => {
+        const valid = ["UTC", "America/New_York", "Europe/London", "Asia/Tokyo"];
+        for (const value of valid) {
+            expect(v.safeParse(Timezone, value).success).toEqual(true);
+        }
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(Timezone, "")).toThrow("timezone.empty");
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(Timezone, null)).toThrow("timezone.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(Timezone, 123)).toThrow("timezone.type");
+    });
+    test("rejects too long", () => {
+        expect(() => v.parse(Timezone, "a".repeat(129))).toThrow("timezone.too.long");
+    });
+    test("rejects invalid timezones", () => {
+        const invalid = ["invalid-timezone", "Moon/Base1", "GMT+25"];
+        for (const value of invalid) {
+            expect(() => v.parse(Timezone, value)).toThrow("timezone.invalid");
+        }
+    });
+});

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

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

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

@@ -0,0 +1,24 @@
+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

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

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

@@ -0,0 +1,25 @@
+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

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

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

@@ -0,0 +1,89 @@
+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

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

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

@@ -0,0 +1,37 @@
+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

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

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

@@ -0,0 +1,64 @@
+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

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

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

@@ -0,0 +1,24 @@
+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

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

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

@@ -0,0 +1,51 @@
+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

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

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

@@ -0,0 +1,21 @@
+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

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

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

@@ -0,0 +1,66 @@
+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

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

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

@@ -0,0 +1,23 @@
+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

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