@bgord/tools 1.3.24 → 1.4.0

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

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

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

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

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

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

package/dist/tests/iban-schema.vo.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { IbanSchema } from "../src/iban-schema.vo";
+describe("IBAN", () => {
+    test("normalizes and formats valid IBANs", () => {
+        const cases = [
+            "PL61 1090 1014 0000 0712 1981 2874",
+            "pl61 1090 1014 0000 0712 1981 2874",
+            "DE44 5001 0517 5407 3249 31",
+            "GB82WEST12345698765432",
+        ];
+        for (const value of cases) {
+            expect(v.safeParse(IbanSchema, value).success).toEqual(true);
+        }
+    });
+    test("rejects prefix", () => {
+        expect(() => v.parse(IbanSchema, "_PL61 1090 1014 0000 0712 1981 2874")).toThrow("iban.schema.invalid");
+    });
+    test("rejects suffix", () => {
+        expect(() => v.parse(IbanSchema, "PL61 1090 1014 0000 0712 1981 2874_")).toThrow("iban.schema.invalid");
+    });
+    test("rejects non-string input - number", () => {
+        expect(() => v.parse(IbanSchema, 123)).toThrow("iban.schema.type");
+    });
+    test("rejects non-string input - null", () => {
+        expect(() => v.parse(IbanSchema, null)).toThrow("iban.schema.type");
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(IbanSchema, "")).toThrow("iban.schema.invalid");
+    });
+    test("rejects invalid format", () => {
+        const invalid = [
+            "INVALID_VALUE",
+            "61 1090 1014 0000 0712 1981 2874",
+            "PL61 1090 1014 00",
+            "PL61 1090 1014 0000 0712 1981 2874 00000 00",
+            "PL61 1090 1014 $000 0712 1981 2874",
+        ];
+        for (const value of invalid) {
+            expect(() => v.parse(IbanSchema, value)).toThrow("iban.schema.invalid");
+        }
+    });
+});

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

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

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

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { IBAN } from "../src/iban.vo";
+describe("IBAN", () => {
+    test("normalizes and formats", () => {
+        const cases = [
+            [
+                "PL61 1090 1014 0000 0712 1981 2874",
+                "PL61109010140000071219812874",
+                "PL61 1090 1014 0000 0712 1981 2874",
+            ],
+            [
+                "pl61 1090 1014 0000 0712 1981 2874",
+                "PL61109010140000071219812874",
+                "PL61 1090 1014 0000 0712 1981 2874",
+            ],
+            ["DE44 5001 0517 5407 3249 31", "DE44500105175407324931", "DE44 5001 0517 5407 3249 31"],
+            ["GB82WEST12345698765432", "GB82WEST12345698765432", "GB82 WEST 1234 5698 7654 32"],
+        ];
+        for (const [input, normalized, formatted] of cases) {
+            const iban = new IBAN(input);
+            // @ts-expect-error
+            expect(iban.toString()).toEqual(normalized);
+            expect(iban.format()).toEqual(formatted);
+            expect(iban.countryCode).toEqual(normalized.slice(0, 2));
+        }
+    });
+    test("equals", () => {
+        const a = new IBAN("PL61 1090 1014 0000 0712 1981 2874");
+        const b = new IBAN("PL61109010140000071219812874");
+        const c = new IBAN("DE44 5001 0517 5407 3249 31");
+        expect(a.equals(b)).toEqual(true);
+        expect(a.equals(c)).toEqual(false);
+    });
+    test("rejects invalid format", () => {
+        const invalid = [
+            "INVALID_VALUE",
+            "61 1090 1014 0000 0712 1981 2874",
+            "PL61 1090 1014 00",
+            "PL61 1090 1014 0000 0712 1981 2874 00000 00",
+            "PL61 1090 1014 $000 0712 1981 2874",
+        ];
+        for (const value of invalid) {
+            expect(() => new IBAN(value)).toThrow("iban.schema.invalid");
+        }
+    });
+});

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

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

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

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { ImageHeight, ImageWidth } from "../src/image.vo";
+describe("ImageWidth", () => {
+    test("happy path", () => {
+        expect(v.safeParse(ImageWidth, 1).success).toEqual(true);
+        expect(v.safeParse(ImageWidth, 100).success).toEqual(true);
+        expect(v.safeParse(ImageWidth, 10_000).success).toEqual(true);
+    });
+    test("rejects non-numeric - null", () => {
+        expect(() => v.parse(ImageWidth, null)).toThrow("image.width.type");
+    });
+    test("rejects non-numeric - string", () => {
+        expect(() => v.parse(ImageWidth, "100")).toThrow("image.width.type");
+    });
+    test("rejects too small", () => {
+        expect(() => v.parse(ImageWidth, 0)).toThrow("image.width.length");
+    });
+    test("rejects too big", () => {
+        expect(() => v.parse(ImageWidth, 10_001)).toThrow("image.width.length");
+    });
+});
+describe("ImageHeight", () => {
+    test("happy path", () => {
+        expect(v.safeParse(ImageHeight, 1).success).toEqual(true);
+        expect(v.safeParse(ImageHeight, 100).success).toEqual(true);
+        expect(v.safeParse(ImageHeight, 10_000).success).toEqual(true);
+    });
+    test("rejects non-numeric - null", () => {
+        expect(() => v.parse(ImageHeight, null)).toThrow("image.height.type");
+    });
+    test("rejects non-numeric - string", () => {
+        expect(() => v.parse(ImageHeight, "100")).toThrow("image.height.type");
+    });
+    test("rejects too small", () => {
+        expect(() => v.parse(ImageHeight, 0)).toThrow("image.height.length");
+    });
+    test("rejects too big", () => {
+        expect(() => v.parse(ImageHeight, 10_001)).toThrow("image.height.length");
+    });
+});

package/dist/tests/integer-non-negative.vo.test.d.ts

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

package/dist/tests/integer-non-negative.vo.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { IntegerNonNegative } from "../src/integer-non-negative.vo";
+describe("IntegerNonNegative VO", () => {
+    test("happy path", () => {
+        expect(v.safeParse(IntegerNonNegative, 0).success).toEqual(true);
+        expect(v.safeParse(IntegerNonNegative, 1).success).toEqual(true);
+        expect(v.safeParse(IntegerNonNegative, 130).success).toEqual(true);
+    });
+    test("rejects non-number - null", () => {
+        expect(() => v.parse(IntegerNonNegative, null)).toThrow("integer.non.negative.type");
+    });
+    test("rejects non-number - string", () => {
+        expect(() => v.parse(IntegerNonNegative, "100")).toThrow("integer.non.negative.type");
+    });
+    test("rejects fraction", () => {
+        expect(() => v.parse(IntegerNonNegative, 100.5)).toThrow("integer.non.negative.type");
+    });
+    test("rejects negative", () => {
+        expect(() => v.parse(IntegerNonNegative, -1)).toThrow("integer.non.negative.invalid");
+    });
+});

package/dist/tests/integer-positive.vo.test.d.ts

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

package/dist/tests/integer-positive.vo.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { IntegerPositive } from "../src/integer-positive.vo";
+describe("IntegerPositive VO", () => {
+    test("happy path", () => {
+        expect(v.safeParse(IntegerPositive, 1).success).toEqual(true);
+        expect(v.safeParse(IntegerPositive, 130).success).toEqual(true);
+    });
+    test("rejects non-number - null", () => {
+        expect(() => v.parse(IntegerPositive, null)).toThrow("integer.positive.type");
+    });
+    test("rejects non-number - string", () => {
+        expect(() => v.parse(IntegerPositive, "100")).toThrow("integer.positive.type");
+    });
+    test("rejects fraction", () => {
+        expect(() => v.parse(IntegerPositive, 100.5)).toThrow("integer.positive.type");
+    });
+    test("rejects 0", () => {
+        expect(() => v.parse(IntegerPositive, 0)).toThrow("integer.positive.invalid");
+    });
+});

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

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

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

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Integer } from "../src/integer.vo";
+describe("Integer VO", () => {
+    test("happy path", () => {
+        expect(v.safeParse(Integer, -130).success).toEqual(true);
+        expect(v.safeParse(Integer, -1).success).toEqual(true);
+        expect(v.safeParse(Integer, 0).success).toEqual(true);
+        expect(v.safeParse(Integer, 1).success).toEqual(true);
+        expect(v.safeParse(Integer, 130).success).toEqual(true);
+    });
+    test("rejects non-number - null", () => {
+        expect(() => v.parse(Integer, null)).toThrow("integer.type");
+    });
+    test("rejects non-number - string", () => {
+        expect(() => v.parse(Integer, "100")).toThrow("integer.type");
+    });
+    test("rejects fraction", () => {
+        expect(() => v.parse(Integer, 100.5)).toThrow("integer.type");
+    });
+});

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

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

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

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Language } from "../src/language.vo";
+describe("Language", () => {
+    test("happy path", () => {
+        expect(v.safeParse(Language, "en").success).toEqual(true);
+        expect(v.safeParse(Language, "es").success).toEqual(true);
+        expect(v.safeParse(Language, "pl").success).toEqual(true);
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(Language, "")).toThrow("language.bad.chars");
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(Language, null)).toThrow("language.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(Language, 123)).toThrow("language.type");
+    });
+    test("rejects non-lowercase", () => {
+        expect(() => v.parse(Language, "EN")).toThrow("language.bad.chars");
+        expect(() => v.parse(Language, "ES")).toThrow("language.bad.chars");
+        expect(() => v.parse(Language, "PL")).toThrow("language.bad.chars");
+    });
+    test("rejects strings < 1 and > 2", () => {
+        expect(() => v.parse(Language, "e")).toThrow("language.bad.chars");
+        expect(() => v.parse(Language, "eng")).toThrow("language.bad.chars");
+    });
+});

package/dist/tests/linear-regression.service.test.d.ts

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

package/dist/tests/linear-regression.service.test.js

@@ -0,0 +1,111 @@
+import { describe, expect, test } from "bun:test";
+import { LinearRegression } from "../src/linear-regression.service";
+describe("LinearRegression", () => {
+    test("throws when sum of x values is too big", () => {
+        expect(() => LinearRegression.fromPairs([
+            { x: Number.MAX_SAFE_INTEGER, y: 2 },
+            { x: Number.MAX_SAFE_INTEGER, y: 4 },
+        ])).toThrow("linear.regression.sum.x.too.big");
+    });
+    test("throws when sum of y values is too big", () => {
+        expect(() => LinearRegression.fromPairs([
+            { y: Number.MAX_SAFE_INTEGER, x: 2 },
+            { y: Number.MAX_SAFE_INTEGER, x: 4 },
+        ])).toThrow("linear.regression.sum.y.too.big");
+    });
+    test("throws when sum of x times y values is too big", () => {
+        const x = 10_000_000;
+        const y = 100_000_000_000_000;
+        expect(() => LinearRegression.fromPairs([
+            { x, y },
+            { x, y },
+        ])).toThrow("linear.regression.sum.x.times.y.too.big");
+    });
+    test("throws when sum of x squared values is too big", () => {
+        const value = Number.MAX_SAFE_INTEGER;
+        expect(() => LinearRegression.fromPairs([
+            { x: value, y: 0 },
+            { x: -value, y: 0 },
+        ])).toThrow("linear.regression.sum.x.squared.too.big");
+    });
+    test("throws where no min two pairs are provided - empty array", () => {
+        expect(() => LinearRegression.fromPairs([])).toThrow("linear.regression.min.pairs");
+    });
+    test("throws where no min two pairs are provided - one", () => {
+        expect(() => LinearRegression.fromPairs([{ x: 1, y: 2 }])).toThrow("linear.regression.min.pairs");
+    });
+    test("predicts correctly from two pairs", () => {
+        const model = LinearRegression.fromPairs([
+            { x: 1, y: 2 },
+            { x: 2, y: 4 },
+        ]);
+        expect(model.predict(4)).toEqual(8);
+    });
+    test("predicts correctly from three pairs", () => {
+        const model = LinearRegression.fromPairs([
+            { x: 1, y: 2 },
+            { x: 2, y: 4 },
+            { x: 3, y: 6 },
+        ]);
+        expect(model.predict(10)).toEqual(20);
+    });
+    test("predicts correctly for line with non-zero intercept", () => {
+        const model = LinearRegression.fromPairs([
+            { x: 1, y: 3 },
+            { x: 2, y: 5 },
+        ]);
+        expect(model.predict(3)).toEqual(7);
+        expect(model.inspect()).toEqual({ a: 1, b: 2 });
+    });
+    test("works the same way when constructed directly", () => {
+        const model = LinearRegression.fromPairs([
+            { x: 1, y: 2 },
+            { x: 2, y: 4 },
+            { x: 3, y: 6 },
+        ]);
+        const params = model.inspect();
+        const reconstructed = new LinearRegression(params);
+        expect(reconstructed.predict(10)).toEqual(20);
+    });
+    test("works for all zeros in y", () => {
+        const model = LinearRegression.fromPairs([
+            { x: 0, y: 0 },
+            { x: 1, y: 0 },
+            { x: 2, y: 0 },
+        ]);
+        const params = model.inspect();
+        const reconstructed = new LinearRegression(params);
+        expect(reconstructed.predict(10)).toEqual(0);
+    });
+    test("fails for all zeros (x has zero variance)", () => {
+        expect(() => LinearRegression.fromPairs([
+            { x: 0, y: 0 },
+            { x: 0, y: 0 },
+            { x: 0, y: 0 },
+        ])).toThrow("linear.regression.model.creation");
+    });
+    test("incalculable result with identical x values", () => {
+        expect(() => LinearRegression.fromPairs([
+            { x: 0, y: 0 },
+            { x: 0, y: 0 },
+        ])).toThrow("linear.regression.model.creation");
+    });
+    test("throws when sum of x is max safe integer", () => {
+        expect(() => LinearRegression.fromPairs([
+            { x: Number.MAX_SAFE_INTEGER, y: 0 },
+            { x: 0, y: 0 },
+        ])).toThrow("linear.regression.sum.x.too.big");
+    });
+    test("throws when sum of y is max safe integer", () => {
+        expect(() => LinearRegression.fromPairs([
+            { x: 0, y: Number.MAX_SAFE_INTEGER },
+            { x: 0, y: 0 },
+        ])).toThrow("linear.regression.sum.y.too.big");
+    });
+    test("throws when sum of xy is max safe integer", () => {
+        expect(() => LinearRegression.fromPairs([
+            { x: Number.MAX_SAFE_INTEGER - 2, y: 2 },
+            { x: 0, y: 0 },
+        ])).toThrow("linear.regression.sum.x.times.y.too.big");
+    });
+});

package/dist/tests/mean.service.test.d.ts

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

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

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+import { Mean } from "../src/mean.service";
+import { RoundingToNearestStrategy } from "../src/rounding-to-nearest.strategy";
+describe("Mean", () => {
+    test("throws for empty values array", () => {
+        expect(() => Mean.calculate([])).toThrow("mean.not.enough.values");
+    });
+    test("works for one value", () => {
+        expect(Mean.calculate([1])).toEqual(1);
+    });
+    test("works for two values", () => {
+        expect(Mean.calculate([1, 2])).toEqual(1.5);
+    });
+    test("works for three values", () => {
+        expect(Mean.calculate([1, 3, 6])).toEqual(3.33);
+    });
+    test("works for all zeros", () => {
+        expect(Mean.calculate([0, 0, 0])).toEqual(0);
+    });
+    test("non-default rounding", () => {
+        expect(Mean.calculate([1, 3, 6], new RoundingToNearestStrategy())).toEqual(3);
+    });
+});

package/dist/tests/mime-registry-entry.vo.test.d.ts

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

package/dist/tests/mime-registry-entry.vo.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Extension } from "../src/extension.vo";
+import { Mime } from "../src/mime.vo";
+import { MimeRegistryEntry } from "../src/mime-registry-entry.vo";
+describe("MimeRegistryEntry", () => {
+    test("happy path", () => {
+        const jpegMime = Mime.fromString("image/jpeg");
+        const jpgExtension = v.parse(Extension, "jpg");
+        const jpegExtension = v.parse(Extension, "jpeg");
+        const entry = new MimeRegistryEntry(jpegMime, [jpgExtension, jpegExtension]);
+        expect(entry.mime.isSatisfiedBy(jpegMime)).toEqual(true);
+        expect(entry.extensions).toEqual([jpgExtension, jpegExtension]);
+    });
+});

package/dist/tests/mime-registry.service.test.d.ts

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

package/dist/tests/mime-registry.service.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Extension } from "../src/extension.vo";
+import { Mime } from "../src/mime.vo";
+import { MimeRegistry } from "../src/mime-registry.service";
+const jpegMime = Mime.fromString("image/jpeg");
+const jpgExtension = v.parse(Extension, "jpg");
+const jpegExtension = v.parse(Extension, "jpeg");
+const pngMime = Mime.fromString("image/png");
+const pngExtension = v.parse(Extension, "png");
+const pdfMime = Mime.fromString("application/pdf");
+const csvExtension = v.parse(Extension, "csv");
+const registry = new MimeRegistry([
+    { mime: jpegMime, extensions: [jpgExtension, jpegExtension] },
+    { mime: pngMime, extensions: [pngExtension] },
+]);
+describe("MimeRegistry", () => {
+    test("fromExtension - canonical", () => {
+        expect(registry.fromExtension(pngExtension)).toEqual(pngMime);
+    });
+    test("fromExtension - aliases", () => {
+        expect(registry.fromExtension(jpgExtension)).toEqual(jpegMime);
+        expect(registry.fromExtension(jpegExtension)).toEqual(jpegMime);
+    });
+    test("fromExtension - unknown extension", () => {
+        expect(registry.fromExtension(csvExtension)).toEqual(undefined);
+    });
+    test("toExtension", () => {
+        expect(registry.toExtension(jpegMime)).toEqual(jpgExtension);
+        expect(registry.toExtension(pngMime)).toEqual(pngExtension);
+    });
+    test("toExtension - unknown mime", () => {
+        expect(registry.toExtension(pdfMime)).toEqual(undefined);
+    });
+    test("hasExtension", () => {
+        expect(registry.hasExtension(jpgExtension)).toEqual(true);
+        expect(registry.hasExtension(jpgExtension)).toEqual(true);
+        expect(registry.hasExtension(csvExtension)).toEqual(false);
+    });
+    test("hasMime", () => {
+        expect(registry.hasMime(jpegMime)).toEqual(true);
+        expect(registry.hasMime(pngMime)).toEqual(true);
+        expect(registry.hasMime(pdfMime)).toEqual(false);
+    });
+});

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

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

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

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { MimeValue } from "../src/mime-value.vo";
+describe("MimeValue", () => {
+    test("happy path", () => {
+        expect(v.safeParse(MimeValue, "text/plain").success).toEqual(true);
+        expect(v.safeParse(MimeValue, "*/*").success).toEqual(true);
+        expect(v.safeParse(MimeValue, "image/*").success).toEqual(true);
+        expect(v.safeParse(MimeValue, "application/octet-stream").success).toEqual(true);
+        expect(v.safeParse(MimeValue, "video/mp4").success).toEqual(true);
+        expect(v.safeParse(MimeValue, "application/ace+json").success).toEqual(true);
+        expect(v.safeParse(MimeValue, "video/vnd.planar").success).toEqual(true);
+        expect(v.safeParse(MimeValue, `${"a".repeat(24)}/${"a".repeat(72)}`).success).toEqual(true);
+        expect(v.safeParse(MimeValue, "application/clue_info+xml").success).toEqual(true);
+    });
+    test("rejects prefix", () => {
+        expect(() => v.parse(MimeValue, "!text/plain")).toThrow("mime.value.invalid");
+    });
+    test("rejects suffix", () => {
+        expect(() => v.parse(MimeValue, "text/plain!")).toThrow("mime.value.invalid");
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(MimeValue, "")).toThrow("mime.value.invalid");
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(MimeValue, null)).toThrow("mime.value.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(MimeValue, 123)).toThrow("mime.value.type");
+    });
+    test("rejects missing type", () => {
+        expect(() => v.parse(MimeValue, "/plain")).toThrow("mime.value.invalid");
+    });
+    test("rejects too long type", () => {
+        expect(() => v.parse(MimeValue, `${"a".repeat(25)}/plain`)).toThrow("mime.value.invalid");
+    });
+    test("rejects missing subtype", () => {
+        expect(() => v.parse(MimeValue, "text/")).toThrow("mime.value.invalid");
+    });
+    test("rejects too long subtype", () => {
+        expect(() => v.parse(MimeValue, `text/${"a".repeat(73)}`)).toThrow("mime.value.invalid");
+    });
+    test("rejects no slash", () => {
+        expect(() => v.parse(MimeValue, "text")).toThrow("mime.value.invalid");
+    });
+    test("rejects only *", () => {
+        expect(() => v.parse(MimeValue, "*")).toThrow("mime.value.invalid");
+    });
+});

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

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