@bgord/tools 0.6.0 → 0.7.0

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

@@ -0,0 +1,58 @@
+import { RoundToDecimal } from "./rounding.service";
+export class MinMaxScaler {
+    constructor(config) {
+        const rounding = config.rounding ?? new RoundToDecimal(2);
+        const lower = config.bound?.lower ?? 0;
+        const upper = config.bound?.upper ?? 1;
+        if (config.max - config.min < 0) {
+            throw new Error("Invalid MinMaxScaler min-max config");
+        }
+        if (upper - lower <= 0) {
+            throw new Error("Invalid MinMaxScaler bound config");
+        }
+        this.rounding = rounding;
+        this.min = config.min;
+        this.max = config.max;
+        this.lower = lower;
+        this.upper = upper;
+    }
+    scale(value) {
+        const { min, max, lower, upper } = this;
+        if (value < min || value > max) {
+            throw new Error("Value out of min/max range");
+        }
+        if (min === max)
+            return {
+                original: value,
+                scaled: (lower + upper) / 2,
+                isMin: value === min,
+                isMax: value === max,
+            };
+        const result = ((value - min) / (max - min)) * (upper - lower) + lower;
+        return {
+            original: value,
+            scaled: this.rounding.round(result),
+            isMin: value === min,
+            isMax: value === max,
+        };
+    }
+    descale(scaled) {
+        const { min, max, lower, upper } = this;
+        if (scaled < lower || scaled > upper) {
+            throw new Error("Scaled value out of bounds");
+        }
+        const result = ((scaled - lower) / (upper - lower)) * (max - min) + min;
+        return {
+            original: this.rounding.round(result),
+            scaled,
+            isLowerBound: scaled === lower,
+            isUpperBound: scaled === upper,
+        };
+    }
+    static getMinMax(values) {
+        if (values.length === 0) {
+            throw new Error("An empty array supplied");
+        }
+        return { min: Math.min(...values), max: Math.max(...values) };
+    }
+}

package/dist/minute.vo.d.ts

@@ -0,0 +1,14 @@
+export declare class Minute {
+    private readonly value;
+    static readonly ZERO: Minute;
+    static readonly MAX: Minute;
+    constructor(candidate: number);
+    get(): {
+        raw: number;
+        formatted: string;
+    };
+    equals(another: Minute): boolean;
+    isAfter(another: Minute): boolean;
+    isBefore(another: Minute): boolean;
+    static list(): Minute[];
+}

package/dist/minute.vo.js

@@ -0,0 +1,34 @@
+export class Minute {
+    constructor(candidate) {
+        if (!Number.isInteger(candidate)) {
+            throw new Error("Invalid minute");
+        }
+        if (candidate < 0) {
+            throw new Error("Invalid minute");
+        }
+        if (candidate >= 60) {
+            throw new Error("Invalid minute");
+        }
+        this.value = candidate;
+    }
+    get() {
+        return {
+            raw: this.value,
+            formatted: this.value.toString().padStart(2, "0"),
+        };
+    }
+    equals(another) {
+        return this.value === another.get().raw;
+    }
+    isAfter(another) {
+        return this.value > another.get().raw;
+    }
+    isBefore(another) {
+        return this.value < another.get().raw;
+    }
+    static list() {
+        return Array.from({ length: 60 }).map((_, index) => new Minute(index));
+    }
+}
+Minute.ZERO = new Minute(0);
+Minute.MAX = new Minute(59);

package/dist/money.vo.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod/v4";
+import { RoundingStrategy } from "./rounding.service";
+export declare const MoneyAmount: z.ZodNumber;
+export type MoneyAmountType = z.infer<typeof MoneyAmount>;
+export declare const MoneyMultiplicationFactor: z.ZodNumber;
+export type MoneyMultiplicationFactorType = z.infer<typeof MoneyMultiplicationFactor>;
+export declare const MoneyDivisionFactor: z.ZodNumber;
+export type MoneyDivisionFactorType = z.infer<typeof MoneyDivisionFactor>;
+export declare class Money {
+    private static readonly ZERO;
+    private readonly amount;
+    private readonly rounding;
+    constructor(value?: number, rounding?: RoundingStrategy);
+    getAmount(): MoneyAmountType;
+    add(money: Money): Money;
+    multiply(factor: MoneyMultiplicationFactorType): Money;
+    subtract(money: Money): Money;
+    divide(factor: MoneyDivisionFactorType): Money;
+    equals(another: Money): boolean;
+    isGreaterThan(another: Money): boolean;
+    isLessThan(another: Money): boolean;
+    isZero(): boolean;
+    format(): string;
+}

package/dist/money.vo.js

@@ -0,0 +1,64 @@
+import { z } from "zod/v4";
+import { RoundToNearest } from "./rounding.service";
+export const MoneyAmount = z
+    .number()
+    .int({ message: "money.amount.invalid " })
+    .min(0, { message: "money.amount.invalid " });
+export const MoneyMultiplicationFactor = z
+    .number()
+    .min(0, { message: "money.multiplication-factor.invalid" });
+export const MoneyDivisionFactor = z
+    .number()
+    .min(0, { message: "money.division-factor.invalid" })
+    .refine((value) => value !== 0, { message: "money.division-factor.invalid" });
+export class Money {
+    constructor(value = Money.ZERO, rounding) {
+        this.amount = MoneyAmount.parse(value);
+        this.rounding = rounding ?? new RoundToNearest();
+    }
+    getAmount() {
+        return this.amount;
+    }
+    add(money) {
+        const result = this.rounding.round(this.amount + money.getAmount());
+        return new Money(MoneyAmount.parse(result), this.rounding);
+    }
+    multiply(factor) {
+        const result = this.rounding.round(this.amount * factor);
+        return new Money(MoneyAmount.parse(result), this.rounding);
+    }
+    subtract(money) {
+        const result = this.rounding.round(this.amount - money.getAmount());
+        if (result < Money.ZERO) {
+            throw new Error("Less than zero");
+        }
+        return new Money(MoneyAmount.parse(result), this.rounding);
+    }
+    divide(factor) {
+        if (factor === 0) {
+            throw new Error("Cannot divide by zero");
+        }
+        const result = this.rounding.round(this.amount / factor);
+        return new Money(MoneyAmount.parse(result), this.rounding);
+    }
+    equals(another) {
+        return this.amount === another.getAmount();
+    }
+    isGreaterThan(another) {
+        return this.amount > another.getAmount();
+    }
+    isLessThan(another) {
+        return this.amount < another.getAmount();
+    }
+    isZero() {
+        return this.amount === Money.ZERO;
+    }
+    format() {
+        const result = this.amount / 100;
+        const whole = Math.floor(result);
+        const fraction = this.amount % 100;
+        const fractionFormatted = fraction.toString().padStart(2, "0");
+        return `${whole}.${fractionFormatted}`;
+    }
+}
+Money.ZERO = 0;

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

@@ -0,0 +1,6 @@
+export declare class OutlierDetector {
+    private readonly zScore;
+    private readonly threshold;
+    constructor(values: number[], threshold: number);
+    check(value: number): boolean;
+}

package/dist/outlier-detector.service.js

@@ -0,0 +1,13 @@
+import { ZScore } from "./z-score.service";
+export class OutlierDetector {
+    constructor(values, threshold) {
+        if (values.length < 2) {
+            throw new Error("At least two values are needed");
+        }
+        this.zScore = new ZScore(values);
+        this.threshold = Math.abs(threshold);
+    }
+    check(value) {
+        return this.zScore.calculate(value) <= this.threshold;
+    }
+}

package/dist/pagination.service.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod/v4";
+declare const Take: z.ZodNumber;
+type TakeType = z.infer<typeof Take>;
+declare const Skip: z.ZodNumber;
+type SkipType = z.infer<typeof Skip>;
+declare const Page: z.ZodDefault<z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodTransform<number, number>>>;
+export type PageType = z.infer<typeof Page>;
+export type PaginationType = {
+    values: {
+        take: TakeType;
+        skip: SkipType;
+    };
+    page: PageType;
+};
+export type PaginationValuesType = Record<string, unknown>;
+export type TotalType = number;
+export type ExhaustedType = boolean;
+export type PaginationExhaustedConfig = {
+    total: TotalType;
+    pagination: PaginationType;
+};
+export type PaginationPrepareConfigType<T> = {
+    total: TotalType;
+    pagination: PaginationType;
+    result: T[];
+};
+export declare class Pagination {
+    static parse(values: PaginationValuesType, _take: TakeType): PaginationType;
+    static prepare<T>(config: PaginationPrepareConfigType<T>): Paged<T>;
+    static isExhausted(config: PaginationExhaustedConfig): ExhaustedType;
+    private static getLastPage;
+    static empty: {
+        result: never[];
+        meta: {
+            exhausted: boolean;
+            currentPage: number;
+            previousPage: undefined;
+            nextPage: undefined;
+            lastPage: number;
+            total: number;
+        };
+    };
+    static getFirstPage({ take }: {
+        take: TakeType;
+    }): PaginationType;
+}
+export type Paged<T> = {
+    result: T[];
+    meta: {
+        exhausted: ExhaustedType;
+        currentPage: PageType;
+        previousPage: PageType | undefined;
+        nextPage: PageType | undefined;
+        lastPage: PageType;
+        total: TotalType;
+    };
+};
+export {};

package/dist/pagination.service.js

@@ -0,0 +1,56 @@
+import { z } from "zod/v4";
+const Take = z.number().int().positive();
+const Skip = z.number().int().positive();
+const Page = z.coerce
+    .number()
+    .int()
+    .transform((value) => (value <= 0 ? 1 : value))
+    .default(1);
+export class Pagination {
+    static parse(values, _take) {
+        const page = Page.parse(values.page);
+        const take = Take.parse(_take);
+        const skip = (page - 1) * take;
+        return { values: { take, skip }, page };
+    }
+    static prepare(config) {
+        const exhausted = Pagination.isExhausted(config);
+        const currentPage = config.pagination.page;
+        const lastPage = Pagination.getLastPage(config);
+        const previousPage = currentPage > 1 ? currentPage - 1 : undefined;
+        const nextPage = currentPage < lastPage ? currentPage + 1 : undefined;
+        return {
+            result: config.result,
+            meta: {
+                exhausted,
+                currentPage,
+                previousPage,
+                nextPage,
+                lastPage,
+                total: config.total,
+            },
+        };
+    }
+    static isExhausted(config) {
+        const lastPage = Pagination.getLastPage(config);
+        const currentPage = config.pagination.page;
+        return lastPage <= currentPage;
+    }
+    static getLastPage(config) {
+        return Math.ceil(config.total / config.pagination.values.take);
+    }
+    static getFirstPage({ take }) {
+        return { values: { take, skip: 0 }, page: 1 };
+    }
+}
+Pagination.empty = {
+    result: [],
+    meta: {
+        exhausted: true,
+        currentPage: 1,
+        previousPage: undefined,
+        nextPage: undefined,
+        lastPage: 1,
+        total: 0,
+    },
+};

package/dist/percentage.service.d.ts

@@ -0,0 +1,4 @@
+import { RoundingStrategy } from "./rounding.service";
+export declare class Percentage {
+    static of(numerator: number, denominator: number, rounding?: RoundingStrategy): number;
+}

package/dist/percentage.service.js

@@ -0,0 +1,11 @@
+import { RoundToNearest } from "./rounding.service";
+export class Percentage {
+    static of(numerator, denominator, rounding = new RoundToNearest()) {
+        if (denominator === 0) {
+            throw new Error("Invalid denominator");
+        }
+        if (numerator === 0)
+            return 0;
+        return rounding.round((numerator / denominator) * 100);
+    }
+}

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

@@ -0,0 +1,4 @@
+import { RoundingStrategy } from "./rounding.service";
+export declare class PopulationStandardDeviation {
+    static calculate(values: number[], rounding?: RoundingStrategy): number;
+}

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

@@ -0,0 +1,16 @@
+import { Mean } from "./mean.service";
+import { RoundToDecimal } from "./rounding.service";
+import { Sum } from "./sum.service";
+export class PopulationStandardDeviation {
+    static calculate(values, rounding = new RoundToDecimal(2)) {
+        if (values.length < 2) {
+            throw new Error("At least two values are needed");
+        }
+        const mean = Mean.calculate(values);
+        const n = values.length;
+        const squaredDifferences = values.map((value) => (value - mean) ** 2);
+        const sumOfSquaredDifferences = Sum.of(squaredDifferences);
+        const variance = sumOfSquaredDifferences / n;
+        return rounding.round(Math.sqrt(variance));
+    }
+}

package/dist/random.service.d.ts

@@ -0,0 +1,8 @@
+type RandomGenerateConfigType = {
+    min: number;
+    max: number;
+};
+export declare class Random {
+    static generate(config?: RandomGenerateConfigType): number;
+}
+export {};

package/dist/random.service.js

@@ -0,0 +1,19 @@
+export class Random {
+    static generate(config) {
+        const min = config?.min ?? 0;
+        const max = config?.max ?? 1;
+        if (!Number.isInteger(min)) {
+            throw new Error("Minimum value is not an integer");
+        }
+        if (!Number.isInteger(max)) {
+            throw new Error("Maximum value is not an integer");
+        }
+        if (min === max) {
+            throw new Error("Minimum and maximum values cannot be equal");
+        }
+        if (min > max) {
+            throw new Error("Minimum value cannot be greater than maximum value");
+        }
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+}

package/dist/reordering.service.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod/v4";
+export declare const ReorderingItemPositionValue: z.ZodNumber;
+export type ReorderingItemPositionValueType = z.infer<typeof ReorderingItemPositionValue>;
+export declare const ReorderingCorrelationId: z.ZodString;
+export type ReorderingCorrelationIdType = z.infer<typeof ReorderingCorrelationId>;
+export declare const ReorderingItemId: z.ZodUUID;
+export type ReorderingItemIdType = z.infer<typeof ReorderingItemId>;
+export declare const Reordering: z.ZodObject<{
+    correlationId: z.ZodString;
+    id: z.ZodUUID;
+    position: z.ZodNumber;
+}, z.core.$strip>;
+export type ReorderingType = z.infer<typeof Reordering>;
+export type WithReorderingPositionValue<T> = T & {
+    position: ReorderingItemPositionValueType;
+};
+export declare class ReorderingPosition {
+    readonly value: ReorderingItemPositionValueType;
+    constructor(value: ReorderingItemPositionValueType);
+    eq(another: ReorderingPosition): boolean;
+}
+declare class ReorderingItem {
+    readonly id: ReorderingItemIdType;
+    readonly position: ReorderingPosition;
+    constructor(id: ReorderingItemIdType, position: ReorderingPosition);
+    eq(anotherItemId: ReorderingItem["id"]): boolean;
+}
+declare enum ReorderingTransferDirection {
+    upwards = "upwards",
+    downwards = "downwards",
+    noop = "noop"
+}
+export declare class ReorderingTransfer {
+    readonly id: ReorderingItem["id"];
+    readonly to: ReorderingPosition;
+    constructor(config: {
+        id: ReorderingItem["id"];
+        to: ReorderingItemPositionValueType;
+    });
+    getDirection(currentPosition: ReorderingPosition): ReorderingTransferDirection;
+}
+export declare class ReorderingCalculator {
+    private dll;
+    constructor();
+    static fromArray(ids: ReorderingItem["id"][]): ReorderingCalculator;
+    add(id: ReorderingItem["id"]): ReorderingItem;
+    delete(id: ReorderingItem["id"]): void;
+    transfer(transfer: ReorderingTransfer): ReturnType<ReorderingCalculator["read"]>;
+    read(): {
+        ids: string[];
+        items: ReorderingItem[];
+    };
+    private recalculate;
+}
+export declare class ReorderingIntegrator {
+    static appendPosition(reordering: ReorderingType[]): <T extends {
+        id: ReorderingItemIdType;
+    }>(item: T) => WithReorderingPositionValue<T>;
+    static sortByPosition(): (a: WithReorderingPositionValue<unknown>, b: WithReorderingPositionValue<unknown>) => number;
+}
+export {};

package/dist/reordering.service.js

@@ -0,0 +1,121 @@
+import { z } from "zod/v4";
+import { DoublyLinkedList, Node } from "./dll.service";
+export const ReorderingItemPositionValue = z.number().int().min(0);
+export const ReorderingCorrelationId = z.string().min(1);
+export const ReorderingItemId = z.uuid();
+export const Reordering = z.object({
+    correlationId: ReorderingCorrelationId,
+    id: ReorderingItemId,
+    position: ReorderingItemPositionValue,
+});
+export class ReorderingPosition {
+    constructor(value) {
+        if (!ReorderingItemPositionValue.safeParse(value).success) {
+            throw new Error("Position is not a positive integer");
+        }
+        this.value = value;
+    }
+    eq(another) {
+        return this.value === another.value;
+    }
+}
+class ReorderingItem {
+    constructor(id, position) {
+        this.id = id;
+        this.position = position;
+    }
+    eq(anotherItemId) {
+        return this.id === anotherItemId;
+    }
+}
+var ReorderingTransferDirection;
+(function (ReorderingTransferDirection) {
+    ReorderingTransferDirection["upwards"] = "upwards";
+    ReorderingTransferDirection["downwards"] = "downwards";
+    ReorderingTransferDirection["noop"] = "noop";
+})(ReorderingTransferDirection || (ReorderingTransferDirection = {}));
+export class ReorderingTransfer {
+    constructor(config) {
+        this.id = config.id;
+        this.to = new ReorderingPosition(config.to);
+    }
+    getDirection(currentPosition) {
+        if (this.to.value === currentPosition.value)
+            return ReorderingTransferDirection.noop;
+        if (this.to.value > currentPosition.value) {
+            return ReorderingTransferDirection.downwards;
+        }
+        return ReorderingTransferDirection.upwards;
+    }
+}
+export class ReorderingCalculator {
+    constructor() {
+        this.dll = DoublyLinkedList.fromArray([]);
+    }
+    static fromArray(ids) {
+        const reordering = new ReorderingCalculator();
+        for (const id of ids) {
+            reordering.add(id);
+        }
+        return reordering;
+    }
+    add(id) {
+        const position = new ReorderingPosition(this.dll.getSize());
+        const item = new ReorderingItem(id, position);
+        this.dll.append(new Node(item));
+        return item;
+    }
+    delete(id) {
+        const item = this.dll.find((x) => x.data.eq(id));
+        if (!item) {
+            throw new Error("Cannot find Item");
+        }
+        this.dll.remove(item);
+        this.recalculate();
+    }
+    transfer(transfer) {
+        const current = this.dll.find((node) => node.data.eq(transfer.id));
+        const target = this.dll.find((node) => node.data.position.eq(transfer.to));
+        if (!current) {
+            throw new Error("Cannot find current Item");
+        }
+        if (!target) {
+            throw new Error("Cannot find target Item");
+        }
+        const direction = transfer.getDirection(current.data.position);
+        if (direction === ReorderingTransferDirection.noop)
+            return this.read();
+        if (direction === ReorderingTransferDirection.upwards) {
+            this.dll.remove(current);
+            this.dll.insertBefore(current, target);
+            this.recalculate();
+        }
+        if (direction === ReorderingTransferDirection.downwards) {
+            this.dll.remove(current);
+            this.dll.insertAfter(current, target);
+            this.recalculate();
+        }
+        return this.read();
+    }
+    read() {
+        const ids = Array.from(this.dll).map((item) => item.data.id);
+        const items = Array.from(this.dll).map((item) => item.data);
+        return { ids, items };
+    }
+    recalculate() {
+        this.dll = ReorderingCalculator.fromArray(this.read().ids).dll;
+    }
+}
+export class ReorderingIntegrator {
+    static appendPosition(reordering) {
+        return function (item) {
+            return {
+                ...item,
+                position: reordering.find((x) => x.id === item.id)?.position ?? 0,
+            };
+        };
+    }
+    static sortByPosition() {
+        return (a, b) => a.position - b.position;
+    }
+}

package/dist/revision.vo.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod/v4";
+import { ETag, WeakETag } from "./etags.vo";
+export declare const RevisionValue: z.ZodNumber;
+export type RevisionValueType = z.infer<typeof RevisionValue>;
+export declare class Revision {
+    readonly value: RevisionValueType;
+    static initial: RevisionValueType;
+    constructor(value: unknown);
+    matches(another: RevisionValueType): boolean;
+    validate(another: RevisionValueType): void;
+    next(): Revision;
+    static fromETag(etag: ETag | null): Revision;
+    static fromWeakETag(weakEtag: WeakETag | null): Revision;
+}
+export declare class RevisionMismatchError extends Error {
+    constructor();
+}
+export declare class InvalidRevisionError extends Error {
+    constructor();
+}

package/dist/revision.vo.js

@@ -0,0 +1,45 @@
+import { z } from "zod/v4";
+export const RevisionValue = z.number().int().min(0);
+export class Revision {
+    constructor(value) {
+        const result = RevisionValue.safeParse(value);
+        if (!result.success)
+            throw new InvalidRevisionError();
+        this.value = result.data;
+    }
+    matches(another) {
+        return this.value === another;
+    }
+    validate(another) {
+        if (!this.matches(another))
+            throw new RevisionMismatchError();
+    }
+    next() {
+        return new Revision(this.value + 1);
+    }
+    static fromETag(etag) {
+        if (!etag) {
+            throw new InvalidRevisionError();
+        }
+        return new Revision(etag.revision);
+    }
+    static fromWeakETag(weakEtag) {
+        if (!weakEtag) {
+            throw new InvalidRevisionError();
+        }
+        return new Revision(weakEtag.revision);
+    }
+}
+Revision.initial = 0;
+export class RevisionMismatchError extends Error {
+    constructor() {
+        super();
+        Object.setPrototypeOf(this, RevisionMismatchError.prototype);
+    }
+}
+export class InvalidRevisionError extends Error {
+    constructor() {
+        super();
+        Object.setPrototypeOf(this, InvalidRevisionError.prototype);
+    }
+}

package/dist/simple-linear-regression.service.d.ts

@@ -0,0 +1,18 @@
+import { RoundingStrategy } from "./rounding.service";
+export type SLRPairType = {
+    x: number;
+    y: number;
+};
+export type SLRParamsType = {
+    a: number;
+    b: number;
+};
+export type SLRPredictionType = number;
+export declare class SimpleLinearRegression {
+    private readonly params;
+    private readonly rounding;
+    constructor(params: SLRParamsType, rounding?: RoundingStrategy);
+    static fromPairs(pairs: SLRPairType[], rounding?: RoundingStrategy): SimpleLinearRegression;
+    predict(x: SLRPairType["x"], strategy?: RoundingStrategy): SLRPredictionType;
+    inspect(): SimpleLinearRegression["params"];
+}