@bgord/tools 1.3.24 → 1.4.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Email } from "../src/email.vo";
+describe("Email", () => {
+    test("happy path", () => {
+        expect(v.safeParse(Email, "user@example.com").success).toEqual(true);
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(Email, "")).toThrow("email.invalid");
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(Email, null)).toThrow("email.invalid");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(Email, 123)).toThrow("email.invalid");
+    });
+});

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

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