@bgord/tools 1.4.0 → 1.4.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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