@bgord/tools 1.4.0 → 1.4.2

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

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

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

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

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

@@ -1,54 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { ETag, WeakETag } from "../src/etags.vo";
-import { RevisionValue } from "../src/revision-value.vo";
-describe("ETag", () => {
-    test("happy path", () => {
-        const value = "123";
-        const etag = ETag.fromHeader(value);
-        //@ts-expect-error
-        expect(etag.value).toEqual(value);
-        //@ts-expect-error
-        expect(etag.revision).toEqual(123);
-    });
-    test("returns null for W/ prefix", () => {
-        const weakETagValue = "W/123";
-        const etag = ETag.fromHeader(weakETagValue);
-        expect(etag).toEqual(null);
-    });
-    test("returns null for nan", () => {
-        const weakETagValue = "abc";
-        const etag = ETag.fromHeader(weakETagValue);
-        expect(etag).toEqual(null);
-    });
-    test("returns null for empty", () => {
-        expect(ETag.fromHeader()).toEqual(null);
-    });
-    test("static", () => {
-        expect(ETag.HEADER_NAME).toEqual("ETag");
-        expect(ETag.IF_MATCH_HEADER_NAME).toEqual("if-match");
-    });
-});
-describe("WeakETag", () => {
-    test("happy path", () => {
-        const value = "W/123";
-        const weakEtag = WeakETag.fromHeader(value);
-        expect(weakEtag?.value).toEqual(value);
-        expect(weakEtag?.revision).toEqual(v.parse(RevisionValue, 123));
-    });
-    test("returns null for nan", () => {
-        const invalidValue = "W/abc";
-        expect(WeakETag.fromHeader(invalidValue)).toEqual(null);
-    });
-    test("throws for invalid", () => {
-        const invalidValue = "invalid";
-        expect(() => WeakETag.fromHeader(invalidValue)).toThrow("weak.etag.invalid");
-    });
-    test("throws for empty", () => {
-        expect(() => WeakETag.fromHeader()).toThrow("weak.etag.invalid");
-    });
-    test("static", () => {
-        expect(WeakETag.HEADER_NAME).toEqual("ETag");
-        expect(WeakETag.IF_MATCH_HEADER_NAME).toEqual("if-match");
-    });
-});

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

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

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

@@ -1,51 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Extension } from "../src/extension.vo";
-describe("Extension", () => {
-    test("happy path", () => {
-        expect(v.safeParse(Extension, "webp").success).toEqual(true);
-        expect(v.safeParse(Extension, "jpg").success).toEqual(true);
-        expect(v.safeParse(Extension, "7z").success).toEqual(true);
-        expect(v.safeParse(Extension, ".PNG").success).toEqual(true);
-        expect(v.safeParse(Extension, "a".repeat(16)).success).toEqual(true);
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(Extension, 123)).toThrow("extension.type");
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(Extension, null)).toThrow("extension.type");
-    });
-    test("rejects empty string", () => {
-        expect(() => v.parse(Extension, "")).toThrow("extension.empty");
-    });
-    test("rejects single char", () => {
-        expect(() => v.parse(Extension, "a")).toThrow("extension.empty");
-    });
-    test("rejects single dot", () => {
-        expect(() => v.parse(Extension, ".")).toThrow("extension.empty");
-    });
-    test("rejects too long", () => {
-        expect(() => v.parse(Extension, "a".repeat(17))).toThrow("extension.too.long");
-    });
-    test("rejects hyphen", () => {
-        expect(() => v.parse(Extension, "web-p")).toThrow("extension.bad.chars");
-    });
-    test("rejects space", () => {
-        expect(() => v.parse(Extension, "web p")).toThrow("extension.bad.chars");
-    });
-    test("rejects punctuation", () => {
-        expect(() => v.parse(Extension, "webp!")).toThrow("extension.bad.chars");
-    });
-    test("rejects double dot", () => {
-        expect(() => v.parse(Extension, "..png")).toThrow("extension.bad.chars");
-    });
-    test("rejects prefix", () => {
-        expect(() => v.parse(Extension, "!webp")).toThrow("extension.bad.chars");
-    });
-    test("rejects suffix", () => {
-        expect(() => v.parse(Extension, "webp ")).toThrow("extension.bad.chars");
-    });
-    test("rejects internal dot", () => {
-        expect(() => v.parse(Extension, "a.png")).toThrow("extension.bad.chars");
-    });
-});