@bgord/tools 1.4.0 → 1.4.1

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/tests/repeat.test.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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