@bgord/tools 1.3.24 → 1.4.0

package/dist/{year.vo.js → src/year.vo.js}

@@ -1,4 +1,5 @@
 import { endOfYear, getYear, startOfYear } from "date-fns";
+import * as v from "valibot";
 import { DateRange } from "./date-range.vo";
 import { Integer } from "./integer.vo";
 import { Timestamp } from "./timestamp.vo";
@@ -16,14 +17,14 @@ export class Year extends DateRange {
         return Year.fromTimestamp(now);
     }
     static fromNumber(candidate) {
-        return Year.fromIsoId(YearIsoId.parse(String(candidate)));
+        return Year.fromIsoId(v.parse(YearIsoId, String(candidate)));
     }
     static fromIsoId(isoId) {
         const year = Number(isoId);
         return new Year(Timestamp.fromNumber(Date.UTC(year, 0, 1)), Timestamp.fromNumber(Date.UTC(year + 1, 0, 1) - 1));
     }
     toIsoId() {
-        return YearIsoId.parse(String(getYear(this.getStart().ms)));
+        return v.parse(YearIsoId, String(getYear(this.getStart().ms)));
     }
     isLeapYear() {
         const year = getYear(this.getStart().ms);
@@ -34,14 +35,14 @@ export class Year extends DateRange {
         return year % 4 === 0;
     }
     previous() {
-        return this.shift(Integer.parse(-1));
+        return this.shift(v.parse(Integer, -1));
     }
     next() {
-        return this.shift(Integer.parse(1));
+        return this.shift(v.parse(Integer, 1));
     }
     shift(count) {
         const year = getYear(this.getStart().ms) + count;
-        return Year.fromIsoId(YearIsoId.parse(String(year)));
+        return Year.fromNumber(year);
     }
     toString() {
         return this.toIsoId();

package/dist/tests/age-years.vo.test.d.ts

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

package/dist/tests/age-years.vo.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { AgeYears } from "../src/age-years.vo";
+describe("AgeYears", () => {
+    test("happy path", () => {
+        expect(v.safeParse(AgeYears, 0).success).toEqual(true);
+        expect(v.safeParse(AgeYears, 130).success).toEqual(true);
+    });
+    test("rejects non-number - null", () => {
+        expect(() => v.parse(AgeYears, null)).toThrow("age.years.type");
+    });
+    test("rejects non-number - string", () => {
+        expect(() => v.parse(AgeYears, "100")).toThrow("age.years.type");
+    });
+    test("rejects fraction", () => {
+        expect(() => v.parse(AgeYears, 100.5)).toThrow("age.years.type");
+    });
+    test("rejects negative", () => {
+        expect(() => v.parse(AgeYears, -1)).toThrow("age.years.invalid");
+    });
+    test("rejects 131", () => {
+        expect(() => v.parse(AgeYears, 131)).toThrow("age.years.invalid");
+    });
+});

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

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

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

@@ -0,0 +1,106 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Age } from "../src/age.vo";
+import { AgeYears } from "../src/age-years.vo";
+import { Timestamp } from "../src/timestamp.vo";
+import * as mocks from "./mocks";
+const min = v.parse(AgeYears, 0);
+const max = v.parse(AgeYears, 130);
+const twentyThree = v.parse(AgeYears, 23);
+describe("Age", () => {
+    test("fromValue", () => {
+        expect(Age.fromValue(0).get()).toEqual(min);
+        expect(Age.fromValue(130).get()).toEqual(max);
+    });
+    test("fromValueSafe", () => {
+        expect(Age.fromValueSafe(min).get()).toEqual(min);
+        expect(Age.fromValueSafe(max).get()).toEqual(max);
+    });
+    test("fromBirthdateTimestamp - birthday has already happened", () => {
+        expect(Age.fromBirthdateTimestamp({
+            birthdate: Timestamp.fromDateLike("2000-11-13"),
+            now: mocks.TIME_ZERO,
+        }).get()).toEqual(twentyThree);
+    });
+    test("fromBirthdateTimestamp - birthday has NOT yet happened", () => {
+        expect(Age.fromBirthdateTimestamp({
+            birthdate: Timestamp.fromDateLike("2000-11-15"),
+            now: mocks.TIME_ZERO,
+        }).get()).toEqual(v.parse(AgeYears, 22));
+    });
+    test("fromBirthdateTimestamp - exactly on birthday", () => {
+        expect(Age.fromBirthdateTimestamp({
+            birthdate: Timestamp.fromDateLike("2000-11-14"),
+            now: mocks.TIME_ZERO,
+        }).get()).toEqual(twentyThree);
+    });
+    test("fromBirthdateTimestamp - rejects future birthdates", () => {
+        expect(() => Age.fromBirthdateTimestamp({ birthdate: Timestamp.fromDateLike("2125-10-01"), now: mocks.TIME_ZERO })).toThrowError("age.future.birthdate");
+    });
+    test("fromBirthdate - birthday has already happened", () => {
+        expect(Age.fromBirthdate({ birthdate: "2000-11-13", now: mocks.TIME_ZERO }).get()).toEqual(twentyThree);
+    });
+    test("fromBirthdate - birthday has NOT yet happened", () => {
+        expect(Age.fromBirthdate({ birthdate: "2000-11-15", now: mocks.TIME_ZERO }).get()).toEqual(v.parse(AgeYears, 22));
+    });
+    test("fromBirthdate - exactly on birthday", () => {
+        expect(Age.fromBirthdate({ birthdate: "2000-11-14", now: mocks.TIME_ZERO }).get()).toEqual(twentyThree);
+    });
+    test("fromBirthdate - rejects future birthdates", () => {
+        expect(() => Age.fromBirthdate({ birthdate: "2125-10-01", now: mocks.TIME_ZERO })).toThrowError("age.future.birthdate");
+    });
+    test("fromBirthdate - rejects above upper bound", () => {
+        expect(() => Age.fromBirthdate({ birthdate: "1800-01-01", now: mocks.TIME_ZERO })).toThrow("timestamp.invalid");
+    });
+    test("fromBirthdate - invalid date string throws", () => {
+        expect(() => Age.fromBirthdate({ birthdate: "not-a-date", now: mocks.TIME_ZERO })).toThrow("timestamp.invalid");
+    });
+    test("MIN", () => {
+        expect(Age.MIN).toEqual(0);
+    });
+    test("MAX", () => {
+        expect(Age.MAX).toEqual(130);
+    });
+    test("get", () => {
+        expect(Age.fromValue(twentyThree).get()).toEqual(twentyThree);
+    });
+    test("equals - true", () => {
+        const first = Age.fromValue(18);
+        const second = Age.fromValue(18);
+        expect(first.equals(second)).toEqual(true);
+    });
+    test("equals - false", () => {
+        const first = Age.fromValue(18);
+        const second = Age.fromValue(19);
+        expect(first.equals(second)).toEqual(false);
+    });
+    test("isOlderThan", () => {
+        const youngerAge = Age.fromValue(17);
+        const olderAge = Age.fromValue(18);
+        expect(olderAge.isOlderThan(youngerAge)).toEqual(true);
+        expect(youngerAge.isOlderThan(olderAge)).toEqual(false);
+        expect(youngerAge.isOlderThan(youngerAge)).toEqual(false);
+    });
+    test("isYoungerThan", () => {
+        const youngerAge = Age.fromValue(17);
+        const olderAge = Age.fromValue(18);
+        expect(youngerAge.isYoungerThan(olderAge)).toEqual(true);
+        expect(olderAge.isYoungerThan(youngerAge)).toEqual(false);
+        expect(youngerAge.isYoungerThan(youngerAge)).toEqual(false);
+    });
+    test("isAdult - treats exactly the same age as adult", () => {
+        expect(Age.fromValue(18).isAdult(Age.fromValue(18))).toEqual(true);
+    });
+    test("isAdult - treats older age as adult", () => {
+        expect(Age.fromValue(21).isAdult(Age.fromValue(18))).toEqual(true);
+    });
+    test("isAdult - treats younger age as not adult", () => {
+        expect(Age.fromValue(17).isAdult(Age.fromValue(18))).toEqual(false);
+    });
+    test("toString", () => {
+        expect(Age.fromValue(42).toString()).toEqual("42");
+    });
+    test("toJSON", () => {
+        expect(Age.fromValue(42).toJSON()).toEqual(42);
+    });
+});

package/dist/tests/api-key.vo.test.d.ts

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

package/dist/tests/api-key.vo.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { ApiKey } from "../src/api-key.vo";
+describe("ApiKey", () => {
+    test("happy path", () => {
+        expect(v.safeParse(ApiKey, "a".repeat(64)).success).toEqual(true);
+        expect(v.safeParse(ApiKey, "A".repeat(64)).success).toEqual(true);
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(ApiKey, null)).toThrow("api.key.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(ApiKey, 123)).toThrow("api.key.type");
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(ApiKey, "")).toThrow("api.key.bad.chars");
+    });
+    test("rejects too long", () => {
+        expect(() => v.parse(ApiKey, `${"a".repeat(64)}abc`)).toThrow("api.key.bad.chars");
+    });
+    test("rejects bad chars", () => {
+        expect(() => v.parse(ApiKey, `${"a".repeat(63)}!`)).toThrow("api.key.bad.chars");
+    });
+});

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

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

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

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Basename } from "../src/basename.vo";
+describe("Basename", () => {
+    test("happy path", () => {
+        expect(v.safeParse(Basename, "avatar").success).toEqual(true);
+        expect(v.safeParse(Basename, "Report_v1.2-rc").success).toEqual(true);
+        expect(v.safeParse(Basename, "a".repeat(128)).success).toEqual(true);
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(Basename, null)).toThrow("basename.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(Basename, 42)).toThrow("basename.type");
+    });
+    test("rejects 129 chars", () => {
+        expect(() => v.parse(Basename, "a".repeat(129))).toThrow("basename.too.long");
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(Basename, "")).toThrow("basename.empty");
+    });
+    test("rejects forward slash", () => {
+        expect(() => v.parse(Basename, "a/b")).toThrow("basename.bad.chars");
+    });
+    test("rejects backslash", () => {
+        expect(() => v.parse(Basename, "a\\b")).toThrow("basename.bad.chars");
+    });
+    test("rejects control chars", () => {
+        expect(() => v.parse(Basename, "line\nbreak")).toThrow("basename.bad.chars");
+        expect(() => v.parse(Basename, "nul\u0000byte")).toThrow("basename.bad.chars");
+    });
+    test("rejects single dot", () => {
+        expect(() => v.parse(Basename, ".")).toThrow("basename.dot.segments");
+    });
+    test("rejects double dot", () => {
+        expect(() => v.parse(Basename, "..")).toThrow("basename.dot.segments");
+    });
+    test("rejects dotfile", () => {
+        expect(() => v.parse(Basename, ".env")).toThrow("basename.dotfiles");
+    });
+    test("rejects trailing dot", () => {
+        expect(() => v.parse(Basename, "name.")).toThrow("basename.trailing.dot");
+    });
+    test("rejects space", () => {
+        expect(() => v.parse(Basename, "name name")).toThrow("basename.bad.chars");
+    });
+    test("rejects emoji", () => {
+        expect(() => v.parse(Basename, "name🙂")).toThrow("basename.bad.chars");
+    });
+    test("rejects symbol", () => {
+        expect(() => v.parse(Basename, "name@")).toThrow("basename.bad.chars");
+    });
+});

package/dist/tests/batch.test.d.ts

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

package/dist/tests/batch.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { batch } from "../src/batch";
+import { IntegerPositive } from "../src/integer-positive.vo";
+const size = v.parse(IntegerPositive, 10);
+describe("batch", () => {
+    test("happy path", () => {
+        const strings = Array.from({ length: 25 }, (_, i) => `item-${i}`);
+        const result = batch(strings, size);
+        expect(result.length).toEqual(3);
+        expect(result[0].length).toEqual(10);
+        expect(result[1].length).toEqual(10);
+        expect(result[2].length).toEqual(5);
+    });
+    test("happy path - less than size", () => {
+        const strings = ["a", "b", "c"];
+        const result = batch(strings, size);
+        expect(result.length).toEqual(1);
+        expect(result[0]).toEqual(["a", "b", "c"]);
+    });
+    test("empty array", () => {
+        expect(batch([], size)).toEqual([]);
+    });
+});

package/dist/tests/date-calculator.service.test.d.ts

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

package/dist/tests/date-calculator.service.test.js

@@ -0,0 +1,32 @@
+import { afterEach, beforeEach, describe, expect, jest, test } from "bun:test";
+import { DateCalculator } from "../src/date-calculator.service";
+import { Duration } from "../src/duration.service";
+import { Timestamp } from "../src/timestamp.vo";
+describe("DateCalculator", () => {
+    beforeEach(() => jest.setSystemTime(new Date("2024-06-01T12:00:00Z")));
+    afterEach(() => jest.setSystemTime());
+    test("UTC timezone", () => {
+        const now = Timestamp.fromNumber(Date.now()); // 2024-06-01T12:00:00Z
+        const result = DateCalculator.getStartOfDayTsInTz({ now, timeZoneOffset: Duration.Ms(0) });
+        expect(result).toEqual(Timestamp.fromNumber(new Date("2024-06-01T00:00:00Z").getTime()));
+    });
+    test("UTC+2 timezone", () => {
+        const now = Timestamp.fromNumber(Date.now()); // 2024-06-01T12:00:00Z
+        const result = DateCalculator.getStartOfDayTsInTz({ now, timeZoneOffset: Duration.Hours(2) });
+        // Local day = 2024-06-01 (because 12:00Z is 14:00 local).
+        // Local midnight (00:00 +02:00) corresponds to 2024-06-01T02:00:00Z.
+        expect(result).toEqual(Timestamp.fromNumber(new Date("2024-06-01T02:00:00Z").getTime()));
+    });
+    test("UTC-5 timezone", () => {
+        const now = Timestamp.fromNumber(Date.now()); // 2024-06-01T12:00:00Z
+        const result = DateCalculator.getStartOfDayTsInTz({ now, timeZoneOffset: Duration.Hours(-5) });
+        // Local day = 2024-06-01 (because 12:00Z is 07:00 local).
+        // Local midnight (00:00 -05:00) corresponds to 2024-05-31T19:00:00Z.
+        expect(result).toEqual(Timestamp.fromNumber(new Date("2024-05-31T19:00:00Z").getTime()));
+    });
+    test("UTC+2 timezone - between days", () => {
+        const now = Timestamp.fromNumber(new Date("2024-06-01T01:00:00Z").getTime());
+        const result = DateCalculator.getStartOfDayTsInTz({ now, timeZoneOffset: Duration.Hours(2) });
+        expect(result).toEqual(Timestamp.fromNumber(new Date("2024-05-31T02:00:00Z").getTime()));
+    });
+});

package/dist/tests/date-formatter.service.test.d.ts

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

package/dist/tests/date-formatter.service.test.js

@@ -0,0 +1,22 @@
+import { afterEach, beforeEach, describe, expect, jest, test } from "bun:test";
+import { DateFormatters } from "../src/date-formatter.service";
+import * as mocks from "./mocks";
+const date = new Date(mocks.TIME_ZERO.ms);
+describe("DateFormatters", () => {
+    test("datetime", () => {
+        expect(DateFormatters.datetime(date)).toEqual("2023/11/14 22:13");
+    });
+    test("date", () => {
+        expect(DateFormatters.date(date)).toEqual("2023/11/14");
+    });
+    test("monthDay", () => {
+        expect(DateFormatters.monthDay(date)).toEqual("11/14");
+    });
+    describe("relative", () => {
+        beforeEach(() => jest.setSystemTime(new Date("2024-06-01T15:35:00Z")));
+        afterEach(() => jest.setSystemTime());
+        test("happy path", () => {
+            expect(DateFormatters.relative(date)).toEqual("7 months ago");
+        });
+    });
+});

package/dist/tests/date-range.vo.test.d.ts

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

package/dist/tests/date-range.vo.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { DateRange } from "../src/date-range.vo";
+import { Duration } from "../src/duration.service";
+import * as mocks from "./mocks";
+const duration = Duration.Seconds(1);
+const START = mocks.TIME_ZERO;
+const END = START.add(duration);
+const range = new DateRange(START, END);
+describe("DateRange", () => {
+    test("constructor - start after end", () => {
+        expect(() => new DateRange(END, START)).toThrow("date.range.invalid");
+    });
+    test("constructor - start equals end", () => {
+        expect(() => new DateRange(START, START)).toThrow("date.range.invalid");
+    });
+    test("getStart", () => {
+        expect(range.getStart()).toEqual(START);
+    });
+    test("getEnd", () => {
+        expect(range.getEnd()).toEqual(END);
+    });
+    test("get", () => {
+        expect(range.get()).toEqual([START, END]);
+    });
+    test("getDuration", () => {
+        expect(range.getDuration()).toEqual(duration);
+    });
+    test("contains - true", () => {
+        expect(range.contains(START)).toEqual(true);
+        expect(range.contains(START.add(Duration.Ms(500)))).toEqual(true);
+        expect(range.contains(END)).toEqual(true);
+    });
+    test("contains - false", () => {
+        expect(range.contains(START.subtract(Duration.Ms(1)))).toEqual(false);
+        expect(range.contains(END.add(Duration.Ms(1)))).toEqual(false);
+    });
+    test("equals - true", () => {
+        expect(range.equals(range)).toEqual(true);
+    });
+    test("equals - false", () => {
+        expect(range.equals(new DateRange(START, END.add(Duration.Seconds(1))))).toEqual(false);
+    });
+    test("toString", () => {
+        expect(range.toString()).toEqual(`${START.toString()} - ${END.toString()}`);
+    });
+    test("toJSON", () => {
+        expect(range.toJSON()).toEqual({ start: START.ms, end: END.ms });
+    });
+});

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

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

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

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { DayIsoId } from "../src/day-iso-id.vo";
+describe("DayIsoId", () => {
+    test("happy path", () => {
+        expect(v.safeParse(DayIsoId, "2025-07-15").success).toEqual(true);
+        expect(v.safeParse(DayIsoId, "2024-02-29").success).toEqual(true);
+    });
+    test("rejects prefix", () => {
+        expect(() => v.parse(DayIsoId, "prefix2025-07-15")).toThrow("day.iso.id.bad.chars");
+    });
+    test("rejects suffix", () => {
+        expect(() => v.parse(DayIsoId, "2025-07-15suffix")).toThrow("day.iso.id.bad.chars");
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(DayIsoId, null)).toThrow("day.iso.id.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(DayIsoId, 2024)).toThrow("day.iso.id.type");
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(DayIsoId, "")).toThrow("day.iso.id.bad.chars");
+    });
+    test("rejects strings that don't match YYYY-MM-DD", () => {
+        const invalid = ["2025-7-15", "25-07-15", "2025/07/15", "20250715"];
+        for (const value of invalid) {
+            expect(() => v.parse(DayIsoId, value)).toThrow("day.iso.id.bad.chars");
+        }
+    });
+    test("rejects impossible calendar dates", () => {
+        const invalid = ["2025-02-30", "2025-13-01", "2025-00-10", "2025-04-31", "2025-02-29"];
+        for (const value of invalid) {
+            expect(() => v.parse(DayIsoId, value)).toThrow("day.iso.id.invalid.date");
+        }
+    });
+});

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

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

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

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Day } from "../src/day.vo";
+import { DayIsoId } from "../src/day-iso-id.vo";
+import { Duration } from "../src/duration.service";
+import { Integer } from "../src/integer.vo";
+import { Timestamp } from "../src/timestamp.vo";
+import * as mocks from "./mocks";
+const start = Timestamp.fromNumber(Date.UTC(mocks.TIME_ZERO_DATE.getUTCFullYear(), mocks.TIME_ZERO_DATE.getUTCMonth(), mocks.TIME_ZERO_DATE.getUTCDate()));
+const end = start.add(Duration.Days(1)).subtract(mocks.epsilon);
+const dayIsoId = v.parse(DayIsoId, mocks.TIME_ZERO_DATE_LIKE);
+describe("Day", () => {
+    test("happy path", () => {
+        const day = Day.fromTimestamp(mocks.TIME_ZERO);
+        expect(day.getStart()).toEqual(start);
+        expect(day.getEnd()).toEqual(end);
+        expect(day.toIsoId()).toEqual(dayIsoId);
+        expect(day.contains(mocks.TIME_ZERO)).toEqual(true);
+    });
+    test("fromTimestamp", () => {
+        expect(Day.fromTimestamp(mocks.TIME_ZERO).toIsoId()).toEqual(dayIsoId);
+    });
+    test("fromTimestampValue", () => {
+        expect(Day.fromTimestampValue(mocks.TIME_ZERO.ms).toIsoId()).toEqual(dayIsoId);
+    });
+    test("fromNow", () => {
+        expect(Day.fromNow(mocks.TIME_ZERO).toIsoId()).toEqual(dayIsoId);
+    });
+    test("fromIsoId", () => {
+        expect(Day.fromIsoId(dayIsoId).toIsoId()).toEqual(dayIsoId);
+    });
+    test("leap-day", () => {
+        const timestamp = Timestamp.fromDateLike("2024-02-29");
+        const day = Day.fromTimestamp(timestamp);
+        expect(day.toIsoId()).toEqual(v.parse(DayIsoId, "2024-02-29"));
+        expect(day.contains(timestamp)).toEqual(true);
+    });
+    test("equals", () => {
+        const day = Day.fromTimestamp(mocks.TIME_ZERO);
+        const now = Day.fromNow(Timestamp.fromNumber(Date.now()));
+        expect(day.equals(now)).toEqual(false);
+        expect(day.equals(day)).toEqual(true);
+    });
+    test("next", () => {
+        expect(Day.fromTimestamp(mocks.TIME_ZERO).next().toIsoId()).toEqual(v.parse(DayIsoId, "2023-11-15"));
+    });
+    test("previous", () => {
+        expect(Day.fromTimestamp(mocks.TIME_ZERO).previous().toIsoId()).toEqual(v.parse(DayIsoId, "2023-11-13"));
+    });
+    test("shift", () => {
+        expect(Day.fromTimestamp(mocks.TIME_ZERO).shift(v.parse(Integer, 2)).toIsoId()).toEqual(v.parse(DayIsoId, "2023-11-16"));
+        expect(Day.fromTimestamp(mocks.TIME_ZERO).shift(v.parse(Integer, -2)).toIsoId()).toEqual(v.parse(DayIsoId, "2023-11-12"));
+    });
+    test("round-trips", () => {
+        expect(Day.fromIsoId(dayIsoId).toIsoId()).toEqual(dayIsoId);
+    });
+    test("contains", () => {
+        const day = Day.fromTimestamp(mocks.TIME_ZERO);
+        expect(day.contains(day.getStart().subtract(mocks.epsilon))).toEqual(false);
+        expect(day.contains(day.getEnd().add(mocks.epsilon))).toEqual(false);
+    });
+    test("toString", () => {
+        expect(Day.fromIsoId(dayIsoId).toString()).toEqual(mocks.TIME_ZERO_DATE_LIKE);
+    });
+    test("toJSON", () => {
+        expect(Day.fromIsoId(dayIsoId).toJSON()).toEqual({ start: 1699920000000, end: 1700006399999 });
+    });
+});

package/dist/tests/directory-path-absolute.vo.test.d.ts

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

package/dist/tests/directory-path-absolute.vo.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { DirectoryPathAbsoluteSchema } from "../src/directory-path-absolute.vo";
+describe("DirectoryPathAbsoluteSchema", () => {
+    test("happy path", () => {
+        const valid = ["/tmp/app/users", "/", "/ok.png"];
+        for (const value of valid) {
+            expect(v.safeParse(DirectoryPathAbsoluteSchema, value)).toMatchObject({ success: true, output: value });
+        }
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, null)).toThrow("directory.path.absolue.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, 42)).toThrow("directory.path.absolue.type");
+    });
+    test("rejects too long", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, `/${"a".repeat(512)}`)).toThrow("directory.path.absolue.too.long");
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, "")).toThrow("directory.path.absolue.empty");
+    });
+    test("rejects empty segment", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, "/tmp//app///users")).toThrow("directory.path.absolue.bad.segments");
+    });
+    test("rejects trailing slash", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, "/tmp/app/")).toThrow("directory.path.absolue.trailing.slash");
+    });
+    test("rejects relative path", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, "tmp/app")).toThrow("directory.path.absolue.leading.slash");
+    });
+    test("rejects backslash", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, "/tmp\\app")).toThrow("directory.path.absolue.bad.segments");
+    });
+    test("rejects control chars", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, "/tmp\napp")).toThrow("directory.path.absolue.bad.segments");
+    });
+    test("rejects dot segment", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, "/tmp/../etc")).toThrow("directory.path.absolue.bad.segments");
+    });
+    test("rejects double-dot segment", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, "/tmp/./users")).toThrow("directory.path.absolue.bad.segments");
+    });
+    test("rejects invalid segment", () => {
+        expect(() => v.parse(DirectoryPathAbsoluteSchema, "/tmp/app/invalid segment")).toThrow("directory.path.absolue.bad.segments");
+    });
+});

package/dist/tests/directory-path-relative.vo.test.d.ts

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

package/dist/tests/directory-path-relative.vo.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { DirectoryPathRelativeSchema } from "../src/directory-path-relative.vo";
+describe("DirectoryPathRelativeSchema", () => {
+    test("happy path", () => {
+        const valid = ["users/avatars", "users"];
+        for (const value of valid) {
+            expect(v.safeParse(DirectoryPathRelativeSchema, value)).toMatchObject({ success: true, output: value });
+        }
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, null)).toThrow("directory.path.relative.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, 123)).toThrow("directory.path.relative.type");
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, "")).toThrow("directory.path.relative.empty");
+    });
+    test("rejects too long", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, "a".repeat(513))).toThrow("directory.path.absolue.too.long");
+    });
+    test("rejects empty segment", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, "tmp//app///users")).toThrow("directory.path.relative.bad.segments");
+    });
+    test("rejects leading slash", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, "/users/avatars")).toThrow("directory.path.relative.leading.slash");
+    });
+    test("rejects trailing slash", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, "tmp/app/")).toThrow("directory.path.absolue.trailing.slash");
+    });
+    test("rejects backslash", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, "users\\avatars")).toThrow("directory.path.relative.bad.segments");
+    });
+    test("rejects control chars", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, "users\navatars")).toThrow("directory.path.relative.bad.segments");
+    });
+    test("rejects dot segment", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, "users/./avatars")).toThrow("directory.path.relative.bad.segments");
+    });
+    test("rejects double dot segment", () => {
+        expect(() => v.parse(DirectoryPathRelativeSchema, "users/../avatars")).toThrow("directory.path.relative.bad.segments");
+    });
+});

package/dist/tests/distance-value.vo.test.d.ts

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

package/dist/tests/distance-value.vo.test.js

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

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

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