@bgord/tools 1.4.0 → 1.4.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/tests/noop.test.js

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

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

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

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

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

package/dist/tests/outlier-detector.service.test.js

@@ -1,35 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { OutlierDetector } from "../src/outlier-detector.service";
-describe("Outlier detector", () => {
-    test("throws for empty values array", () => {
-        expect(() => new OutlierDetector([], 2)).toThrow("outlier.detector.not.enough.values");
-    });
-    test("throws for one value array", () => {
-        expect(() => new OutlierDetector([1], 2)).toThrow("outlier.detector.not.enough.values");
-    });
-    test("works for three values", () => {
-        const values = [1, 3];
-        const detector = new OutlierDetector(values, 2);
-        expect(values.filter((value) => detector.isInlier(value))).toEqual([1, 3]);
-    });
-    test("works for three values", () => {
-        const values = [1, 3, 10];
-        const detector = new OutlierDetector(values, 2);
-        expect(values.filter((value) => detector.isInlier(value))).toEqual([1, 3, 10]);
-    });
-    test("works for a set of data", () => {
-        const values = [1, 3, 1, 3, 1, 3, 10];
-        const detector = new OutlierDetector(values, 2);
-        expect(values.filter((value) => detector.isInlier(value))).toEqual([1, 3, 1, 3, 1, 3]);
-        expect(detector.isInlier(10)).toEqual(false);
-    });
-    test("works for all zeros", () => {
-        const values = [0, 0, 0, 0];
-        const detector = new OutlierDetector(values, 2);
-        expect(values.filter((value) => detector.isInlier(value))).toEqual([]);
-    });
-    test("works score equal to threshold ", () => {
-        const detector = new OutlierDetector([10, 30], 0);
-        expect(detector.isInlier(20)).toEqual(true);
-    });
-});

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

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

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

@@ -1,32 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import * as v from "valibot";
-import { PackageVersionSchema } from "../src/package-version-schema.vo";
-describe("PackageVersionSchema", () => {
-    test("happy path", () => {
-        const valid = ["v0.0.0", "v1.10.0", "v9999.9999.9999"];
-        for (const value of valid) {
-            expect(v.safeParse(PackageVersionSchema, value).success).toEqual(true);
-        }
-    });
-    test("rejects prefix", () => {
-        expect(() => v.parse(PackageVersionSchema, " v1.0.0")).toThrow("package.version.schema.bad.chars");
-    });
-    test("rejects suffix", () => {
-        expect(() => v.parse(PackageVersionSchema, "v1.0.0 ")).toThrow("package.version.schema.bad.chars");
-    });
-    test("rejects empty value", () => {
-        expect(() => v.parse(PackageVersionSchema, "")).toThrow("package.version.schema.bad.chars");
-    });
-    test("rejects non-string - null", () => {
-        expect(() => v.parse(PackageVersionSchema, null)).toThrow("package.version.schema.error");
-    });
-    test("rejects non-string - number", () => {
-        expect(() => v.parse(PackageVersionSchema, 123)).toThrow("package.version.schema.error");
-    });
-    test("rejects invalid values", () => {
-        const invalid = ["v", "v1", "v1.0", "0.0.0", "vx.0.0", "v1.x.0", "v1.1.x"];
-        for (const value of invalid) {
-            expect(() => v.parse(PackageVersionSchema, value)).toThrow("package.version.schema.bad.chars");
-        }
-    });
-});

package/dist/tests/package-version.vo.test.d.ts

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