@bgord/tools 1.3.24 → 1.4.0

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

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

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

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

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

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

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

@@ -0,0 +1,138 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { PackageVersion } from "../src/package-version.vo";
+import { PackageVersionSchema } from "../src/package-version-schema.vo";
+describe("PackageVersion", () => {
+    test("fromVersionString", () => {
+        const version = PackageVersion.fromVersionString("v1.2.3");
+        expect(version.toJSON()).toEqual({ major: 1, minor: 2, patch: 3 });
+    });
+    test("fromVersionStringSafe", () => {
+        const version = PackageVersion.fromVersionStringSafe(v.parse(PackageVersionSchema, "v1.2.3"));
+        expect(version.toJSON()).toEqual({ major: 1, minor: 2, patch: 3 });
+    });
+    test("equals - true", () => {
+        const left = PackageVersion.fromString("1.2.3");
+        const right = PackageVersion.fromString("1.2.3");
+        expect(left.equals(right)).toEqual(true);
+    });
+    test("equals - false - major mismatch", () => {
+        const left = PackageVersion.fromString("2.1.1");
+        const right = PackageVersion.fromString("1.1.1");
+        expect(left.equals(right)).toEqual(false);
+    });
+    test("equals - false - minor mismatch", () => {
+        const left = PackageVersion.fromString("1.2.1");
+        const right = PackageVersion.fromString("1.1.1");
+        expect(left.equals(right)).toEqual(false);
+    });
+    test("equals - false - patch mismatch", () => {
+        const left = PackageVersion.fromString("1.1.2");
+        const right = PackageVersion.fromString("1.1.1");
+        expect(left.equals(right)).toEqual(false);
+    });
+    test("greater - major", () => {
+        const left = PackageVersion.fromString("2.0.0");
+        const right = PackageVersion.fromString("1.9.9");
+        expect(left.isGreaterThan(right)).toEqual(true);
+        expect(right.isGreaterThan(left)).toEqual(false);
+    });
+    test("greater - minor", () => {
+        const left = PackageVersion.fromString("1.2.0");
+        const right = PackageVersion.fromString("1.1.9");
+        expect(left.isGreaterThan(right)).toEqual(true);
+        expect(right.isGreaterThan(left)).toEqual(false);
+    });
+    test("greater - patch", () => {
+        const left = PackageVersion.fromString("1.1.2");
+        const right = PackageVersion.fromString("1.1.1");
+        expect(left.isGreaterThan(right)).toEqual(true);
+        expect(right.isGreaterThan(left)).toEqual(false);
+    });
+    test("greater - false - equal", () => {
+        const left = PackageVersion.fromString("1.2.3");
+        const right = PackageVersion.fromString("1.2.3");
+        expect(left.isGreaterThan(right)).toEqual(false);
+    });
+    test("greater - false - major smaller", () => {
+        const left = PackageVersion.fromString("1.0.0");
+        const right = PackageVersion.fromString("2.0.0");
+        expect(left.isGreaterThan(right)).toEqual(false);
+    });
+    test("greater - false - minor smaller", () => {
+        const left = PackageVersion.fromString("1.1.0");
+        const right = PackageVersion.fromString("1.2.0");
+        expect(left.isGreaterThan(right)).toEqual(false);
+    });
+    test("greaterOrEqual - equal", () => {
+        const left = PackageVersion.fromString("1.2.3");
+        const right = PackageVersion.fromString("1.2.3");
+        expect(left.isGreaterThanOrEqual(right)).toEqual(true);
+    });
+    test("greaterOrEqual - greater", () => {
+        const left = PackageVersion.fromString("1.2.4");
+        const right = PackageVersion.fromString("1.2.3");
+        expect(left.isGreaterThanOrEqual(right)).toEqual(true);
+    });
+    test("greaterOrEqual - false - smaller", () => {
+        const left = PackageVersion.fromString("1.2.2");
+        const right = PackageVersion.fromString("1.2.3");
+        expect(left.isGreaterThanOrEqual(right)).toEqual(false);
+    });
+    test("smaller - major", () => {
+        const left = PackageVersion.fromString("1.0.0");
+        const right = PackageVersion.fromString("2.0.0");
+        expect(left.isSmallerThan(right)).toEqual(true);
+        expect(right.isSmallerThan(left)).toEqual(false);
+    });
+    test("smaller - minor", () => {
+        const left = PackageVersion.fromString("1.1.0");
+        const right = PackageVersion.fromString("1.2.0");
+        expect(left.isSmallerThan(right)).toEqual(true);
+        expect(right.isSmallerThan(left)).toEqual(false);
+    });
+    test("smaller - patch", () => {
+        const left = PackageVersion.fromString("1.1.1");
+        const right = PackageVersion.fromString("1.1.2");
+        expect(left.isSmallerThan(right)).toEqual(true);
+        expect(right.isSmallerThan(left)).toEqual(false);
+    });
+    test("smaller - false - equal", () => {
+        const left = PackageVersion.fromString("1.2.3");
+        const right = PackageVersion.fromString("1.2.3");
+        expect(left.isSmallerThan(right)).toEqual(false);
+    });
+    test("smaller - false - major greater", () => {
+        const left = PackageVersion.fromString("2.0.0");
+        const right = PackageVersion.fromString("1.0.0");
+        expect(left.isSmallerThan(right)).toEqual(false);
+    });
+    test("smaller - false - minor greater", () => {
+        const left = PackageVersion.fromString("1.2.0");
+        const right = PackageVersion.fromString("1.1.0");
+        expect(left.isSmallerThan(right)).toEqual(false);
+    });
+    test("smallerOrEqual - equal", () => {
+        const left = PackageVersion.fromString("1.2.3");
+        const right = PackageVersion.fromString("1.2.3");
+        expect(left.isSmallerThanOrEqual(right)).toEqual(true);
+    });
+    test("smallerOrEqual - smaller", () => {
+        const left = PackageVersion.fromString("1.2.2");
+        const right = PackageVersion.fromString("1.2.3");
+        expect(left.isSmallerThanOrEqual(right)).toEqual(true);
+    });
+    test("smallerOrEqual - false - greater", () => {
+        const left = PackageVersion.fromString("1.2.4");
+        const right = PackageVersion.fromString("1.2.3");
+        expect(left.isSmallerThanOrEqual(right)).toEqual(false);
+    });
+    test("toString", () => {
+        const version = PackageVersion.fromString("3.4.5");
+        expect(version.toString()).toEqual("3.4.5");
+    });
+    test("toJSON", () => {
+        const version = PackageVersion.fromString("3.4.5");
+        expect(version.toJSON()).toEqual({ major: 3, minor: 4, patch: 5 });
+    });
+});

package/dist/tests/pagination-page.vo.test.d.ts

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

package/dist/tests/pagination-page.vo.test.js

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Page } from "../src/pagination-page.vo";
+describe("PaginationPage", () => {
+    test("happy path", () => {
+        expect(v.safeParse(Page, 0).success).toEqual(true);
+        expect(v.safeParse(Page, 1).success).toEqual(true);
+        expect(v.safeParse(Page, 5).success).toEqual(true);
+        expect(v.safeParse(Page, 15).success).toEqual(true);
+    });
+    test("transforms null to 1", () => {
+        expect(v.safeParse(Page, null)).toMatchObject({ success: true, output: 1 });
+    });
+    test("transforms undefined to 1", () => {
+        expect(v.safeParse(Page, undefined)).toMatchObject({ success: true, output: 1 });
+    });
+    test("transforms string to int", () => {
+        expect(v.safeParse(Page, "123")).toMatchObject({ success: true, output: 123 });
+    });
+    test("transforms negative numbers to 1", () => {
+        expect(v.safeParse(Page, -2)).toMatchObject({ success: true, output: 1 });
+    });
+    test("rejects fractions", () => {
+        expect(() => v.parse(Page, 1.5)).toThrow("pagination.page.type");
+    });
+});

package/dist/tests/pagination-skip.vo.test.d.ts

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

package/dist/tests/pagination-skip.vo.test.js

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

package/dist/tests/pagination-take.vo.test.d.ts

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

package/dist/tests/pagination-take.vo.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { Take } from "../src/pagination-take.vo";
+describe("PaginationTake", () => {
+    test("happy path", () => {
+        expect(v.safeParse(Take, 1).success).toEqual(true);
+        expect(v.safeParse(Take, 5).success).toEqual(true);
+        expect(v.safeParse(Take, 15).success).toEqual(true);
+    });
+    test("rejects non-number - null", () => {
+        expect(() => v.parse(Take, null)).toThrow("pagination.take.type");
+    });
+    test("rejects non-number - string", () => {
+        expect(() => v.parse(Take, "123")).toThrow("pagination.take.type");
+    });
+    test("rejects fractions", () => {
+        expect(() => v.parse(Take, 1.5)).toThrow("pagination.take.type");
+    });
+    test("rejects zero", () => {
+        expect(() => v.parse(Take, 0)).toThrow("pagination.take.invalid");
+    });
+    test("rejects negative numbers", () => {
+        expect(() => v.parse(Take, -1)).toThrow("pagination.take.invalid");
+    });
+});

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

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

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

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+import { Pagination } from "../src/pagination.service";
+describe("Pagination", () => {
+    test("page 0, take 10", () => {
+        const take = 10;
+        const parsed = Pagination.parse({ page: 0 }, take);
+        expect(parsed.page).toEqual(1);
+        expect(parsed.values.take).toEqual(take);
+        expect(parsed.values.skip).toEqual(0);
+    });
+    test("page 1, take 10", () => {
+        const take = 10;
+        const page = 1;
+        const parsed = Pagination.parse({ page }, take);
+        expect(parsed.page).toEqual(page);
+        expect(parsed.values.take).toEqual(take);
+        expect(parsed.values.skip).toEqual(0);
+    });
+    test("page 2, take 10", () => {
+        const take = 10;
+        const parsed = Pagination.parse({ page: 2 }, take);
+        expect(parsed.page).toEqual(2);
+        expect(parsed.values.take).toEqual(10);
+        expect(parsed.values.skip).toEqual(10);
+    });
+    test("page -1, take 10", () => {
+        const take = 10;
+        const parsed = Pagination.parse({ page: -1 }, take);
+        expect(parsed.page).toEqual(1);
+        expect(parsed.values.take).toEqual(take);
+        expect(parsed.values.skip).toEqual(0);
+    });
+    test("prepares paged metadata", () => {
+        const config = {
+            total: 50,
+            pagination: { values: { take: 10, skip: 10 }, page: 2 },
+            result: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+        };
+        const paged = Pagination.prepare(config);
+        expect(paged.result).toEqual([11, 12, 13, 14, 15, 16, 17, 18, 19, 20]);
+        expect(paged.meta.exhausted).toEqual(false);
+        expect(paged.meta.currentPage).toEqual(2);
+        expect(paged.meta.previousPage).toEqual(1);
+        expect(paged.meta.nextPage).toEqual(3);
+        expect(paged.meta.lastPage).toEqual(5);
+        expect(paged.meta.total).toEqual(50);
+    });
+    test("empty paged data", () => {
+        const emptyPaged = Pagination.empty;
+        expect(emptyPaged.result).toEqual([]);
+        expect(emptyPaged.meta.exhausted).toEqual(true);
+        expect(emptyPaged.meta.currentPage).toEqual(1);
+        expect(emptyPaged.meta.previousPage).toEqual(undefined);
+        expect(emptyPaged.meta.nextPage).toEqual(undefined);
+        expect(emptyPaged.meta.lastPage).toEqual(1);
+        expect(emptyPaged.meta.total).toEqual(0);
+    });
+    test("prepare - first page boundary", () => {
+        const config = {
+            total: 50,
+            pagination: { values: { take: 10, skip: 0 }, page: 1 },
+            result: [],
+        };
+        const paged = Pagination.prepare(config);
+        expect(paged.meta.currentPage).toEqual(1);
+        expect(paged.meta.previousPage).toBeUndefined();
+        expect(paged.meta.nextPage).toEqual(2);
+    });
+    test("prepare - last page boundary", () => {
+        const config = {
+            total: 50,
+            pagination: { values: { take: 10, skip: 40 }, page: 5 },
+            result: [],
+        };
+        const paged = Pagination.prepare(config);
+        expect(paged.meta.currentPage).toEqual(5);
+        expect(paged.meta.lastPage).toEqual(5);
+        expect(paged.meta.previousPage).toEqual(4);
+        expect(paged.meta.nextPage).toBeUndefined();
+    });
+    test("isExhausted", () => {
+        const config = { total: 25, pagination: { values: { take: 10, skip: 10 }, page: 3 } };
+        const exhausted = Pagination.isExhausted(config);
+        expect(exhausted).toEqual(true);
+    });
+    test("getFirstPage", () => {
+        const firstPage = Pagination.getFirstPage({ take: 15 });
+        expect(firstPage.page).toEqual(1);
+        expect(firstPage.values.take).toEqual(15);
+        expect(firstPage.values.skip).toEqual(0);
+    });
+});

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

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

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

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+import { Percentage } from "../src/percentage.service";
+import { RoundingUpStrategy } from "../src/rounding-up.strategy";
+describe("Percentage", () => {
+    test("happy path", () => {
+        expect(Percentage.of(0, 2)).toEqual(0);
+        expect(Percentage.of(1, 2)).toEqual(50);
+        expect(Percentage.of(1, 3)).toEqual(33);
+    });
+    test("throws - invalid denominator", () => {
+        expect(() => Percentage.of(2, 0)).toThrow("percentage.invalid.denominator");
+    });
+    test("non-default rounding", () => {
+        expect(Percentage.of(1, 3, new RoundingUpStrategy())).toEqual(34);
+    });
+});

package/dist/tests/population-standard-deviation.service.test.d.ts

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

package/dist/tests/population-standard-deviation.service.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test";
+import { PopulationStandardDeviation } from "../src/population-standard-deviation.service";
+describe("Standard deviation", () => {
+    test("throws - empty array", () => {
+        expect(() => PopulationStandardDeviation.calculate([])).toThrow("population.standard.deviation.not.enough.values");
+    });
+    test("throws - single value", () => {
+        expect(() => PopulationStandardDeviation.calculate([1])).toThrow("population.standard.deviation.not.enough.values");
+    });
+    test("two values", () => {
+        expect(PopulationStandardDeviation.calculate([1, 2])).toEqual(0.5);
+    });
+    test("three values", () => {
+        expect(PopulationStandardDeviation.calculate([1, 2, 3])).toEqual(0.82);
+    });
+    test("set of numbers", () => {
+        expect(PopulationStandardDeviation.calculate([2, 4, 4, 4, 5, 5, 7, 9])).toEqual(2);
+        expect(PopulationStandardDeviation.calculate([1, 1, 1, 1, 1, 1, 10])).toEqual(3.15);
+    });
+});

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

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

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

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import * as v from "valibot";
+import { QuarterIsoId } from "../src/quarter-iso-id.vo";
+describe("QuarterIsoId", () => {
+    test("happy path", () => {
+        const valid = ["0000-Q1", "1970-Q1", "1999-Q4", "2024-Q2", "2025-Q3", "9999-Q4"];
+        for (const value of valid) {
+            expect(v.safeParse(QuarterIsoId, value).success).toEqual(true);
+        }
+    });
+    test("rejects empty", () => {
+        expect(() => v.parse(QuarterIsoId, "")).toThrow("quarter.iso.id.bad.chars");
+    });
+    test("rejects non-string - null", () => {
+        expect(() => v.parse(QuarterIsoId, null)).toThrow("quarter.iso.id.type");
+    });
+    test("rejects non-string - number", () => {
+        expect(() => v.parse(QuarterIsoId, 123)).toThrow("quarter.iso.id.type");
+    });
+    test("rejects quarters < 1 and > 4", () => {
+        expect(() => v.parse(QuarterIsoId, "2025-Q0")).toThrow("quarter.iso.id.bad.chars");
+        expect(() => v.parse(QuarterIsoId, "2025-Q5")).toThrow("quarter.iso.id.bad.chars");
+    });
+    test("rejects structurally invalid strings", () => {
+        const invalid = ["2025Q1", "2025-Q", "25-Q1", "2025-q1", "2025-QA", "2025-01"];
+        for (const value of invalid) {
+            expect(() => v.parse(QuarterIsoId, value)).toThrow("quarter.iso.id.bad.chars");
+        }
+    });
+});

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

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

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

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "bun:test";
+import { endOfQuarter, startOfQuarter } from "date-fns";
+import * as v from "valibot";
+import { Duration } from "../src/duration.service";
+import { Quarter } from "../src/quarter.vo";
+import { QuarterIsoId } from "../src/quarter-iso-id.vo";
+import { Timestamp } from "../src/timestamp.vo";
+import * as mocks from "./mocks";
+const q4 = v.parse(QuarterIsoId, "2023-Q4");
+describe("Quarter", () => {
+    test("happy path", () => {
+        const quarter = Quarter.fromTimestamp(mocks.TIME_ZERO);
+        expect(quarter.getStart()).toEqual(Timestamp.fromNumber(startOfQuarter(mocks.TIME_ZERO.ms).getTime()));
+        expect(quarter.getEnd()).toEqual(Timestamp.fromNumber(endOfQuarter(mocks.TIME_ZERO.ms).getTime()));
+        expect(quarter.toIsoId()).toEqual(q4);
+        expect(quarter.contains(mocks.TIME_ZERO)).toEqual(true);
+    });
+    test("happy path - near year boundary", () => {
+        const timestamp = Timestamp.fromDateLike("2025-12-31T23:59:59Z");
+        const quarter = Quarter.fromTimestamp(timestamp);
+        expect(quarter.getStart()).toEqual(Timestamp.fromNumber(startOfQuarter(timestamp.ms).getTime()));
+        expect(quarter.getEnd()).toEqual(Timestamp.fromNumber(endOfQuarter(timestamp.ms).getTime()));
+        expect(quarter.toIsoId()).toEqual(v.parse(QuarterIsoId, "2025-Q4"));
+    });
+    test("fromNow", () => {
+        expect(Quarter.fromNow(mocks.TIME_ZERO).toIsoId()).toEqual(q4);
+    });
+    test("fromTimestamp", () => {
+        expect(Quarter.fromTimestamp(mocks.TIME_ZERO).toIsoId()).toEqual(q4);
+    });
+    test("fromTimestampValue", () => {
+        expect(Quarter.fromTimestampValue(mocks.TIME_ZERO.ms).toIsoId()).toEqual(q4);
+    });
+    test("fromIsoId", () => {
+        expect(Quarter.fromIsoId(q4).toIsoId()).toEqual(q4);
+    });
+    test("round-trips", () => {
+        const ids = ["1970-Q1", "1999-Q4", "2024-Q2", "2025-Q3", "2026-Q1"];
+        for (const id of ids) {
+            expect(Quarter.fromIsoId(v.parse(QuarterIsoId, id)).toIsoId()).toEqual(v.parse(QuarterIsoId, id));
+        }
+    });
+    test("contains", () => {
+        const quarter = Quarter.fromTimestamp(mocks.TIME_ZERO);
+        expect(quarter.contains(quarter.getStart().subtract(Duration.Ms(1)))).toEqual(false);
+        expect(quarter.contains(quarter.getEnd().add(Duration.Ms(1)))).toEqual(false);
+    });
+    test("toString", () => {
+        expect(Quarter.fromIsoId(q4).toString()).toEqual("2023-Q4");
+    });
+    test("toJSON", () => {
+        expect(Quarter.fromIsoId(q4).toJSON()).toEqual({ start: 1696118400000, end: 1704067199999 });
+    });
+});

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

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

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

@@ -0,0 +1,93 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { describe, expect, spyOn, test } from "bun:test";
+import { Random } from "../src/random.service";
+describe("Random", () => {
+    test("throws when min equals max", () => {
+        expect(() => Random.generate({ min: 1, max: 1 })).toThrow("random.min.max");
+    });
+    test("throws when min greater than max", () => {
+        expect(() => Random.generate({ min: 2, max: 1 })).toThrow("random.min.max");
+    });
+    test("throws when all zeros", () => {
+        expect(() => Random.generate({ min: 0, max: 0 })).toThrow("random.min.max");
+    });
+    test("generate - default config", () => {
+        const result = Random.generate();
+        expect(result).toBeGreaterThanOrEqual(0);
+        expect(result).toBeLessThanOrEqual(1);
+    });
+    test("generate - min 1, max 10", () => {
+        const result = Random.generate({ min: 1, max: 10 });
+        expect(result).toBeGreaterThanOrEqual(1);
+        expect(result).toBeLessThanOrEqual(10);
+    });
+    test("calculation integrity", () => {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const randomSpy = __addDisposableResource(env_1, spyOn(Math, "random").mockReturnValue(0.9999999), false);
+            const min = 100;
+            const max = 110;
+            expect(Random.generate({ min, max })).toEqual(max);
+            randomSpy.mockReturnValue(0);
+            expect(Random.generate({ min, max })).toEqual(min);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    });
+});

package/dist/tests/rate-limiter.service.test.d.ts

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