@bgord/tools 1.4.0 → 1.4.2

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

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

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

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

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

@@ -1,64 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { Hour } from "../src/hour.vo";
-import { HourValue } from "../src/hour-value.vo";
-import * as mocks from "./mocks";
-const FIVE = Hour.fromValue(5);
-const THIRTEEN = Hour.fromValue(13);
-describe("Hour", () => {
-    test("happy path", () => {
-        expect(FIVE.get()).toEqual(v.parse(HourValue, 5));
-    });
-    test("throws for invalid hour values", () => {
-        expect(() => Hour.fromValue(12.5)).toThrow("hour.value.type");
-        expect(() => Hour.fromValue(-1)).toThrow("hour.value.invalid");
-        expect(() => Hour.fromValue(24)).toThrow("hour.value.invalid");
-    });
-    test("fromValueSafe", () => {
-        expect(Hour.fromValueSafe(v.parse(HourValue, 1)).get()).toEqual(v.parse(HourValue, 1));
-    });
-    test("fromTimestampValue", () => {
-        expect(Hour.fromTimestampValue(mocks.TIME_ZERO.ms).get()).toEqual(v.parse(HourValue, 22));
-    });
-    test("fromTimestamp", () => {
-        expect(Hour.fromTimestamp(mocks.TIME_ZERO).get()).toEqual(v.parse(HourValue, 22));
-    });
-    test("zero", () => {
-        expect(Hour.zero().get()).toEqual(v.parse(HourValue, 0));
-    });
-    test("max", () => {
-        expect(Hour.max().get()).toEqual(v.parse(HourValue, 23));
-    });
-    test("get", () => {
-        expect(FIVE.get()).toEqual(v.parse(HourValue, 5));
-    });
-    test("equals", () => {
-        expect(FIVE.equals(FIVE)).toEqual(true);
-        expect(FIVE.equals(THIRTEEN)).toEqual(false);
-    });
-    test("isAfter", () => {
-        expect(THIRTEEN.isAfter(FIVE)).toEqual(true);
-        expect(FIVE.isAfter(THIRTEEN)).toEqual(false);
-        expect(THIRTEEN.isAfter(THIRTEEN)).toEqual(false);
-    });
-    test("isBefore", () => {
-        expect(FIVE.isBefore(THIRTEEN)).toEqual(true);
-        expect(THIRTEEN.isBefore(FIVE)).toEqual(false);
-        expect(THIRTEEN.isBefore(THIRTEEN)).toEqual(false);
-    });
-    test("list", () => {
-        const hours = Hour.list();
-        expect(hours.length).toEqual(24);
-        expect(hours[0].get()).toEqual(v.parse(HourValue, 0));
-        expect(hours[23].get()).toEqual(v.parse(HourValue, 23));
-        expect(Hour.list()).toEqual(hours);
-    });
-    test("toString", () => {
-        expect(FIVE.toString()).toEqual("5");
-        expect(THIRTEEN.toString()).toEqual("13");
-    });
-    test("toJSON", () => {
-        expect(FIVE.toJSON()).toEqual(v.parse(HourValue, 5));
-        expect(THIRTEEN.toJSON()).toEqual(13);
-    });
-});

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

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

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

@@ -1,13 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { IBAN } from "../src/iban.vo";
-import { IbanMask } from "../src/iban-mask.service";
-describe("IbanMask", () => {
-    test("works for a correct value with spaces", () => {
-        const iban = new IBAN("PL61 1090 1014 0000 0712 1981 2874");
-        expect(IbanMask.censor(iban)).toEqual("PL61 **** **** **** **** **** 2874");
-    });
-    test("works for a correct value without spaces", () => {
-        const iban = new IBAN("PL61109010140000071219812874");
-        expect(IbanMask.censor(iban)).toEqual("PL61 **** **** **** **** **** 2874");
-    });
-});

package/dist/tests/iban-schema.vo.test.d.ts

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