@bgord/tools 1.4.0 → 1.4.1

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

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

@@ -1,381 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { DoublyLinkedList, Node } from "../src/dll.service";
-class Token {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-}
-const token = new Token("test");
-describe("DLL", () => {
-    test("creates an empty List", () => {
-        const dll = new DoublyLinkedList();
-        expect(dll.getSize()).toEqual(0);
-        expect(dll.getHead()).toEqual(null);
-        expect(dll.getTail()).toEqual(null);
-    });
-    test("isEmpty", () => {
-        const dll = new DoublyLinkedList();
-        expect(dll.isEmpty()).toEqual(true);
-        dll.append(new Node(token));
-        expect(dll.isEmpty()).toEqual(false);
-    });
-    test("appends the first Node", () => {
-        const dll = new DoublyLinkedList();
-        const node = new Node(token);
-        dll.append(node);
-        expect(dll.getSize()).toEqual(1);
-        expect(dll.getHead()).toEqual(node);
-        expect(dll.getTail()).toEqual(node);
-    });
-    test("appends two Nodes", () => {
-        const dll = new DoublyLinkedList();
-        const firstNode = new Node(token);
-        const secondNode = new Node(token);
-        dll.append(firstNode);
-        expect(dll.getSize()).toEqual(1);
-        expect(dll.getHead()).toEqual(firstNode);
-        expect(dll.getTail()).toEqual(firstNode);
-        dll.append(secondNode);
-        expect(dll.getSize()).toEqual(2);
-        expect(dll.getHead()).toEqual(firstNode);
-        expect(dll.getTail()).toEqual(secondNode);
-        expect(firstNode.backward(1)).toEqual(null);
-        expect(firstNode.forward(1)).toEqual(secondNode);
-        expect(secondNode.backward(1)).toEqual(firstNode);
-        expect(secondNode.forward(1)).toEqual(null);
-    });
-    test("appends three Nodes", () => {
-        const dll = new DoublyLinkedList();
-        const firstNode = new Node(token);
-        const secondNode = new Node(token);
-        const thirdNode = new Node(token);
-        dll.append(firstNode);
-        expect(dll.getSize()).toEqual(1);
-        expect(dll.getHead()).toEqual(firstNode);
-        expect(dll.getTail()).toEqual(firstNode);
-        dll.append(secondNode);
-        expect(dll.getSize()).toEqual(2);
-        expect(dll.getHead()).toEqual(firstNode);
-        expect(dll.getTail()).toEqual(secondNode);
-        expect(firstNode.backward(1)).toEqual(null);
-        expect(firstNode.forward(1)).toEqual(secondNode);
-        expect(secondNode.backward(1)).toEqual(firstNode);
-        expect(secondNode.forward(1)).toEqual(null);
-        dll.append(thirdNode);
-        expect(dll.getSize()).toEqual(3);
-        expect(dll.getHead()).toEqual(firstNode);
-        expect(dll.getTail()).toEqual(thirdNode);
-        expect(firstNode.backward(1)).toEqual(null);
-        expect(firstNode.forward(1)).toEqual(secondNode);
-        expect(secondNode.backward(1)).toEqual(firstNode);
-        expect(secondNode.forward(1)).toEqual(thirdNode);
-        expect(thirdNode.backward(1)).toEqual(secondNode);
-        expect(thirdNode.forward(1)).toEqual(null);
-    });
-    test("appends four Nodes", () => {
-        const dll = new DoublyLinkedList();
-        const firstNode = new Node(token);
-        const secondNode = new Node(token);
-        const thirdNode = new Node(token);
-        const fourthNode = new Node(token);
-        dll.append(firstNode);
-        expect(dll.getSize()).toEqual(1);
-        expect(dll.getHead()).toEqual(firstNode);
-        expect(dll.getTail()).toEqual(firstNode);
-        dll.append(secondNode);
-        expect(dll.getSize()).toEqual(2);
-        expect(dll.getHead()).toEqual(firstNode);
-        expect(dll.getTail()).toEqual(secondNode);
-        expect(firstNode.backward(1)).toEqual(null);
-        expect(firstNode.forward(1)).toEqual(secondNode);
-        expect(secondNode.backward(1)).toEqual(firstNode);
-        expect(secondNode.forward(1)).toEqual(null);
-        dll.append(thirdNode);
-        expect(dll.getSize()).toEqual(3);
-        expect(dll.getHead()).toEqual(firstNode);
-        expect(dll.getTail()).toEqual(thirdNode);
-        expect(firstNode.backward(1)).toEqual(null);
-        expect(firstNode.forward(1)).toEqual(secondNode);
-        expect(secondNode.backward(1)).toEqual(firstNode);
-        expect(secondNode.forward(1)).toEqual(thirdNode);
-        expect(thirdNode.backward(1)).toEqual(secondNode);
-        expect(thirdNode.forward(1)).toEqual(null);
-        dll.append(fourthNode);
-        expect(dll.getSize()).toEqual(4);
-        expect(dll.getHead()).toEqual(firstNode);
-        expect(dll.getTail()).toEqual(fourthNode);
-        expect(firstNode.backward(1)).toEqual(null);
-        expect(firstNode.forward(1)).toEqual(secondNode);
-        expect(secondNode.backward(1)).toEqual(firstNode);
-        expect(secondNode.forward(1)).toEqual(thirdNode);
-        expect(thirdNode.backward(1)).toEqual(secondNode);
-        expect(thirdNode.forward(1)).toEqual(fourthNode);
-        expect(fourthNode.backward(1)).toEqual(thirdNode);
-        expect(fourthNode.forward(1)).toEqual(null);
-    });
-    test("prepend on empty dll", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        expect(dll.getSize()).toEqual(0);
-        expect(dll.getHead()).toEqual(null);
-        expect(dll.getTail()).toEqual(null);
-        dll.prepend(node1);
-        expect(dll.getSize()).toEqual(1);
-        expect(dll.getHead()).toEqual(node1);
-        expect(dll.getTail()).toEqual(node1);
-    });
-    test("prepend one node", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        dll.append(node1);
-        expect(dll.getSize()).toEqual(1);
-        expect(dll.getHead()).toEqual(node1);
-        expect(dll.getTail()).toEqual(node1);
-        dll.prepend(node2);
-        expect(dll.getSize()).toEqual(2);
-        expect(dll.getHead()).toEqual(node2);
-        expect(dll.getTail()).toEqual(node1);
-    });
-    test("prepend two node", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        const node3 = new Node(token);
-        dll.append(node1);
-        expect(dll.getSize()).toEqual(1);
-        expect(dll.getHead()).toEqual(node1);
-        expect(dll.getTail()).toEqual(node1);
-        dll.prepend(node2);
-        expect(dll.getSize()).toEqual(2);
-        expect(dll.getHead()).toEqual(node2);
-        expect(dll.getTail()).toEqual(node1);
-        dll.prepend(node3);
-        expect(dll.getSize()).toEqual(3);
-        expect(dll.getHead()).toEqual(node3);
-        expect(dll.getHead()?.next).toEqual(node2);
-        expect(dll.getHead()?.next?.next).toEqual(node1);
-        expect(dll.getTail()).toEqual(node1);
-    });
-    test("clear", () => {
-        const dll = new DoublyLinkedList();
-        const node = new Node(token);
-        dll.append(node);
-        expect(dll.getSize()).toEqual(1);
-        expect(dll.getHead()).toEqual(node);
-        expect(dll.getTail()).toEqual(node);
-        dll.clear();
-        expect(dll.getSize()).toEqual(0);
-        expect(dll.getHead()).toEqual(null);
-        expect(dll.getTail()).toEqual(null);
-    });
-    test("remove - head", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        const node3 = new Node(token);
-        dll.append(node1);
-        dll.append(node2);
-        dll.append(node3);
-        expect(dll.getSize()).toEqual(3);
-        dll.remove(node1);
-        expect(dll.getSize()).toEqual(2);
-        expect(dll.getHead()).toEqual(node2);
-        expect(dll.getHead()?.next).toEqual(node3);
-        expect(dll.getTail()).toEqual(node3);
-    });
-    test("remove - tail", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        const node3 = new Node(token);
-        dll.append(node1);
-        dll.append(node2);
-        dll.append(node3);
-        expect(dll.getSize()).toEqual(3);
-        dll.remove(node3);
-        expect(dll.getSize()).toEqual(2);
-        expect(dll.getHead()).toEqual(node1);
-        expect(dll.getHead()?.next).toEqual(node2);
-        expect(dll.getTail()).toEqual(node2);
-    });
-    test("remove - in between", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        const node3 = new Node(token);
-        dll.append(node1);
-        dll.append(node2);
-        dll.append(node3);
-        expect(dll.getSize()).toEqual(3);
-        dll.remove(node2);
-        expect(dll.getSize()).toEqual(2);
-        expect(dll.getHead()).toEqual(node1);
-        expect(dll.getHead()?.next).toEqual(node3);
-        expect(node3.prev).toEqual(node1);
-        expect(dll.getTail()).toEqual(node3);
-    });
-    test("insertAfter - head", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        dll.append(node1);
-        expect(dll.getSize()).toEqual(1);
-        dll.insertAfter(node2, node1);
-        expect(dll.getSize()).toEqual(2);
-        expect(dll.getHead()).toEqual(node1);
-        expect(dll.getTail()).toEqual(node2);
-    });
-    test("insertAfter - tail", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        const node3 = new Node(token);
-        dll.append(node1);
-        dll.append(node2);
-        expect(dll.getSize()).toEqual(2);
-        dll.insertAfter(node3, node2);
-        expect(dll.getSize()).toEqual(3);
-        expect(dll.getHead()).toEqual(node1);
-        expect(dll.getHead()?.next).toEqual(node2);
-        expect(dll.getHead()?.next?.next).toEqual(node3);
-        expect(dll.getTail()).toEqual(node3);
-    });
-    test("insertAfter - node in between", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        const node3 = new Node(token);
-        dll.append(node1);
-        dll.append(node2);
-        expect(dll.getSize()).toEqual(2);
-        dll.insertAfter(node3, node1);
-        expect(dll.getSize()).toEqual(3);
-        expect(dll.getHead()).toEqual(node1);
-        expect(dll.getHead()?.next).toEqual(node3);
-        expect(dll.getHead()?.next?.next).toEqual(node2);
-        expect(dll.getTail()).toEqual(node2);
-    });
-    test("insertBefore - head", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        dll.append(node1);
-        expect(dll.getSize()).toEqual(1);
-        dll.insertBefore(node2, node1);
-        expect(dll.getSize()).toEqual(2);
-        expect(dll.getHead()).toEqual(node2);
-        expect(dll.getTail()).toEqual(node1);
-    });
-    test("insertBefore - tail", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        const node3 = new Node(token);
-        dll.append(node1);
-        dll.append(node2);
-        expect(dll.getSize()).toEqual(2);
-        dll.insertBefore(node3, node2);
-        expect(dll.getSize()).toEqual(3);
-        expect(dll.getHead()).toEqual(node1);
-        expect(dll.getHead()?.next).toEqual(node3);
-        expect(dll.getHead()?.next?.next).toEqual(node2);
-        expect(dll.getTail()).toEqual(node2);
-    });
-    test("insertBefore - node in between", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        const node3 = new Node(token);
-        dll.append(node1);
-        dll.append(node2);
-        expect(dll.getSize()).toEqual(2);
-        dll.insertBefore(node3, node1);
-        expect(dll.getSize()).toEqual(3);
-        expect(dll.getHead()).toEqual(node3);
-        expect(dll.getHead()?.next).toEqual(node1);
-        expect(dll.getHead()?.next?.next).toEqual(node2);
-        expect(dll.getTail()).toEqual(node2);
-    });
-    test("find", () => {
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token);
-        const node2 = new Node(token);
-        const node3 = new Node(token);
-        dll.append(node1);
-        dll.append(node2);
-        dll.append(node3);
-        expect(dll.getSize()).toEqual(3);
-        expect(dll.find((node) => node === dll.getHead())).toEqual(node1);
-        expect(dll.find((node) => node === dll.getTail())).toEqual(node3);
-        expect(dll.find((node) => node.data.value === "ok")).toEqual(null);
-    });
-    test("fromArray", () => {
-        const data = [token, token, token];
-        const dll = DoublyLinkedList.fromArray(data);
-        expect(dll.getSize()).toEqual(3);
-        expect(dll.getHead()?.backward(1)).toEqual(null);
-        expect(dll.getHead()?.forward(1)).not.toEqual(null);
-        expect(dll.getHead()?.forward(2)).not.toEqual(null);
-        expect(dll.getHead()?.forward(3)).toEqual(null);
-        expect(dll.getTail()?.forward(1)).toEqual(null);
-        expect(dll.getTail()?.backward(1)).not.toEqual(null);
-        expect(dll.getTail()?.backward(2)).not.toEqual(null);
-        expect(dll.getTail()?.backward(3)).toEqual(null);
-    });
-    test("toArray", () => {
-        const data = [token, token, token];
-        const dll = DoublyLinkedList.fromArray(data);
-        expect(dll.getSize()).toEqual(3);
-        expect(dll.toArray().length).toEqual(3);
-        expect(dll?.toArray?.()?.[0]?.data).toEqual(data[0]);
-        expect(dll?.toArray?.()?.[1]?.data).toEqual(data[1]);
-        expect(dll?.toArray?.()?.[2]?.data).toEqual(data[2]);
-    });
-    test("reverse", () => {
-        const token1 = new Token("test1");
-        const token2 = new Token("test2");
-        const token3 = new Token("test3");
-        const token4 = new Token("test4");
-        const dll = new DoublyLinkedList();
-        const node1 = new Node(token1);
-        const node2 = new Node(token2);
-        const node3 = new Node(token3);
-        const node4 = new Node(token4);
-        dll.append(node1);
-        dll.append(node2);
-        dll.append(node3);
-        dll.append(node4);
-        expect(dll.getSize()).toEqual(4);
-        dll.reverse();
-        expect(dll.getSize()).toEqual(4);
-        expect(dll.getHead()).toEqual(node4);
-        expect(dll.getHead()?.next).toEqual(node3);
-        expect(dll.getHead()?.next?.next).toEqual(node2);
-        expect(dll.getHead()?.next?.next?.next).toEqual(node1);
-        expect(dll.getTail()).toEqual(node1);
-    });
-    test("Symbol.iterator", () => {
-        const dll = new DoublyLinkedList();
-        const firstToken = new Token("first");
-        const firstNode = new Node(firstToken);
-        const secondToken = new Token("second");
-        const secondNode = new Node(secondToken);
-        const thirdToken = new Token("third");
-        const thirdNode = new Node(thirdToken);
-        dll.append(firstNode);
-        dll.append(secondNode);
-        dll.append(thirdNode);
-        let index = 0;
-        for (const node of dll) {
-            if (index === 0)
-                expect(node.data).toEqual(firstToken);
-            if (index === 1)
-                expect(node.data).toEqual(secondToken);
-            if (index === 2)
-                expect(node.data).toEqual(thirdToken);
-            index += 1;
-        }
-    });
-});

package/dist/tests/duration-ms.vo.test.d.ts

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

package/dist/tests/duration-ms.vo.test.js

@@ -1,18 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { DurationMs } from "../src/duration-ms.vo";
-describe("DurationMs", () => {
-    test("happy path", () => {
-        expect(v.safeParse(DurationMs, 0).success).toEqual(true);
-        expect(v.safeParse(DurationMs, 10_000).success).toEqual(true);
-    });
-    test("rejects non-number - null", () => {
-        expect(() => v.parse(DurationMs, null)).toThrow("duration.invalid");
-    });
-    test("rejects non-number - string", () => {
-        expect(() => v.parse(DurationMs, "123")).toThrow("duration.invalid");
-    });
-    test("rejects fractions", () => {
-        expect(() => v.parse(DurationMs, 1.5)).toThrow("duration.invalid");
-    });
-});

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

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

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

@@ -1,126 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Duration } from "../src/duration.service";
-import { DurationMs } from "../src/duration-ms.vo";
-import { MultiplicationFactor } from "../src/multiplication-factor.vo";
-describe("Duration", () => {
-    test("weeks", () => {
-        const weeks = Duration.Weeks(2);
-        expect(weeks.days).toEqual(14);
-        expect(weeks.hours).toEqual(336);
-        expect(weeks.minutes).toEqual(20160);
-        expect(weeks.seconds).toEqual(1209600);
-        expect(weeks.ms).toEqual(v.parse(DurationMs, 1_209_600_000));
-        expect(weeks.ns).toEqual(1_209_600_000_000_000);
-    });
-    test("days", () => {
-        const days = Duration.Days(2);
-        expect(days.weeks).toEqual(0.29);
-        expect(days.days).toEqual(2);
-        expect(days.hours).toEqual(48);
-        expect(days.minutes).toEqual(2880);
-        expect(days.seconds).toEqual(172800);
-        expect(days.ms).toEqual(v.parse(DurationMs, 172_800_000));
-        expect(days.ns).toEqual(172_800_000_000_000);
-    });
-    test("hours", () => {
-        const hours = Duration.Hours(3);
-        expect(hours.weeks).toEqual(0.02);
-        expect(hours.days).toEqual(0.13);
-        expect(hours.hours).toEqual(3);
-        expect(hours.minutes).toEqual(180);
-        expect(hours.seconds).toEqual(10_800);
-        expect(hours.ms).toEqual(v.parse(DurationMs, 10_800_000));
-        expect(hours.ns).toEqual(10_800_000_000_000);
-    });
-    test("minutes", () => {
-        const minutes = Duration.Minutes(30);
-        expect(minutes.weeks).toEqual(0);
-        expect(minutes.days).toEqual(0.02);
-        expect(minutes.hours).toEqual(0.5);
-        expect(minutes.minutes).toEqual(30);
-        expect(minutes.seconds).toEqual(1_800);
-        expect(minutes.ms).toEqual(v.parse(DurationMs, 1_800_000));
-        expect(minutes.ns).toEqual(1_800_000_000_000);
-    });
-    test("seconds", () => {
-        const seconds = Duration.Seconds(120);
-        expect(seconds.weeks).toEqual(0);
-        expect(seconds.days).toEqual(0);
-        expect(seconds.hours).toEqual(0.03);
-        expect(seconds.minutes).toEqual(2);
-        expect(seconds.seconds).toEqual(120);
-        expect(seconds.ms).toEqual(v.parse(DurationMs, 120_000));
-        expect(seconds.ns).toEqual(120_000_000_000);
-    });
-    test("ms", () => {
-        const ms = Duration.Ms(500);
-        expect(ms.weeks).toEqual(0);
-        expect(ms.days).toEqual(0);
-        expect(ms.hours).toEqual(0);
-        expect(ms.minutes).toEqual(0.01);
-        expect(ms.seconds).toEqual(0.5);
-        expect(ms.ms).toEqual(v.parse(DurationMs, 500));
-        expect(ms.ns).toEqual(500_000_000);
-    });
-    test("ns", () => {
-        const ns = Duration.Ns(5_499_999);
-        expect(ns.weeks).toEqual(0);
-        expect(ns.days).toEqual(0);
-        expect(ns.hours).toEqual(0);
-        expect(ns.minutes).toEqual(0);
-        expect(ns.seconds).toEqual(0.01);
-        expect(ns.ms).toEqual(v.parse(DurationMs, 5));
-        expect(ns.ns).toEqual(5_000_000);
-    });
-    test("add/subtract", () => {
-        const base = Duration.Seconds(10);
-        const added = base.add(Duration.Seconds(5));
-        const subtracted = base.subtract(Duration.Seconds(3));
-        expect(added.seconds).toEqual(15);
-        expect(subtracted.seconds).toEqual(7);
-    });
-    test("times", () => {
-        const base = Duration.Ms(10);
-        const factor = v.parse(MultiplicationFactor, 1.5);
-        const result = base.times(factor);
-        expect(result.ms).toEqual(v.parse(DurationMs, 15));
-    });
-    test("times - rounding", () => {
-        const base = Duration.Ms(7);
-        const factor = v.parse(MultiplicationFactor, 1.29);
-        const result = base.times(factor);
-        expect(result.ms).toEqual(v.parse(DurationMs, 9));
-    });
-    test("equals", () => {
-        const a = Duration.Ms(1_000);
-        const b = Duration.Ms(2_000);
-        expect(a.equals(a)).toEqual(true);
-        expect(a.equals(b)).toEqual(false);
-    });
-    test("isLongerThan", () => {
-        const a = Duration.Ms(2_000);
-        const b = Duration.Ms(1_000);
-        expect(a.isLongerThan(b)).toEqual(true);
-        expect(a.isLongerThan(a)).toEqual(false);
-    });
-    test("isShorterThan", () => {
-        const a = Duration.Ms(1_000);
-        const b = Duration.Ms(2_000);
-        expect(a.isShorterThan(b)).toEqual(true);
-        expect(a.isShorterThan(a)).toEqual(false);
-    });
-    test("toAbsolute", () => {
-        expect(Duration.Ms(1000).toAbsolute()).toEqual(Duration.Ms(1000));
-        expect(Duration.Ms(-1000).toAbsolute()).toEqual(Duration.Ms(1000));
-    });
-    test("MIN", () => {
-        expect(Duration.MIN.ms).toEqual(v.parse(DurationMs, 1));
-    });
-    test("toString", () => {
-        expect(Duration.MIN.toString()).toEqual("1");
-    });
-    test("toJSON", () => {
-        expect(Duration.MIN.toJSON()).toEqual(1);
-    });
-});

package/dist/tests/email-mask.service.test.d.ts

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

package/dist/tests/email-mask.service.test.js

@@ -1,15 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Email } from "../src/email.vo";
-import { EmailMask } from "../src/email-mask.service";
-describe("EmailMask", () => {
-    test("works for 1 char", () => {
-        expect(EmailMask.censor(v.parse(Email, "t@example.com"))).toEqual("*@example.com");
-    });
-    test("works for 2 chars", () => {
-        expect(EmailMask.censor(v.parse(Email, "te@example.com"))).toEqual("**@example.com");
-    });
-    test("works for more than 2 chars", () => {
-        expect(EmailMask.censor(v.parse(Email, "testing@example.com"))).toEqual("t*****g@example.com");
-    });
-});

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

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