@bgord/tools 1.3.24 → 1.4.0

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

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test";
+import { Mime } from "../src/mime.vo";
+describe("Mime", () => {
+    test("fromString", () => {
+        const mime = Mime.fromString("text/plain");
+        expect(mime.type).toEqual("text");
+        expect(mime.subtype).toEqual("plain");
+    });
+    test("fromString - trimmed", () => {
+        const mime = Mime.fromString("text/plain ");
+        expect(mime.type).toEqual("text");
+        expect(mime.subtype).toEqual("plain");
+    });
+    test("strips semicolon separated mime metadata", () => {
+        expect(Mime.fromString("text/plain; charset=UTF-8").toString()).toEqual("text/plain");
+    });
+    test("throws InvalidMimeError for invalid input", () => {
+        expect(() => Mime.fromString("")).toThrow("mime.value.invalid");
+        expect(() => Mime.fromString("/subtype")).toThrow("mime.value.invalid");
+        expect(() => Mime.fromString("type/")).toThrow("mime.value.invalid");
+        expect(() => Mime.fromString("no-slash")).toThrow("mime.value.invalid");
+    });
+    test("isSatisfiedBy - happy path", () => {
+        const textPlain = Mime.fromString("text/plain");
+        const textHtml = Mime.fromString("text/html");
+        const applicationJson = Mime.fromString("application/json");
+        const textWildcard = Mime.fromString("text/*");
+        const anyWildcard = Mime.fromString("*/*");
+        expect(textPlain.isSatisfiedBy(textHtml)).toEqual(false);
+        expect(textPlain.isSatisfiedBy(applicationJson)).toEqual(false);
+        expect(textPlain.isSatisfiedBy(textPlain)).toEqual(true);
+        expect(textWildcard.isSatisfiedBy(textPlain)).toEqual(true);
+        expect(anyWildcard.isSatisfiedBy(textPlain)).toEqual(true);
+    });
+    test("isSatisfiedBy - failures", () => {
+        const textPlain = Mime.fromString("text/plain");
+        const imageWildcard = Mime.fromString("image/*");
+        const wildcardPlain = Mime.fromString("*/plain");
+        const anyWildcard = Mime.fromString("*/*");
+        expect(textPlain.isSatisfiedBy(imageWildcard)).toEqual(false);
+        expect(textPlain.isSatisfiedBy(wildcardPlain)).toEqual(false);
+        expect(textPlain.isSatisfiedBy(anyWildcard)).toEqual(false);
+        expect(imageWildcard.isSatisfiedBy(wildcardPlain)).toEqual(false);
+        expect(imageWildcard.isSatisfiedBy(anyWildcard)).toEqual(false);
+        expect(wildcardPlain.isSatisfiedBy(anyWildcard)).toEqual(false);
+    });
+    test("toString", () => {
+        expect(Mime.fromString("text/plain").toString()).toEqual("text/plain");
+    });
+    test("toJSON", () => {
+        expect(Mime.fromString("text/plain").toJSON()).toEqual({ type: "text", subtype: "plain" });
+    });
+});

package/dist/tests/mimes.test.d.ts

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

package/dist/tests/mimes.test.js

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Extension } from "../src/extension.vo";
+import { Mimes } from "../src/mimes";
+describe("Mimes", () => {
+    test("map", () => {
+        expect(Mimes.csv.mime.toString()).toEqual("text/csv");
+        expect(Mimes.csv.extensions).toEqual([v.parse(Extension, "csv")]);
+        expect(Mimes.jpg.mime.toString()).toEqual("image/jpeg");
+        expect(Mimes.jpg.extensions).toEqual([v.parse(Extension, "jpg"), v.parse(Extension, "jpeg")]);
+        expect(Mimes.markdown.mime.toString()).toEqual("text/markdown");
+        expect(Mimes.markdown.extensions).toEqual([v.parse(Extension, "md")]);
+        expect(Mimes.mp4.mime.toString()).toEqual("video/mp4");
+        expect(Mimes.mp4.extensions).toEqual([v.parse(Extension, "mp4")]);
+        expect(Mimes.pdf.mime.toString()).toEqual("application/pdf");
+        expect(Mimes.pdf.extensions).toEqual([v.parse(Extension, "pdf")]);
+        expect(Mimes.png.mime.toString()).toEqual("image/png");
+        expect(Mimes.png.extensions).toEqual([v.parse(Extension, "png")]);
+        expect(Mimes.text.mime.toString()).toEqual("text/plain");
+        expect(Mimes.text.extensions).toEqual([v.parse(Extension, "txt")]);
+        expect(Mimes.webp.mime.toString()).toEqual("image/webp");
+        expect(Mimes.webp.extensions).toEqual([v.parse(Extension, "webp")]);
+        expect(Mimes.wav.mime.toString()).toEqual("audio/wav");
+        expect(Mimes.wav.extensions).toEqual([v.parse(Extension, "wav")]);
+        expect(Mimes.zip.mime.toString()).toEqual("application/zip");
+        expect(Mimes.zip.extensions).toEqual([v.parse(Extension, "zip")]);
+    });
+});

package/dist/tests/min-max-scaler.service.test.d.ts

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

package/dist/tests/min-max-scaler.service.test.js

@@ -0,0 +1,116 @@
+import { describe, expect, test } from "bun:test";
+import { MinMaxScaler } from "../src/min-max-scaler.service";
+describe("MinMaxScaler", () => {
+    test("scale - default bound", () => {
+        const scaler = new MinMaxScaler({ min: 0, max: 100 });
+        const original = 50;
+        const scaled = 0.5;
+        const result = scaler.scale(original);
+        expect(result).toEqual({ scaled, original, isMin: false, isMax: false });
+        expect(scaler.descale(result.scaled)).toEqual({
+            isLowerBound: false,
+            isUpperBound: false,
+            original,
+            scaled,
+        });
+    });
+    test("scale - custom bound", () => {
+        const scaler = new MinMaxScaler({ min: 0, max: 100, bound: { lower: 10, upper: 20 } });
+        const original = 50;
+        const scaled = 15;
+        const result = scaler.scale(original);
+        expect(result).toEqual({ original, scaled, isMin: false, isMax: false });
+        expect(scaler.descale(result.scaled)).toEqual({
+            isLowerBound: false,
+            isUpperBound: false,
+            original,
+            scaled,
+        });
+    });
+    test("scale - custom bound - 2 decimals rounding", () => {
+        const scaler = new MinMaxScaler({ min: 0, max: 27, bound: { lower: 0, upper: 9 } });
+        const original = 5;
+        const scaled = 1.67;
+        const result = scaler.scale(original);
+        expect(result).toEqual({ scaled, original, isMin: false, isMax: false });
+        expect(scaler.descale(result.scaled)).toEqual({
+            isLowerBound: false,
+            isUpperBound: false,
+            original: 5.01,
+            scaled,
+        });
+    });
+    test("scale - minimum value", () => {
+        const scaler = new MinMaxScaler({ min: 0, max: 100, bound: { lower: 10, upper: 20 } });
+        const original = 0;
+        const scaled = 10;
+        const result = scaler.scale(original);
+        expect(result).toEqual({ scaled, original, isMin: true, isMax: false });
+        expect(scaler.descale(result.scaled)).toEqual({
+            isLowerBound: true,
+            isUpperBound: false,
+            original,
+            scaled,
+        });
+    });
+    test("scale - maximum value", () => {
+        const scaler = new MinMaxScaler({ min: 0, max: 100, bound: { lower: 10, upper: 20 } });
+        const original = 100;
+        const scaled = 20;
+        const result = scaler.scale(original);
+        expect(result).toEqual({ scaled, original, isMin: false, isMax: true });
+        expect(scaler.descale(result.scaled)).toEqual({
+            isLowerBound: false,
+            isUpperBound: true,
+            original,
+            scaled,
+        });
+    });
+    test("scale - min equals to max", () => {
+        const scaler = new MinMaxScaler({ min: 100, max: 100, bound: { lower: 10, upper: 20 } });
+        const original = 100;
+        const scaled = 15;
+        const result = scaler.scale(original);
+        expect(result).toEqual({ scaled, original, isMin: true, isMax: true });
+        expect(scaler.descale(result.scaled)).toEqual({
+            isLowerBound: false,
+            isUpperBound: false,
+            original,
+            scaled,
+        });
+    });
+    test("scale - non-zero min value", () => {
+        const scaler = new MinMaxScaler({ min: 50, max: 100, bound: { lower: 0, upper: 10 } });
+        const result = scaler.scale(75);
+        expect(result.scaled).toBe(5);
+        expect(result.original).toBe(75);
+    });
+    test("scale - throws for invalid min/max config", () => {
+        expect(() => new MinMaxScaler({ min: 100, max: 0, bound: { lower: 0, upper: 10 } })).toThrow("min.max.scaler.invalid.min.max");
+    });
+    test("scale - throws for invalid bound config", () => {
+        expect(() => new MinMaxScaler({ min: 0, max: 10, bound: { lower: 20, upper: 10 } })).toThrow("min.max.scaler.invalid.bound");
+        expect(() => new MinMaxScaler({ min: 0, max: 10, bound: { lower: 10, upper: 10 } })).toThrow("min.max.scaler.invalid.bound");
+    });
+    test("scale - throws when value is bigger than configured range", () => {
+        expect(() => new MinMaxScaler({ min: 0, max: 10 }).scale(15)).toThrow("min.max.scaler.value.out.of.range");
+    });
+    test("scale - throws when value is less than configured range", () => {
+        const scaler = new MinMaxScaler({ min: 10, max: 20 });
+        expect(() => scaler.scale(5)).toThrow("min.max.scaler.value.out.of.range");
+    });
+    test("descale - throws when scaled value is out of bounds", () => {
+        const scaler = new MinMaxScaler({ min: 0, max: 100, bound: { lower: 10, upper: 20 } });
+        expect(() => scaler.descale(5)).toThrow("min.max.scaler.scaled.out.of.bounds");
+        expect(() => scaler.descale(25)).toThrow("min.max.scaler.scaled.out.of.bounds");
+    });
+    test("getMinMax - happy path", () => {
+        expect(MinMaxScaler.getMinMax([10, 5, 20, 15, 30])).toEqual({ min: 5, max: 30 });
+    });
+    test("getMinMax - empty array", () => {
+        expect(() => MinMaxScaler.getMinMax([])).toThrow("min.max.scaler.empty.array");
+    });
+    test("getMinMax - single-value arrays", () => {
+        expect(MinMaxScaler.getMinMax([10])).toEqual({ min: 10, max: 10 });
+    });
+});

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

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

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

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

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

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

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

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Minute } from "../src/minute.vo";
+import { MinuteValue } from "../src/minute-value.vo";
+import * as mocks from "./mocks";
+const FIVE = Minute.fromValue(5);
+const TEN = Minute.fromValue(10);
+const thirteenth = v.parse(MinuteValue, 13);
+describe("Minute", () => {
+    test("happy path", () => {
+        expect(FIVE.get()).toEqual(v.parse(MinuteValue, 5));
+    });
+    test("throws for invalid minute values", () => {
+        expect(() => Minute.fromValue(12.5)).toThrow("minute.value.type");
+        expect(() => Minute.fromValue(-1)).toThrow("minute.value.invalid");
+        expect(() => Minute.fromValue(60)).toThrow("minute.value.invalid");
+    });
+    test("fromValueSafe", () => {
+        expect(Minute.fromValueSafe(thirteenth).get()).toEqual(thirteenth);
+    });
+    test("fromTimestamp", () => {
+        expect(Minute.fromTimestamp(mocks.TIME_ZERO).get()).toEqual(thirteenth);
+    });
+    test("fromTimestampValue", () => {
+        expect(Minute.fromTimestampValue(mocks.TIME_ZERO.ms).get()).toEqual(thirteenth);
+    });
+    test("zero", () => {
+        expect(Minute.zero().get()).toEqual(v.parse(MinuteValue, 0));
+    });
+    test("max", () => {
+        expect(Minute.max().get()).toEqual(v.parse(MinuteValue, 59));
+    });
+    test("get", () => {
+        expect(FIVE.get()).toEqual(v.parse(MinuteValue, 5));
+    });
+    test("equals", () => {
+        expect(FIVE.equals(FIVE)).toEqual(true);
+        expect(FIVE.equals(TEN)).toEqual(false);
+    });
+    test("isBefore", () => {
+        expect(FIVE.isBefore(TEN)).toEqual(true);
+        expect(TEN.isBefore(FIVE)).toEqual(false);
+        expect(TEN.isBefore(TEN)).toEqual(false);
+    });
+    test("isAfter", () => {
+        expect(TEN.isAfter(FIVE)).toEqual(true);
+        expect(FIVE.isAfter(TEN)).toEqual(false);
+        expect(FIVE.isAfter(FIVE)).toEqual(false);
+    });
+    test("list", () => {
+        const list = Minute.list();
+        expect(list.length).toEqual(60);
+        expect(list[0].get()).toEqual(v.parse(MinuteValue, 0));
+        expect(list[59].get()).toEqual(v.parse(MinuteValue, 59));
+    });
+    test("toString", () => {
+        expect(FIVE.toString()).toEqual("05");
+        expect(TEN.toString()).toEqual("10");
+    });
+    test("toJSON", () => {
+        expect(FIVE.toJSON()).toEqual(v.parse(MinuteValue, 5));
+        expect(TEN.toJSON()).toEqual(v.parse(MinuteValue, 10));
+    });
+});

package/dist/tests/mocks.d.ts

@@ -0,0 +1,6 @@
+import { Duration } from "../src/duration.service";
+import { Timestamp } from "../src/timestamp.vo";
+export declare const TIME_ZERO: Timestamp;
+export declare const TIME_ZERO_DATE_LIKE = "2023-11-14";
+export declare const TIME_ZERO_DATE: Date;
+export declare const epsilon: Duration;

package/dist/tests/mocks.js

@@ -0,0 +1,7 @@
+import { Duration } from "../src/duration.service";
+import { Timestamp } from "../src/timestamp.vo";
+// Tue Nov 14 2023 22:13:20 GMT+0000
+export const TIME_ZERO = Timestamp.fromNumber(1700000000000);
+export const TIME_ZERO_DATE_LIKE = "2023-11-14";
+export const TIME_ZERO_DATE = new Date(TIME_ZERO_DATE_LIKE);
+export const epsilon = Duration.Ms(1);

package/dist/tests/money-amount.vo.test.d.ts

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

package/dist/tests/money-amount.vo.test.js

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

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

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

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

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { DivisionFactor } from "../src/division-factor.vo";
+import { Money } from "../src/money.vo";
+import { MoneyAmount } from "../src/money-amount.vo";
+import { MultiplicationFactor } from "../src/multiplication-factor.vo";
+import { RoundingDownStrategy } from "../src/rounding-down.strategy";
+import { RoundingUpStrategy } from "../src/rounding-up.strategy";
+const roundUp = new RoundingUpStrategy();
+const roundDown = new RoundingDownStrategy();
+const divisor = v.parse(DivisionFactor, 2.5);
+const multiplier = v.parse(MultiplicationFactor, 1.5);
+describe("Money", () => {
+    test("fromAmount", () => {
+        expect(Money.fromAmount(0).getAmount()).toEqual(v.parse(MoneyAmount, 0));
+        expect(Money.fromAmount(100).getAmount()).toEqual(v.parse(MoneyAmount, 100));
+    });
+    test("fromAmount - invalid input", () => {
+        expect(() => Money.fromAmount(100.5)).toThrow("money.amount.type");
+    });
+    test("fromAmountSafe", () => {
+        expect(Money.fromAmountSafe(v.parse(MoneyAmount, 0)).getAmount()).toEqual(v.parse(MoneyAmount, 0));
+        expect(Money.fromAmountSafe(v.parse(MoneyAmount, 100)).getAmount()).toEqual(v.parse(MoneyAmount, 100));
+    });
+    test("add", () => {
+        expect(Money.fromAmount(100).add(Money.fromAmount(0)).getAmount()).toEqual(v.parse(MoneyAmount, 100));
+        expect(Money.fromAmount(15).add(Money.fromAmount(10)).getAmount()).toEqual(v.parse(MoneyAmount, 25));
+    });
+    test("multiply - integer factor", () => {
+        expect(Money.fromAmount(100).multiply(v.parse(MultiplicationFactor, 5)).getAmount()).toEqual(v.parse(MoneyAmount, 500));
+    });
+    test("multiply - float factor - default round-to-nearest", () => {
+        expect(Money.fromAmount(99).multiply(multiplier).getAmount()).toEqual(v.parse(MoneyAmount, 149));
+    });
+    test("multiply - float factor - round-up", () => {
+        expect(Money.fromAmount(99).multiply(multiplier, roundUp).getAmount()).toEqual(v.parse(MoneyAmount, 149));
+    });
+    test("multiply - float factor - round-down", () => {
+        expect(Money.fromAmount(99).multiply(multiplier, roundDown).getAmount()).toEqual(v.parse(MoneyAmount, 148));
+    });
+    test("subtract - result more than zero", () => {
+        expect(Money.fromAmount(100).subtract(Money.fromAmount(20)).getAmount()).toEqual(v.parse(MoneyAmount, 80));
+    });
+    test("subtract - result zero", () => {
+        expect(Money.fromAmount(100).subtract(Money.fromAmount(100)).isZero()).toEqual(true);
+    });
+    test("subtract - result less than zero", () => {
+        expect(() => Money.fromAmount(100).subtract(Money.fromAmount(120)).getAmount()).toThrow("money.subtract.result.less.than.zero");
+    });
+    test("divide - float factor - default round-to-nearest", () => {
+        expect(Money.fromAmount(98).divide(divisor).getAmount()).toEqual(v.parse(MoneyAmount, 39));
+    });
+    test("divide - float factor - round-up", () => {
+        expect(Money.fromAmount(98).divide(divisor, roundUp).getAmount()).toEqual(v.parse(MoneyAmount, 40));
+    });
+    test("divide - float factor - round-down", () => {
+        expect(Money.fromAmount(98).divide(divisor, roundDown).getAmount()).toEqual(v.parse(MoneyAmount, 39));
+    });
+    test("equals", () => {
+        const oneHundred = Money.fromAmount(100);
+        const twoHundred = Money.fromAmount(200);
+        expect(oneHundred.equals(oneHundred)).toEqual(true);
+        expect(oneHundred.equals(twoHundred)).toEqual(false);
+    });
+    test("isGreaterThan", () => {
+        const oneHundred = Money.fromAmount(100);
+        const twoHundred = Money.fromAmount(200);
+        expect(oneHundred.isGreaterThan(oneHundred)).toEqual(false);
+        expect(twoHundred.isGreaterThan(oneHundred)).toEqual(true);
+    });
+    test("isLessThan", () => {
+        const oneHundred = Money.fromAmount(100);
+        const twoHundred = Money.fromAmount(200);
+        expect(oneHundred.isLessThan(oneHundred)).toEqual(false);
+        expect(oneHundred.isLessThan(twoHundred)).toEqual(true);
+    });
+    test("isZero", () => {
+        expect(Money.fromAmount(0).isZero()).toEqual(true);
+        expect(Money.fromAmount(1).isZero()).toEqual(false);
+    });
+    test("zero", () => {
+        expect(Money.zero()).toEqual(Money.fromAmountSafe(v.parse(MoneyAmount, 0)));
+    });
+    test("toString", () => {
+        expect(Money.fromAmount(5).toString()).toEqual("5");
+    });
+    test("toJSON", () => {
+        expect(Money.fromAmount(5).toJSON()).toEqual(5);
+    });
+});

package/dist/tests/month-iso-id.vo.test.d.ts

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

package/dist/tests/month-iso-id.vo.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { MonthIsoId } from "../src/month-iso-id.vo";
+describe("MonthIsoId", () => {
+    test("happy path", () => {
+        const valid = ["0000-01", "1970-01", "1999-12", "2024-02", "2025-10", "9999-12"];
+        for (const value of valid) {
+            expect(v.safeParse(MonthIsoId, value).success).toEqual(true);
+        }
+    });
+    test("rejects prefix", () => {
+        expect(() => v.parse(MonthIsoId, "prefix2000-01")).toThrow("month.iso.id.bad.chars");
+    });
+    test("rejects suffix", () => {
+        expect(() => v.parse(MonthIsoId, "2000-01suffix")).toThrow("month.iso.id.bad.chars");
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(MonthIsoId, "")).toThrow("month.iso.id.bad.chars");
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(MonthIsoId, null)).toThrow("month.iso.id.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(MonthIsoId, 123)).toThrow("month.iso.id.type");
+    });
+    test("rejects months < 1 and > 12", () => {
+        expect(() => v.parse(MonthIsoId, "2023-00")).toThrow("month.iso.id.invalid");
+        expect(() => v.parse(MonthIsoId, "2023-13")).toThrow("month.iso.id.invalid");
+    });
+    test("rejects structurally invalid strings", () => {
+        const invalid = ["2023-1", "2023/01", "23-01"];
+        for (const value of invalid) {
+            expect(() => v.parse(MonthIsoId, value)).toThrow("month.iso.id.bad.chars");
+        }
+    });
+});

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

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

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

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test";
+import { endOfMonth, startOfMonth } from "date-fns";
+import * as v from "valibot";
+import { Duration } from "../src/duration.service";
+import { Integer } from "../src/integer.vo";
+import { Month } from "../src/month.vo";
+import { MonthIsoId } from "../src/month-iso-id.vo";
+import { Timestamp } from "../src/timestamp.vo";
+import * as mocks from "./mocks";
+const november = v.parse(MonthIsoId, "2023-11");
+describe("Month", () => {
+    test("happy path", () => {
+        const month = Month.fromTimestamp(mocks.TIME_ZERO);
+        expect(month.getStart()).toEqual(Timestamp.fromNumber(startOfMonth(mocks.TIME_ZERO.ms).getTime()));
+        expect(month.getEnd()).toEqual(Timestamp.fromNumber(endOfMonth(mocks.TIME_ZERO.ms).getTime()));
+        expect(month.toIsoId()).toEqual(november);
+        expect(month.contains(mocks.TIME_ZERO)).toEqual(true);
+    });
+    test("happy path - near year boundary", () => {
+        const timestamp = Timestamp.fromDateLike("2025-12-31");
+        const month = Month.fromTimestamp(timestamp);
+        expect(month.getStart()).toEqual(Timestamp.fromNumber(startOfMonth(timestamp.ms).getTime()));
+        expect(month.getEnd()).toEqual(Timestamp.fromNumber(endOfMonth(timestamp.ms).getTime()));
+        expect(month.toIsoId()).toEqual(v.parse(MonthIsoId, "2025-12"));
+    });
+    test("fromNow", () => {
+        expect(Month.fromNow(mocks.TIME_ZERO).toIsoId()).toEqual(november);
+    });
+    test("fromTimestamp", () => {
+        expect(Month.fromTimestamp(mocks.TIME_ZERO).toIsoId()).toEqual(november);
+    });
+    test("fromTimestampValue", () => {
+        expect(Month.fromTimestampValue(mocks.TIME_ZERO.ms).toIsoId()).toEqual(november);
+    });
+    test("fromIsoId", () => {
+        expect(Month.fromIsoId(november).toIsoId()).toEqual(november);
+    });
+    test("next", () => {
+        expect(Month.fromTimestamp(mocks.TIME_ZERO).next().toIsoId()).toEqual(v.parse(MonthIsoId, "2023-12"));
+    });
+    test("previous", () => {
+        expect(Month.fromTimestamp(mocks.TIME_ZERO).previous().toIsoId()).toEqual(v.parse(MonthIsoId, "2023-10"));
+    });
+    test("shift", () => {
+        expect(Month.fromTimestamp(mocks.TIME_ZERO).shift(v.parse(Integer, 2)).toIsoId()).toEqual(v.parse(MonthIsoId, "2024-01"));
+        expect(Month.fromTimestamp(mocks.TIME_ZERO).shift(v.parse(Integer, -2)).toIsoId()).toEqual(v.parse(MonthIsoId, "2023-09"));
+    });
+    test("round-trips", () => {
+        const months = ["1970-01", "1999-12", "2024-02", "2025-12", "2026-01"].map((value) => v.parse(MonthIsoId, value));
+        for (const value of months) {
+            expect(Month.fromIsoId(v.parse(MonthIsoId, value)).toIsoId()).toEqual(value);
+        }
+    });
+    test("contains", () => {
+        const month = Month.fromTimestamp(mocks.TIME_ZERO);
+        expect(month.contains(month.getStart().subtract(Duration.Ms(1)))).toEqual(false);
+        expect(month.contains(month.getEnd().add(Duration.Ms(1)))).toEqual(false);
+    });
+    test("toString", () => {
+        expect(Month.fromIsoId(november).toString()).toEqual(november);
+    });
+    test("toJSON", () => {
+        expect(Month.fromIsoId(november).toJSON()).toEqual({ start: 1698796800000, end: 1701388799999 });
+    });
+});

package/dist/tests/multiplication-factor.vo.test.d.ts

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

package/dist/tests/multiplication-factor.vo.test.js

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

package/dist/tests/noop.test.d.ts

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

package/dist/tests/noop.test.js

@@ -0,0 +1,12 @@
+import { describe, expect, test } from "bun:test";
+import { anoop, noop } from "../src/noop.service";
+describe("noop", () => {
+    test("does nothing", () => {
+        expect(noop()).toEqual(undefined);
+    });
+});
+describe("anoop", () => {
+    test("does nothing", async () => {
+        expect(await anoop()).toEqual(undefined);
+    });
+});

package/dist/tests/object-key.vo.test.d.ts

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

package/dist/tests/object-key.vo.test.js

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { ObjectKey } from "../src/object-key.vo";
+describe("ObjectKey", () => {
+    test("happy path", () => {
+        const valid = [
+            "avatar.webp",
+            "users/123/avatar.webp",
+            "users/u-1/avatar.webp",
+            "users/abc_def/avatar-1.2_3.webp",
+            "env.prod/users/a_b-c/avatar.webp",
+        ];
+        for (const key of valid) {
+            expect(v.safeParse(ObjectKey, key).success).toEqual(true);
+        }
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(ObjectKey, "")).toThrow("object.key.empty");
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(ObjectKey, null)).toThrow("object.key.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(ObjectKey, 123)).toThrow("object.key.type");
+    });
+    test("rejects too long", () => {
+        expect(() => v.parse(ObjectKey, "a".repeat(257))).toThrow("object.key.too.long");
+    });
+    test("rejects leading slash", () => {
+        expect(() => v.parse(ObjectKey, "/users/u/avatar.webp")).toThrow("object.key.leading.slash");
+    });
+    test("rejects backslashes", () => {
+        expect(() => v.parse(ObjectKey, "users\\u\\avatar.webP")).toThrow("object.key.bad.chars");
+    });
+    test("rejects control characters", () => {
+        expect(() => v.parse(ObjectKey, "users/\u0000/avatar.webp")).toThrow("object.key.bad.chars");
+    });
+    test("rejects trailing slash", () => {
+        expect(() => v.parse(ObjectKey, "users/u/")).toThrow("object.key.bad.chars");
+    });
+    test("rejects single dot segments", () => {
+        expect(() => v.parse(ObjectKey, "users/./avatar.webp")).toThrow("object.key.dot.segments");
+    });
+    test("rejects double dot segments", () => {
+        expect(() => v.parse(ObjectKey, "users/../avatar.webp")).toThrow("object.key.dot.segments");
+    });
+    test("rejects uppercase letters", () => {
+        expect(() => v.parse(ObjectKey, "Users/u/avatar.webp")).toThrow("object.key.bad.chars");
+    });
+    test("rejects empty segments", () => {
+        expect(() => v.parse(ObjectKey, "users//avatar.webp")).toThrow("object.key.bad.chars");
+    });
+    test("rejects spaces in segments", () => {
+        expect(() => v.parse(ObjectKey, "users/user id/avatar.webp")).toThrow("object.key.bad.chars");
+    });
+});

package/dist/tests/outlier-detector.service.test.d.ts

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