@bgord/tools 1.4.0 → 1.4.1

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

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

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

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

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

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

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 {};