@bgord/tools 1.4.0 → 1.4.1

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");
-    });
-});

package/dist/tests/feature-flag-value.vo.test.d.ts

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

package/dist/tests/feature-flag-value.vo.test.js

@@ -1,12 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { FeatureFlagValue } from "../src/feature-flag-value.vo";
-describe("FeatureFlagValue", () => {
-    test("happy path", () => {
-        expect(v.safeParse(FeatureFlagValue, "yes").success).toEqual(true);
-        expect(v.safeParse(FeatureFlagValue, "no").success).toEqual(true);
-    });
-    test("rejects other values", () => {
-        expect(() => v.parse(FeatureFlagValue, "maybe")).toThrow("feature.flag.value.invalid");
-    });
-});

package/dist/tests/feature-flag.vo.test.d.ts

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

package/dist/tests/feature-flag.vo.test.js

@@ -1,13 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { FeatureFlag } from "../src/feature-flag.vo";
-import { FeatureFlagEnum } from "../src/feature-flag-value.vo";
-describe("FeatureFlag", () => {
-    test("isEnabled", () => {
-        expect(FeatureFlag.isEnabled(FeatureFlagEnum.yes)).toEqual(true);
-        expect(FeatureFlag.isEnabled(FeatureFlagEnum.no)).toEqual(false);
-    });
-    test("isDisabled", () => {
-        expect(FeatureFlag.isDisabled(FeatureFlagEnum.yes)).toEqual(false);
-        expect(FeatureFlag.isDisabled(FeatureFlagEnum.no)).toEqual(true);
-    });
-});

package/dist/tests/file-path-absolute-schema.vo.test.d.ts

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

package/dist/tests/file-path-absolute-schema.vo.test.js

@@ -1,53 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { DirectoryPathAbsoluteSchema } from "../src/directory-path-absolute.vo";
-import { FilePathAbsoluteSchema } from "../src/file-path-absolute-schema.vo";
-describe("FilePathAbsoluteSchema", () => {
-    test("happy path", () => {
-        expect({
-            directory: v.parse(FilePathAbsoluteSchema, "/avatar.webp").directory,
-            filename: v.parse(FilePathAbsoluteSchema, "/avatar.webp").filename.get(),
-        }).toEqual({ directory: v.parse(DirectoryPathAbsoluteSchema, "/"), filename: "avatar.webp" });
-        expect({
-            directory: v.parse(FilePathAbsoluteSchema, "/var/uploads/avatar.webp").directory,
-            filename: v.parse(FilePathAbsoluteSchema, "/var/uploads/avatar.webp").filename.get(),
-        }).toEqual({ directory: v.parse(DirectoryPathAbsoluteSchema, "/var/uploads"), filename: "avatar.webp" });
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(FilePathAbsoluteSchema, 123)).toThrow("file.path.absolute.type");
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(FilePathAbsoluteSchema, null)).toThrow("file.path.absolute.type");
-    });
-    test("rejects empty", () => {
-        expect(() => v.parse(FilePathAbsoluteSchema, "")).toThrow("file.path.absolute.empty");
-    });
-    test("rejects lacking leading slash", () => {
-        expect(() => v.parse(FilePathAbsoluteSchema, "var/uploads/avatar.webp")).toThrow("file.path.absolute.leading.slash");
-    });
-    test("rejects backslashes", () => {
-        expect(() => v.parse(FilePathAbsoluteSchema, "/var\\uploads/avatar.webp")).toThrow("file.path.absolute.backslash.forbidden");
-    });
-    test("rejects trailing slash", () => {
-        expect(() => v.parse(FilePathAbsoluteSchema, "/var/uploads/avatar.webp/")).toThrow("file.path.absolute.trailing.slash");
-    });
-    test("single-segment path keeps root directory", () => {
-        expect({
-            directory: v.parse(FilePathAbsoluteSchema, "/avatar.webp").directory,
-            filename: v.parse(FilePathAbsoluteSchema, "/avatar.webp").filename.get(),
-        }).toEqual({ directory: v.parse(DirectoryPathAbsoluteSchema, "/"), filename: "avatar.webp" });
-    });
-    test("delegated failures", () => {
-        const invalid = [
-            "/var/./avatar.webp",
-            "/var/../avatar.webp",
-            "/var/\u0000/uploads/avatar.webp",
-            "/var/uploads/",
-            "/var/uploads/avatar",
-            "/var/upload s/avatar.webp",
-        ];
-        for (const value of invalid) {
-            expect(() => v.parse(FilePathAbsoluteSchema, value)).toThrow();
-        }
-    });
-});

package/dist/tests/file-path-relative-schema.vo.test.d.ts

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

package/dist/tests/file-path-relative-schema.vo.test.js

@@ -1,52 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { DirectoryPathRelativeSchema } from "../src/directory-path-relative.vo";
-import { FilePathRelativeSchema } from "../src/file-path-relative-schema.vo";
-describe("FilePathRelativeSchema", () => {
-    test("happy path", () => {
-        expect({
-            directory: v.parse(FilePathRelativeSchema, "tmp/file.txt").directory,
-            filename: v.parse(FilePathRelativeSchema, "tmp/file.txt").filename.get(),
-        }).toEqual({ directory: v.parse(DirectoryPathRelativeSchema, "tmp"), filename: "file.txt" });
-        expect({
-            directory: v.parse(FilePathRelativeSchema, "a/b/c/avatar.webp").directory,
-            filename: v.parse(FilePathRelativeSchema, "a/b/c/avatar.webp").filename.get(),
-        }).toEqual({ directory: v.parse(DirectoryPathRelativeSchema, "a/b/c"), filename: "avatar.webp" });
-        expect({
-            directory: v.parse(FilePathRelativeSchema, "dir/sub/archive.tar.gz").directory,
-            filename: v.parse(FilePathRelativeSchema, "dir/sub/archive.tar.gz").filename.get(),
-        }).toEqual({ directory: v.parse(DirectoryPathRelativeSchema, "dir/sub"), filename: "archive.tar.gz" });
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(FilePathRelativeSchema, null)).toThrow("file.path.relative.type");
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(FilePathRelativeSchema, 123)).toThrow("file.path.relative.type");
-    });
-    test("rejects empty", () => {
-        expect(() => v.parse(FilePathRelativeSchema, "")).toThrow("file.path.relative.empty");
-    });
-    test("rejects leading slash", () => {
-        expect(() => v.parse(FilePathRelativeSchema, "/tmp/file.txt")).toThrow("file.path.relative.leading.slash");
-    });
-    test("rejects backslash", () => {
-        expect(() => v.parse(FilePathRelativeSchema, "tmp\\file.txt")).toThrow("file.path.relative.backslash.forbidden");
-    });
-    test("rejects no directory", () => {
-        expect(() => v.parse(FilePathRelativeSchema, "file.txt")).toThrow("file.path.relative.requires.directory");
-    });
-    test("delegated failures", () => {
-        const invalid = [
-            "tmp/./file.txt",
-            "tmp/../file.txt",
-            "tmp/\u0000/sub/file.txt",
-            "my dir/file.txt",
-            "tmp/file",
-            "tmp/file name.txt",
-            "tmp/",
-        ];
-        for (const value of invalid) {
-            expect(() => v.parse(FilePathRelativeSchema, value)).toThrow();
-        }
-    });
-});

package/dist/tests/file-path.vo.test.d.ts

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

package/dist/tests/file-path.vo.test.js

@@ -1,74 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { DirectoryPathAbsoluteSchema } from "../src/directory-path-absolute.vo";
-import { DirectoryPathRelativeSchema } from "../src/directory-path-relative.vo";
-import { FilePathAbsolute, FilePathRelative } from "../src/file-path.vo";
-import { Filename } from "../src/filename.vo";
-describe("FilePathRelative", () => {
-    test("fromParts", () => {
-        expect(FilePathRelative.fromParts("users/avatars", Filename.fromString("avatar.webp")).get()).toEqual("users/avatars/avatar.webp");
-    });
-    test("fromString", () => {
-        expect({
-            path: FilePathRelative.fromString("tmp/file.txt").get(),
-            directory: FilePathRelative.fromString("tmp/file.txt").getDirectory(),
-            filename: FilePathRelative.fromString("tmp/file.txt").getFilename().get(),
-        }).toEqual({
-            path: "tmp/file.txt",
-            directory: v.parse(DirectoryPathRelativeSchema, "tmp"),
-            filename: "file.txt",
-        });
-    });
-    test("rejects absolute paths", () => {
-        expect(() => FilePathRelative.fromString("/tmp/file.txt")).toThrow();
-    });
-    test("withFilename", () => {
-        expect(FilePathRelative.fromParts("users/avatars", Filename.fromString("avatar.webp"))
-            .withFilename(Filename.fromString("avatar.png"))
-            .get()).toEqual("users/avatars/avatar.png");
-    });
-    test("withDirectory", () => {
-        expect(FilePathRelative.fromParts("users/avatars", Filename.fromString("avatar.webp"))
-            .withDirectory(v.parse(DirectoryPathRelativeSchema, "users/pictures"))
-            .get()).toEqual("users/pictures/avatar.webp");
-    });
-    test("toAbsolute", () => {
-        expect(FilePathRelative.fromParts("users/avatars", Filename.fromString("avatar.webp"))
-            .toAbsolute(v.parse(DirectoryPathAbsoluteSchema, "/tmp/app"))
-            .get()).toEqual("/tmp/app/avatar.webp");
-    });
-});
-describe("FilePathAbsolute", () => {
-    test("fromParts", () => {
-        expect(FilePathAbsolute.fromParts("/tmp/app/users", Filename.fromString("avatar.webp")).get()).toEqual("/tmp/app/users/avatar.webp");
-    });
-    test("fromString", () => {
-        expect({
-            path: FilePathAbsolute.fromString("/avatar.webp").get(),
-            directory: FilePathAbsolute.fromString("/avatar.webp").getDirectory(),
-            filename: FilePathAbsolute.fromString("/avatar.webp").getFilename().get(),
-        }).toEqual({
-            path: "/avatar.webp",
-            directory: v.parse(DirectoryPathAbsoluteSchema, "/"),
-            filename: "avatar.webp",
-        });
-    });
-    test("rejects relative paths", () => {
-        expect(() => FilePathAbsolute.fromString("var/uploads/avatar.webp")).toThrow();
-    });
-    test("withFilename", () => {
-        expect(FilePathAbsolute.fromParts("/tmp/app/users", Filename.fromString("avatar.webp"))
-            .withFilename(Filename.fromString("avatar.png"))
-            .get()).toEqual("/tmp/app/users/avatar.png");
-    });
-    test("withDirectory", () => {
-        expect(FilePathAbsolute.fromParts("/tmp/app/users", Filename.fromString("avatar.webp"))
-            .withDirectory(v.parse(DirectoryPathAbsoluteSchema, "/var/lib/app/users"))
-            .get()).toEqual("/var/lib/app/users/avatar.webp");
-    });
-    test("toRelative", () => {
-        expect(FilePathAbsolute.fromParts("/tmp/app/users", Filename.fromString("avatar.webp"))
-            .toRelative(v.parse(DirectoryPathRelativeSchema, "users/avatars"))
-            .get()).toEqual("users/avatars/avatar.webp");
-    });
-});

package/dist/tests/filename-affix.vo.test.d.ts

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

package/dist/tests/filename-affix.vo.test.js

@@ -1,30 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { FilenameAffix } from "../src/filename-affix.vo";
-describe("FilenameAffixSchema", () => {
-    test("happy path", () => {
-        expect(v.safeParse(FilenameAffix, "-sm").success).toEqual(true);
-        expect(v.safeParse(FilenameAffix, "_v2").success).toEqual(true);
-    });
-    test("rejects prefix", () => {
-        expect(() => v.parse(FilenameAffix, "*-sm")).toThrow("affix.bad.chars");
-    });
-    test("rejects suffix", () => {
-        expect(() => v.parse(FilenameAffix, "sm-*")).toThrow("affix.bad.chars");
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(FilenameAffix, 123)).toThrow("affix.type");
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(FilenameAffix, null)).toThrow("affix.type");
-    });
-    test("rejects empty", () => {
-        expect(() => v.parse(FilenameAffix, "")).toThrow("affix.empty");
-    });
-    test("rejects too long", () => {
-        expect(() => v.parse(FilenameAffix, "x".repeat(33))).toThrow("affix.too.long");
-    });
-    test("rejects disallowed characters", () => {
-        expect(() => v.parse(FilenameAffix, "/@!")).toThrow("affix.bad.chars");
-    });
-});

package/dist/tests/filename-from-string.vo.test.d.ts

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

package/dist/tests/filename-from-string.vo.test.js

@@ -1,37 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Basename } from "../src/basename.vo";
-import { Extension } from "../src/extension.vo";
-import { FilenameFromString } from "../src/filename-from-string.vo";
-describe("FilenameFromString", () => {
-    test("happy path", () => {
-        expect(v.parse(FilenameFromString, "avatar.WEBP")).toEqual({
-            basename: v.parse(Basename, "avatar"),
-            extension: v.parse(Extension, "webp"),
-        });
-    });
-    test("rejects prefix", () => {
-        expect(() => v.parse(FilenameFromString, "\navatar.png")).toThrow("filename.from.string.invalid");
-    });
-    test("rejects suffix", () => {
-        expect(() => v.parse(FilenameFromString, "avatar.png\n")).toThrow("filename.from.string.invalid");
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(FilenameFromString, null)).toThrow("filename.from.string.type");
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(FilenameFromString, 123)).toThrow("filename.from.string.type");
-    });
-    test("rejects empty", () => {
-        expect(() => v.parse(FilenameFromString, "")).toThrow("filename.from.string.invalid");
-    });
-    test("rejects missing extension", () => {
-        expect(() => v.parse(FilenameFromString, "avatar")).toThrow("filename.from.string.invalid");
-    });
-    test("rejects missing extension with dot", () => {
-        expect(() => v.parse(FilenameFromString, "name.")).toThrow("filename.from.string.invalid");
-    });
-    test("rejects only an extension", () => {
-        expect(() => v.parse(FilenameFromString, ".png")).toThrow("filename.from.string.invalid");
-    });
-});

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

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

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

@@ -1,93 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Basename } from "../src/basename.vo";
-import { Extension } from "../src/extension.vo";
-import { Filename } from "../src/filename.vo";
-import { FilenameAffix, FilenameAffixStrategy } from "../src/filename-affix.vo";
-import { FilenameFromStringError } from "../src/filename-from-string.vo";
-describe("Filename", () => {
-    test("fromParts", () => {
-        expect(Filename.fromParts("report", ".PNG").get()).toEqual("report.png");
-    });
-    test("fromPartsSafe", () => {
-        const basename = v.parse(Basename, "avatar");
-        const extension = v.parse(Extension, "webp");
-        expect(Filename.fromPartsSafe(basename, extension).get()).toEqual("avatar.webp");
-    });
-    test("fromString rejects invalid input", () => {
-        expect(() => Filename.fromString("avatar")).toThrow(FilenameFromStringError.Invalid);
-        expect(() => Filename.fromString(".env")).toThrow(FilenameFromStringError.Invalid);
-        expect(() => Filename.fromString("name.")).toThrow(FilenameFromStringError.Invalid);
-    });
-    test("get", () => {
-        expect(Filename.fromParts("user-photo", "jpg").get()).toEqual("user-photo.jpg");
-    });
-    test("getBasename", () => {
-        expect(Filename.fromString("user-photo.jpg").getBasename()).toEqual(v.parse(Basename, "user-photo"));
-    });
-    test("getExtension", () => {
-        expect(Filename.fromString("user-photo.jpg").getExtension()).toEqual(v.parse(Extension, "jpg"));
-    });
-    test("withExtension", () => {
-        const filename = Filename.fromString("avatar.webp");
-        const extension = v.parse(Extension, "png");
-        const updated = filename.withExtension(extension);
-        expect(filename.get()).toEqual("avatar.webp");
-        expect(updated.get()).toEqual("avatar.png");
-    });
-    test("withBasename", () => {
-        const filename = Filename.fromString("avatar.webp");
-        const basename = v.parse(Basename, "profile_v2");
-        const updated = filename.withBasename(basename);
-        expect(filename.get()).toEqual("avatar.webp");
-        expect(updated.get()).toEqual("profile_v2.webp");
-    });
-    test("withAffix - suffix", () => {
-        expect(Filename.fromString("avatar.webp").withAffix("-sm", FilenameAffixStrategy.suffix).get()).toEqual("avatar-sm.webp");
-    });
-    test("withSuffix", () => {
-        expect(Filename.fromString("avatar.webp").withSuffix("-sm").get()).toEqual("avatar-sm.webp");
-    });
-    test("withAffix rejects invalid input - suffix", () => {
-        expect(() => Filename.fromString("avatar.webp").withAffix("", FilenameAffixStrategy.suffix)).toThrow("affix.empty");
-    });
-    test("withAffixSafe - suffix", () => {
-        const filename = Filename.fromString("avatar.webp");
-        const affix = v.parse(FilenameAffix, "-sm");
-        expect(filename.withAffixSafe(affix, FilenameAffixStrategy.suffix).get()).toEqual("avatar-sm.webp");
-    });
-    test("withSuffixSafe", () => {
-        const filename = Filename.fromString("avatar.webp");
-        const affix = v.parse(FilenameAffix, "-sm");
-        expect(filename.withSuffixSafe(affix).get()).toEqual("avatar-sm.webp");
-    });
-    test("withAffix - prefix", () => {
-        expect(Filename.fromString("avatar.webp").withAffix("sm-", FilenameAffixStrategy.prefix).get()).toEqual("sm-avatar.webp");
-    });
-    test("withPrefix", () => {
-        expect(Filename.fromString("avatar.webp").withPrefix("sm-").get()).toEqual("sm-avatar.webp");
-    });
-    test("withAffix rejects invalid input - prefix", () => {
-        expect(() => Filename.fromString("avatar.webp").withAffix("", FilenameAffixStrategy.prefix)).toThrow("affix.empty");
-    });
-    test("withAffixSafe - prefix", () => {
-        const filename = Filename.fromString("avatar.webp");
-        const affix = v.parse(FilenameAffix, "sm-");
-        expect(filename.withAffixSafe(affix, FilenameAffixStrategy.prefix).get()).toEqual("sm-avatar.webp");
-    });
-    test("withPrefixSafe", () => {
-        const filename = Filename.fromString("avatar.webp");
-        const affix = v.parse(FilenameAffix, "sm-");
-        expect(filename.withPrefixSafe(affix).get()).toEqual("sm-avatar.webp");
-    });
-    test("toString", () => {
-        const basename = v.parse(Basename, "avatar");
-        const extension = v.parse(Extension, "webp");
-        expect(Filename.fromPartsSafe(basename, extension).toString()).toEqual("avatar.webp");
-    });
-    test("toJSON", () => {
-        const basename = v.parse(Basename, "avatar");
-        const extension = v.parse(Extension, "webp");
-        expect(Filename.fromPartsSafe(basename, extension).toJSON()).toEqual("avatar.webp");
-    });
-});

package/dist/tests/height-milimiters.vo.test.d.ts

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

package/dist/tests/height-milimiters.vo.test.js

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

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

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

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

@@ -1,64 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Height } from "../src/height.vo";
-import { HeightMillimeters } from "../src/height-milimiters.vo";
-import { RoundingDownStrategy } from "../src/rounding-down.strategy";
-import { RoundingUpStrategy } from "../src/rounding-up.strategy";
-describe("Height", () => {
-    test("fromCentimeters", () => {
-        expect(Height.fromCentimeters(180).toMillimeters()).toEqual(1800);
-        expect(Height.fromCentimeters(180.04, new RoundingDownStrategy()).toMillimeters()).toEqual(1800);
-        expect(Height.fromCentimeters(180.06, new RoundingUpStrategy()).toMillimeters()).toEqual(1801);
-    });
-    test("fromMillimeters", () => {
-        expect(Height.fromMillimeters(180).toMillimeters()).toEqual(180);
-    });
-    test("fromMillimetersSafe", () => {
-        expect(Height.fromMillimetersSafe(v.parse(HeightMillimeters, 100)).toMillimeters()).toEqual(100);
-    });
-    test("zero factory", () => {
-        expect(Height.zero().toMillimeters()).toEqual(0);
-    });
-    test("guards invalid inputs", () => {
-        expect(() => Height.fromCentimeters(-1)).toThrow("height.millimeters.invalid");
-        expect(() => Height.fromMillimeters(Number.NaN)).toThrow("height.millimeters.type");
-        expect(() => Height.fromMillimeters(Number.POSITIVE_INFINITY)).toThrow("height.millimeters.type");
-    });
-    test("toCentimeters", () => {
-        const height = Height.fromCentimeters(180);
-        expect(height.toCentimeters()).toEqual(180);
-        expect(height.toCentimeters()).toEqual(180);
-        expect(Height.fromMillimeters(1804).toCentimeters()).toEqual(180.4);
-    });
-    test("equals", () => {
-        const a = Height.fromCentimeters(1800);
-        const b = Height.fromCentimeters(180);
-        expect(a.equals(a)).toEqual(true);
-        expect(a.equals(b)).toEqual(false);
-    });
-    test("greaterThan", () => {
-        const a = Height.fromCentimeters(1800);
-        const b = Height.fromCentimeters(180);
-        expect(a.greaterThan(a)).toEqual(false);
-        expect(a.greaterThan(b)).toEqual(true);
-    });
-    test("lessThan", () => {
-        const a = Height.fromCentimeters(180);
-        const b = Height.fromCentimeters(1800);
-        expect(a.lessThan(a)).toEqual(false);
-        expect(a.lessThan(b)).toEqual(true);
-    });
-    test("isZero", () => {
-        expect(Height.zero().isZero()).toEqual(true);
-        expect(Height.fromCentimeters(180).isZero()).toEqual(false);
-    });
-    test("get", () => {
-        expect(Height.fromMillimeters(1804).get()).toEqual(1804);
-    });
-    test("toString", () => {
-        expect(Height.fromMillimeters(1804).toString()).toEqual("1804");
-    });
-    test("toJSON", () => {
-        expect(Height.fromMillimeters(1804).toJSON()).toEqual(1804);
-    });
-});

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

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