@bgord/tools 1.3.24 → 1.4.0

package/dist/tests/rate-limiter.service.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+import { Duration } from "../src/duration.service";
+import { RateLimiter } from "../src/rate-limiter.service";
+import { Timestamp } from "../src/timestamp.vo";
+import * as mocks from "./mocks";
+const duration = Duration.Ms(1000);
+const currentTimestampMs = Timestamp.fromNumber(0);
+describe("RateLimiter", () => {
+    test("first invocation", () => {
+        expect(new RateLimiter(duration).verify(currentTimestampMs).allowed).toEqual(true);
+    });
+    test("rejects invocations within the rate limit", () => {
+        const rateLimiter = new RateLimiter(duration);
+        const first = rateLimiter.verify(currentTimestampMs);
+        expect(first.allowed).toEqual(true);
+        const second = rateLimiter.verify(currentTimestampMs.add(duration).subtract(mocks.epsilon));
+        expect(second.allowed).toEqual(false);
+        // @ts-expect-error
+        expect(second.remaining).toEqual(mocks.epsilon);
+    });
+    test("allows invocations at the limit boundary", () => {
+        const rateLimiter = new RateLimiter(duration);
+        const first = rateLimiter.verify(currentTimestampMs);
+        expect(first.allowed).toEqual(true);
+        const second = rateLimiter.verify(currentTimestampMs.add(duration));
+        expect(second.allowed).toEqual(true);
+    });
+    test("rejects invocations around the boundaries", () => {
+        const rateLimiter = new RateLimiter(duration);
+        const first = rateLimiter.verify(currentTimestampMs);
+        expect(first.allowed).toEqual(true);
+        const second = rateLimiter.verify(currentTimestampMs.add(duration));
+        expect(second.allowed).toEqual(true);
+        const third = rateLimiter.verify(currentTimestampMs.add(duration).add(mocks.epsilon));
+        expect(third.allowed).toEqual(false);
+        const fourth = rateLimiter.verify(currentTimestampMs.add(duration).add(Duration.Ms(2)));
+        expect(fourth.allowed).toEqual(false);
+    });
+});

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

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

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

@@ -0,0 +1,22 @@
+import { afterEach, beforeEach, describe, expect, jest, test } from "bun:test";
+import { RelativeDate } from "../src/relative-date.vo";
+import { Timestamp } from "../src/timestamp.vo";
+describe("RelativeDate", () => {
+    const timestamp = Timestamp.fromNumber(new Date("2024-06-01T12:00:00Z").getTime());
+    beforeEach(() => jest.setSystemTime(new Date("2024-06-01T12:05:00Z")));
+    afterEach(() => jest.setSystemTime());
+    describe("truthy", () => {
+        test("formats a timestamp into relative format", () => {
+            expect(RelativeDate.truthy(timestamp)).toEqual({ raw: timestamp.ms, relative: "5 minutes ago" });
+        });
+    });
+    describe("falsy", () => {
+        test("returns null for falsy value", () => {
+            expect(RelativeDate.falsy(undefined)).toEqual(null);
+            expect(RelativeDate.falsy(null)).toEqual(null);
+        });
+        test("formats a valid timestamp", () => {
+            expect(RelativeDate.falsy(timestamp)).toEqual({ raw: timestamp.ms, relative: "5 minutes ago" });
+        });
+    });
+});

package/dist/tests/reordering-item-position-value.vo.test.d.ts

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

package/dist/tests/reordering-item-position-value.vo.test.js

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

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

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

package/dist/tests/reordering.service.test.js

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "bun:test";
+import { ReorderingCalculator, ReorderingTransfer } from "../src/reordering.service";
+describe("Reordering", () => {
+    test("add", () => {
+        const calculator = new ReorderingCalculator();
+        for (const id of ["a", "b", "c"])
+            calculator.add(id);
+        calculator.transfer(new ReorderingTransfer({ id: "c", to: 1 }));
+        expect(calculator.read().ids).toEqual(["a", "c", "b"]);
+    });
+    test("delete", () => {
+        const calculator = ReorderingCalculator.fromArray(["a", "b", "c"]);
+        calculator.delete("b");
+        expect(calculator.read().ids).toEqual(["a", "c"]);
+    });
+    test("delete - throws when item is not found", () => {
+        expect(() => ReorderingCalculator.fromArray(["a", "b", "c"]).delete("d")).toThrow("reordering.cannot.find.item");
+    });
+    test("transfer - noop", () => {
+        const calculator = ReorderingCalculator.fromArray(["aaa", "bbb", "ccc"]);
+        calculator.transfer(new ReorderingTransfer({ id: "ccc", to: 2 }));
+        expect(calculator.read().ids).toEqual(["aaa", "bbb", "ccc"]);
+    });
+    test("transfer - from end to middle", () => {
+        const calculator = ReorderingCalculator.fromArray(["aaa", "bbb", "ccc"]);
+        calculator.transfer(new ReorderingTransfer({ id: "ccc", to: 1 }));
+        expect(calculator.read().ids).toEqual(["aaa", "ccc", "bbb"]);
+    });
+    test("transfer - from end to start", () => {
+        const calculator = ReorderingCalculator.fromArray(["aaa", "bbb", "ccc"]);
+        calculator.transfer(new ReorderingTransfer({ id: "ccc", to: 0 }));
+        expect(calculator.read().ids).toEqual(["ccc", "aaa", "bbb"]);
+    });
+    test("transfer - from middle to start", () => {
+        const calculator = ReorderingCalculator.fromArray(["aaa", "bbb", "ccc"]);
+        calculator.transfer(new ReorderingTransfer({ id: "bbb", to: 0 }));
+        expect(calculator.read().ids).toEqual(["bbb", "aaa", "ccc"]);
+    });
+    test("transfer - from middle to end", () => {
+        const calculator = ReorderingCalculator.fromArray(["aaa", "bbb", "ccc"]);
+        calculator.transfer(new ReorderingTransfer({ id: "bbb", to: 2 }));
+        expect(calculator.read().ids).toEqual(["aaa", "ccc", "bbb"]);
+    });
+    test("transfer - from start to middle", () => {
+        const calculator = ReorderingCalculator.fromArray(["aaa", "bbb", "ccc"]);
+        calculator.transfer(new ReorderingTransfer({ id: "aaa", to: 1 }));
+        expect(calculator.read().ids).toEqual(["bbb", "aaa", "ccc"]);
+    });
+    test("transfer - from start to end", () => {
+        const calculator = ReorderingCalculator.fromArray(["aaa", "bbb", "ccc"]);
+        calculator.transfer(new ReorderingTransfer({ id: "aaa", to: 2 }));
+        expect(calculator.read().ids).toEqual(["bbb", "ccc", "aaa"]);
+    });
+    test("transfer - to back and to start", () => {
+        const toEnd = new ReorderingTransfer({ id: "aaa", to: 2 });
+        const toStart = new ReorderingTransfer({ id: "aaa", to: 0 });
+        const calculator = ReorderingCalculator.fromArray(["aaa", "bbb", "ccc"]);
+        calculator.transfer(toEnd);
+        expect(calculator.read().ids).toEqual(["bbb", "ccc", "aaa"]);
+        calculator.transfer(toStart);
+        expect(calculator.read().ids).toEqual(["aaa", "bbb", "ccc"]);
+    });
+    test("transfer - error - cannot find current", () => {
+        const calculator = ReorderingCalculator.fromArray(["aaa", "bbb", "ccc"]);
+        expect(() => calculator.transfer(new ReorderingTransfer({ id: "ddd", to: 1 }))).toThrow("reordering.cannot.find.current");
+    });
+    test("transfer - error - cannot find target", () => {
+        const calculator = ReorderingCalculator.fromArray(["aaa", "bbb", "ccc"]);
+        expect(() => calculator.transfer(new ReorderingTransfer({ id: "ccc", to: 4 }))).toThrow("reordering.cannot.find.target");
+    });
+    test("transfer - 10 elements", () => {
+        const calculator = ReorderingCalculator.fromArray(["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]);
+        calculator.transfer(new ReorderingTransfer({ id: "h", to: 1 }));
+        expect(calculator.read().ids).toEqual(["a", "h", "b", "c", "d", "e", "f", "g", "i", "j"]);
+    });
+});

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

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

package/dist/tests/repeat.test.js

@@ -0,0 +1,8 @@
+import { describe, expect, test } from "bun:test";
+import { repeat } from "../src/repeat";
+describe("repeat", () => {
+    test("happy path", () => {
+        const value = "abc";
+        expect(repeat(value, 3)).toEqual([value, value, value]);
+    });
+});

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

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

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

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

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

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

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

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { ETag, WeakETag } from "../src/etags.vo";
+import { Revision } from "../src/revision.vo";
+import { RevisionValue } from "../src/revision-value.vo";
+describe("Revision", () => {
+    test("happy path", () => {
+        const value = v.parse(RevisionValue, 0);
+        const revision = new Revision(value);
+        expect(revision.value).toEqual(value);
+    });
+    test("throws for invalid input", () => {
+        expect(() => new Revision("invalid")).toThrow("revision.value.type");
+    });
+    test("fromETag", () => {
+        const etag = ETag.fromHeader("123");
+        const revision = Revision.fromETag(etag);
+        expect(revision.value).toEqual(v.parse(RevisionValue, 123));
+    });
+    test("fromETag - throws for null", () => {
+        expect(() => Revision.fromETag(null)).toThrow("revision.missing");
+    });
+    test("fromWeakETag", () => {
+        const weak = WeakETag.fromHeader("W/123");
+        const revision = Revision.fromWeakETag(weak);
+        expect(revision.value).toEqual(v.parse(RevisionValue, 123));
+    });
+    test("fromWeakETag - throws for null", () => {
+        expect(() => Revision.fromWeakETag(null)).toThrow("revision.missing");
+    });
+    test("equals", () => {
+        expect(new Revision(123).equals(new Revision(123).value)).toEqual(true);
+        expect(new Revision(123).equals(new Revision(456).value)).toEqual(false);
+    });
+    test("validate success", () => {
+        expect(() => new Revision(123).validate(new Revision(123).value)).not.toThrow();
+    });
+    test("validate - throws mismatch", () => {
+        expect(() => new Revision(123).validate(new Revision(456).value)).toThrow("revision.mismatch");
+    });
+    test("next - returns a new revision with incremented value", () => {
+        const revision = new Revision(123);
+        const incremented = revision.next();
+        expect(incremented.value).toEqual(v.parse(RevisionValue, revision.value + 1));
+    });
+    test("toString", () => {
+        expect(new Revision(1).toString()).toEqual("1");
+    });
+    test("toJSON", () => {
+        expect(new Revision(1).toJSON()).toEqual(1);
+    });
+});

package/dist/tests/rounding-decimal.strategy.test.d.ts

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

package/dist/tests/rounding-decimal.strategy.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "bun:test";
+import { RoundingDecimalStrategy } from "../src/rounding-decimal.strategy";
+describe("RoundingDecimalStrategy", () => {
+    test("happy path", () => {
+        const rounding = new RoundingDecimalStrategy(2);
+        expect(rounding.round(5.678)).toEqual(5.68);
+        expect(rounding.round(3.245)).toEqual(3.25);
+    });
+    test("invalid", () => {
+        // @ts-expect-error
+        expect(() => new RoundingDecimalStrategy("")).toThrow("rounding.decimal.type");
+        expect(() => new RoundingDecimalStrategy(-1)).toThrow("rounding.decimal.invalid");
+        expect(() => new RoundingDecimalStrategy(0)).toThrow("rounding.decimal.invalid");
+        expect(() => new RoundingDecimalStrategy(1.5)).toThrow("rounding.decimal.invalid");
+        expect(() => new RoundingDecimalStrategy(101)).toThrow("rounding.decimal.invalid");
+    });
+});

package/dist/tests/rounding-down.strategy.test.d.ts

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

package/dist/tests/rounding-down.strategy.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, test } from "bun:test";
+import { RoundingDownStrategy } from "../src/rounding-down.strategy";
+describe("RoundingDownStrategy", () => {
+    test("happy path", () => {
+        const rounding = new RoundingDownStrategy();
+        expect(rounding.round(5.6)).toEqual(5);
+        expect(rounding.round(3.2)).toEqual(3);
+    });
+});

package/dist/tests/rounding-to-nearest.strategy.test.d.ts

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

package/dist/tests/rounding-to-nearest.strategy.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, test } from "bun:test";
+import { RoundingToNearestStrategy } from "../src/rounding-to-nearest.strategy";
+describe("RoundingToNearestStrategy", () => {
+    test("happy path", () => {
+        const rounding = new RoundingToNearestStrategy();
+        expect(rounding.round(5.6)).toEqual(6);
+        expect(rounding.round(3.2)).toEqual(3);
+    });
+});

package/dist/tests/rounding-up.strategy.test.d.ts

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

package/dist/tests/rounding-up.strategy.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, test } from "bun:test";
+import { RoundingUpStrategy } from "../src/rounding-up.strategy";
+describe("RoundingUpStrategy", () => {
+    test("happy path", () => {
+        const rounding = new RoundingUpStrategy();
+        expect(rounding.round(5.6)).toEqual(6);
+        expect(rounding.round(3.2)).toEqual(4);
+    });
+});

package/dist/tests/size-bytes.vo.test.d.ts

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

package/dist/tests/size-bytes.vo.test.js

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

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

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

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

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Size } from "../src/size.vo";
+import { SizeBytes } from "../src/size-bytes.vo";
+describe("Size", () => {
+    test("happy path", () => {
+        expect(Size.fromBytes(500).toString()).toEqual("500 b");
+        expect(Size.fromKb(500).toString()).toEqual("500 kB");
+        expect(Size.fromMB(2).toString()).toEqual("2 MB");
+        expect(Size.fromGB(2).toString()).toEqual("2 GB");
+    });
+    test("rejects invalid values", () => {
+        expect(() => Size.fromKb(1.555)).toThrow("size.bytes.invalid");
+    });
+    test("convert - bytes to bytes", () => {
+        expect(Size.fromBytes(4096).toBytes()).toEqual(v.parse(SizeBytes, 4096));
+    });
+    test("convert - kB to bytes", () => {
+        expect(Size.fromKb(512).toBytes()).toEqual(v.parse(SizeBytes, 524288));
+    });
+    test("convert - MB to bytes", () => {
+        expect(Size.fromMB(1.5).toBytes()).toEqual(v.parse(SizeBytes, 1572864));
+    });
+    test("convert - GB to bytes", () => {
+        expect(Size.fromGB(1.5).toBytes()).toEqual(v.parse(SizeBytes, 1610612736));
+    });
+    test("tokB", () => {
+        expect(Size.fromBytes(1023).tokB()).toEqual(1);
+        expect(Size.fromBytes(1024).tokB()).toEqual(1);
+        expect(Size.fromBytes(1025).tokB()).toEqual(2);
+    });
+    test("toMB", () => {
+        expect(Size.fromKb(1023).toMB()).toEqual(1);
+        expect(Size.fromKb(1024).toMB()).toEqual(1);
+        expect(Size.fromKb(1025).toMB()).toEqual(2);
+    });
+    test("toGB", () => {
+        expect(Size.fromMB(1023).toGB()).toEqual(1);
+        expect(Size.fromMB(1024).toGB()).toEqual(1);
+        expect(Size.fromMB(1025).toGB()).toEqual(2);
+    });
+    test("equals", () => {
+        expect(Size.fromGB(1).equals(Size.fromGB(1))).toEqual(true);
+        expect(Size.fromMB(1).equals(Size.fromMB(2))).toEqual(false);
+    });
+    test("isSmallerThan", () => {
+        expect(Size.fromMB(1).isSmallerThan(Size.fromGB(1))).toEqual(true);
+        expect(Size.fromMB(1).isSmallerThan(Size.fromMB(1))).toEqual(false);
+        expect(Size.fromGB(2).isSmallerThan(Size.fromGB(1))).toEqual(false);
+    });
+    test("isGreaterThan", () => {
+        expect(Size.fromGB(1).isGreaterThan(Size.fromMB(1))).toEqual(true);
+        expect(Size.fromMB(1).isGreaterThan(Size.fromMB(1))).toEqual(false);
+        expect(Size.fromMB(1).isGreaterThan(Size.fromMB(2))).toEqual(false);
+    });
+    test("format - bytes source", () => {
+        const value = Size.fromBytes(1024);
+        expect(value.format(Size.unit.b)).toEqual("1024 b");
+        expect(value.format(Size.unit.kB)).toEqual("1 kB");
+        expect(value.format(Size.unit.MB)).toEqual("0 MB");
+        expect(value.format(Size.unit.GB)).toEqual("0 GB");
+    });
+    test("format - kB source", () => {
+        const value = Size.fromKb(512);
+        expect(value.format(Size.unit.b)).toEqual("524288 b");
+        expect(value.format(Size.unit.kB)).toEqual("512 kB");
+        expect(value.format(Size.unit.MB)).toEqual("0.5 MB");
+        expect(value.format(Size.unit.GB)).toEqual("0 GB");
+    });
+    test("format - MB source", () => {
+        const value = Size.fromMB(128);
+        expect(value.format(Size.unit.b)).toEqual("134217728 b");
+        expect(value.format(Size.unit.kB)).toEqual("131072 kB");
+        expect(value.format(Size.unit.MB)).toEqual("128 MB");
+        expect(value.format(Size.unit.GB)).toEqual("0.13 GB");
+    });
+    test("format - GB source", () => {
+        const value = Size.fromGB(2);
+        expect(value.format(Size.unit.b)).toEqual("2147483648 b");
+        expect(value.format(Size.unit.kB)).toEqual("2097152 kB");
+        expect(value.format(Size.unit.MB)).toEqual("2048 MB");
+        expect(value.format(Size.unit.GB)).toEqual("2 GB");
+    });
+    test("toBytes", () => {
+        expect(Size.toBytes({ unit: Size.unit.GB, value: 1 })).toEqual(v.parse(SizeBytes, 1073741824));
+    });
+    test("toString", () => {
+        expect(Size.fromGB(1).toString()).toEqual("1 GB");
+    });
+    test("toJSON", () => {
+        expect(Size.fromGB(1).toJSON()).toEqual({ bytes: 1073741824 });
+    });
+});

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

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

package/dist/tests/slug.service.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test";
+import { Slug } from "../src/slug.service";
+describe("Slug", () => {
+    test("happy path", () => {
+        expect(Slug.generate("input")).toEqual("input");
+        expect(Slug.generate("file123")).toEqual("file123");
+    });
+    test("spaces and punctuation", () => {
+        expect(Slug.generate("happy path")).toEqual("happy-path");
+        expect(Slug.generate("hello, world!")).toEqual("hello-world");
+        expect(Slug.generate("don't stop")).toEqual("don-t-stop");
+        expect(Slug.generate("price: $100")).toEqual("price-100");
+        expect(Slug.generate("Product: Foo Bar™ (v2.0)")).toEqual("product-foo-bar-v2-0");
+        expect(Slug.generate("Hello... World???")).toEqual("hello-world");
+        expect(Slug.generate("__private__field__")).toEqual("private-field");
+    });
+    test("collapses multiple consecutive separators", () => {
+        expect(Slug.generate("hello!!world")).toEqual("hello-world");
+        expect(Slug.generate("a  b   c")).toEqual("a-b-c");
+        expect(Slug.generate("x---y----z")).toEqual("x-y-z");
+    });
+    test("trims leading and trailing separators", () => {
+        expect(Slug.generate("-input")).toEqual("input");
+        expect(Slug.generate("input-")).toEqual("input");
+        expect(Slug.generate("--input--")).toEqual("input");
+        expect(Slug.generate("!!!input!!!")).toEqual("input");
+    });
+    test("various letters", () => {
+        expect(Slug.generate("bądź sobą")).toEqual("bądź-sobą");
+        expect(Slug.generate("你好世界")).toEqual("你好世界");
+        expect(Slug.generate("مرحبا بالعالم")).toEqual("مرحبا-بالعالم");
+        expect(Slug.generate("Αγία Σοφία")).toEqual("αγία-σοφία");
+        expect(Slug.generate("Café au lait")).toEqual("café-au-lait");
+    });
+    test("custom separators", () => {
+        expect(Slug.generate("hello world", "_")).toEqual("hello_world");
+        expect(Slug.generate("a b c", "+")).toEqual("a+b+c");
+    });
+    test("empty cases", () => {
+        expect(Slug.generate("")).toEqual("");
+        expect(Slug.generate("!!!")).toEqual("");
+        expect(Slug.generate("---")).toEqual("");
+        expect(Slug.generate("   ")).toEqual("");
+    });
+});

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

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

package/dist/tests/sum.service.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import { Sum } from "../src/sum.service";
+describe("Sum", () => {
+    describe("naive", () => {
+        expect(Sum.of([1])).toEqual(1);
+        expect(Sum.of([1, 2])).toEqual(3);
+        expect(Sum.of([1, 3, 6])).toEqual(10);
+        expect(Sum.of([0, 0, 0])).toEqual(0);
+        expect(Sum.of([])).toEqual(0);
+        expect(Sum.of([5, -2, -3])).toEqual(0);
+        expect(Sum.of([0.1, 0.2])).toBeCloseTo(0.3, 12);
+    });
+    test("precise", () => {
+        const values = [1e12, ...Array.from({ length: 1000 }, () => 1e-3)];
+        const naive = Sum.of(values);
+        const expected = 1e12 + 1;
+        const precise = Sum.precise(values);
+        expect(precise).toBeCloseTo(expected, 9);
+        expect(naive).toBeCloseTo(expected, 1);
+        expect(Math.abs(precise - expected)).toBeLessThanOrEqual(Math.abs(naive - expected));
+    });
+});

package/dist/tests/thousands-separator.service.test.d.ts

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

package/dist/tests/thousands-separator.service.test.js

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+import { ThousandsSeparator } from "../src/thousands-separator.service";
+describe("ThousandsSeparator", () => {
+    test("default separator", () => {
+        const cases = [
+            [999, "999"],
+            [999.5, "999.5"],
+            [1000, "1 000"],
+            [1000.99, "1 000.99"],
+            [15000, "15 000"],
+            [15000.5, "15 000.5"],
+            [150000, "150 000"],
+            [150000.99, "150 000.99"],
+            [1500000, "1 500 000"],
+            [1500000.99, "1 500 000.99"],
+            [-1000, "-1 000"],
+            [-1500000.5, "-1 500 000.5"],
+        ];
+        for (const [value, expected] of cases) {
+            expect(ThousandsSeparator.format(value)).toEqual(expected);
+        }
+    });
+    test("custom separator", () => {
+        expect(ThousandsSeparator.format(150000.99, "_")).toEqual("150_000.99");
+        expect(ThousandsSeparator.format(-1234567.89, ",")).toEqual("-1,234,567.89");
+    });
+});

package/dist/tests/time-zone-offset-value.test.d.ts

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

package/dist/tests/time-zone-offset-value.test.js

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { TimeZoneOffsetValue } from "../src/time-zone-offset-value.vo";
+describe("TimeZoneOffsetValue", () => {
+    test("happy path", () => {
+        expect(v.safeParse(TimeZoneOffsetValue, "720").success).toEqual(true);
+        expect(v.safeParse(TimeZoneOffsetValue, "-840").success).toEqual(true);
+        expect(v.safeParse(TimeZoneOffsetValue, "0").success).toEqual(true);
+    });
+    test("rejects - fractions", () => {
+        expect(() => v.parse(TimeZoneOffsetValue, "2.5")).toThrow("time.zone.offset.value.type");
+    });
+    test("rejects - min", () => {
+        expect(() => v.parse(TimeZoneOffsetValue, "-841")).toThrow("time.zone.offset.value.min");
+    });
+    test("rejects - max", () => {
+        expect(() => v.parse(TimeZoneOffsetValue, "721")).toThrow("time.zone.offset.value.max");
+    });
+    test("transforms invalid values to 0", () => {
+        // @ts-expect-error Value comparison
+        expect(v.parse(TimeZoneOffsetValue, undefined)).toEqual(0);
+        // @ts-expect-error Value comparison
+        expect(v.parse(TimeZoneOffsetValue, null)).toEqual(0);
+        // @ts-expect-error Value comparison
+        expect(v.parse(TimeZoneOffsetValue, "")).toEqual(0);
+    });
+});

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

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

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

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

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

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