@bgord/tools 1.3.23 → 1.4.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { HourValue } from "../src/hour-value.vo";
+describe("HourValue", () => {
+    test("happy path", () => {
+        expect(v.safeParse(HourValue, 0).success).toEqual(true);
+        expect(v.safeParse(HourValue, 23).success).toEqual(true);
+    });
+    test("rejects non-number - null", () => {
+        expect(() => v.parse(HourValue, null)).toThrow("hour.value.type");
+    });
+    test("rejects non-number - string", () => {
+        expect(() => v.parse(HourValue, "123")).toThrow("hour.value.type");
+    });
+    test("rejects fractions", () => {
+        expect(() => v.parse(HourValue, 1.5)).toThrow("hour.value.type");
+    });
+    test("rejects negative numbers", () => {
+        expect(() => v.parse(HourValue, -1)).toThrow("hour.value.invalid");
+    });
+    test("rejects too big", () => {
+        expect(() => v.parse(HourValue, 24)).toThrow("hour.value.invalid");
+    });
+});

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

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