@bgord/tools 1.4.0 → 1.4.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,74 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Distance } from "../src/distance.vo";
-import { DistanceValue } from "../src/distance-value.vo";
-import { RoundingDecimalStrategy } from "../src/rounding-decimal.strategy";
-describe("Distance", () => {
-    test("happy path", () => {
-        expect(Distance.fromMeters(0).get()).toEqual(v.parse(DistanceValue, 0));
-        expect(Distance.fromMeters(100).get()).toEqual(v.parse(DistanceValue, 100));
-    });
-    test("throws on invalid input", () => {
-        expect(() => Distance.fromMeters(100.5)).toThrow("distance.value.type");
-    });
-    test("fromMetersSafe", () => {
-        expect(Distance.fromMetersSafe(v.parse(DistanceValue, 1)).get()).toEqual(v.parse(DistanceValue, 1));
-    });
-    test("fromKilometers", () => {
-        expect(Distance.fromKilometers(1).get()).toEqual(v.parse(DistanceValue, 1000));
-        expect(Distance.fromKilometers(1.5).get()).toEqual(v.parse(DistanceValue, 1500));
-        expect(Distance.fromKilometers(0.123456789).get()).toEqual(v.parse(DistanceValue, 123));
-    });
-    test("fromKilometers - throws on invalid input", () => {
-        expect(() => Distance.fromKilometers(0.123456789, new RoundingDecimalStrategy(5))).toThrow("distance.value.type");
-    });
-    test("fromMiles", () => {
-        expect(Distance.fromMiles(1).get()).toEqual(v.parse(DistanceValue, 1609));
-        expect(Distance.fromMiles(1.5).get()).toEqual(v.parse(DistanceValue, 2414));
-        expect(Distance.fromMiles(0.123456789).get()).toEqual(v.parse(DistanceValue, 199));
-    });
-    test("fromMiles - throws on invalid input", () => {
-        expect(() => Distance.fromMiles(1, new RoundingDecimalStrategy(1))).toThrow("distance.value.type");
-    });
-    test("add", () => {
-        expect(Distance.fromMeters(100).add(Distance.fromMeters(0)).get()).toEqual(v.parse(DistanceValue, 100));
-        expect(Distance.fromMeters(15).add(Distance.fromMeters(10)).get()).toEqual(v.parse(DistanceValue, 25));
-    });
-    test("subtract - result more than zero", () => {
-        expect(Distance.fromMeters(100).subtract(Distance.fromMeters(20)).get()).toEqual(v.parse(DistanceValue, 80));
-    });
-    test("subtract - result zero", () => {
-        expect(Distance.fromMeters(100).subtract(Distance.fromMeters(100)).isZero()).toEqual(true);
-    });
-    test("subtract - result less than zero", () => {
-        expect(() => Distance.fromMeters(100).subtract(Distance.fromMeters(120)).get()).toThrow("distance.subtract.result.less.than.zero");
-    });
-    test("equals", () => {
-        const oneHundred = Distance.fromMeters(100);
-        const twoHundred = Distance.fromMeters(200);
-        expect(oneHundred.equals(oneHundred)).toEqual(true);
-        expect(oneHundred.equals(twoHundred)).toEqual(false);
-    });
-    test("isLongerThan", () => {
-        const oneHundred = Distance.fromMeters(100);
-        const twoHundred = Distance.fromMeters(200);
-        expect(oneHundred.isLongerThan(oneHundred)).toEqual(false);
-        expect(twoHundred.isLongerThan(oneHundred)).toEqual(true);
-    });
-    test("isShorterThan", () => {
-        const oneHundred = Distance.fromMeters(100);
-        const twoHundred = Distance.fromMeters(200);
-        expect(oneHundred.isShorterThan(oneHundred)).toEqual(false);
-        expect(oneHundred.isShorterThan(twoHundred)).toEqual(true);
-    });
-    test("isZero", () => {
-        expect(Distance.fromMeters(0).isZero()).toEqual(true);
-        expect(Distance.fromMeters(1).isZero()).toEqual(false);
-    });
-    test("toString", () => {
-        expect(Distance.fromMeters(5).toString()).toEqual("5");
-    });
-    test("toJSON", () => {
-        expect(Distance.fromMeters(5).toJSON()).toEqual(5);
-    });
-});

package/dist/tests/division-factor.vo.test.d.ts

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

package/dist/tests/division-factor.vo.test.js

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

package/dist/tests/dll.service.test.d.ts

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