@bgord/tools 0.6.0 → 0.8.0

package/dist/clock.vo.d.ts

@@ -0,0 +1,25 @@
+import { Hour } from "./hour.vo";
+import { Minute } from "./minute.vo";
+export type ClockFormatter = (hour: Hour, minute: Minute) => string;
+declare enum ClockFormatterEnum {
+    TWENTY_FOUR_HOURS = "TWENTY_FOUR_HOURS",
+    TWELVE_HOURS = "TWELVE_HOURS"
+}
+export declare const ClockFormatters: Record<ClockFormatterEnum, ClockFormatter>;
+export declare class Clock {
+    private readonly hour;
+    private readonly minute;
+    private readonly formatter;
+    constructor(hour: Hour, minute: Minute, formatter?: ClockFormatter);
+    get(formatter?: ClockFormatter): {
+        raw: {
+            hour: number;
+            minute: number;
+        };
+        formatted: string;
+    };
+    equals(another: Clock): boolean;
+    isAfter(another: Clock): boolean;
+    isBefore(another: Clock): boolean;
+}
+export {};

package/dist/clock.vo.js

@@ -0,0 +1,45 @@
+import { HourFormatters } from "./hour.vo";
+var ClockFormatterEnum;
+(function (ClockFormatterEnum) {
+    ClockFormatterEnum["TWENTY_FOUR_HOURS"] = "TWENTY_FOUR_HOURS";
+    ClockFormatterEnum["TWELVE_HOURS"] = "TWELVE_HOURS";
+})(ClockFormatterEnum || (ClockFormatterEnum = {}));
+export const ClockFormatters = {
+    TWENTY_FOUR_HOURS: (hour, minute) => `${hour.get().formatted}:${minute.get().formatted}`,
+    TWELVE_HOURS: (hour, minute) => `${hour.get(HourFormatters.TWELVE_HOURS).formatted}:${minute.get().formatted}`,
+};
+export class Clock {
+    constructor(hour, minute, formatter) {
+        this.hour = hour;
+        this.minute = minute;
+        this.formatter = formatter ?? ClockFormatters.TWENTY_FOUR_HOURS;
+    }
+    get(formatter) {
+        const format = formatter ?? this.formatter;
+        return {
+            raw: { hour: this.hour.get().raw, minute: this.minute.get().raw },
+            formatted: format(this.hour, this.minute),
+        };
+    }
+    equals(another) {
+        return (this.hour.get().raw === another.get().raw.hour && this.minute.get().raw === another.get().raw.minute);
+    }
+    isAfter(another) {
+        if (this.hour.get().raw > another.hour.get().raw) {
+            return true;
+        }
+        if (this.hour.get().raw === another.hour.get().raw && this.minute.get().raw > another.minute.get().raw) {
+            return true;
+        }
+        return false;
+    }
+    isBefore(another) {
+        if (this.hour.get().raw < another.hour.get().raw) {
+            return true;
+        }
+        if (this.hour.get().raw === another.hour.get().raw && this.minute.get().raw < another.minute.get().raw) {
+            return true;
+        }
+        return false;
+    }
+}

package/dist/dll.service.d.ts

@@ -0,0 +1,29 @@
+export declare class Node<T> {
+    data: T;
+    prev: Node<T> | null;
+    next: Node<T> | null;
+    constructor(data: Node<T>["data"]);
+    forward(n: number): Node<T> | null;
+    backward(n: number): Node<T> | null;
+}
+export declare class DoublyLinkedList<T> {
+    static EMPTY_SIZE: number;
+    private size;
+    private head;
+    private tail;
+    getSize(): DoublyLinkedList<T>["size"];
+    isEmpty(): boolean;
+    getHead(): DoublyLinkedList<T>["head"];
+    getTail(): DoublyLinkedList<T>["tail"];
+    append(node: Node<T>): void;
+    prepend(node: Node<T>): void;
+    clear(): void;
+    remove(node: Node<T>): void;
+    insertAfter(node: Node<T>, target: Node<T>): void;
+    insertBefore(node: Node<T>, target: Node<T>): void;
+    find(callback: (node: Node<T>) => boolean): Node<T> | null;
+    reverse(): void;
+    toArray(): Node<T>[];
+    static fromArray<T>(array: T[]): DoublyLinkedList<T>;
+    [Symbol.iterator](): IterableIterator<Node<T>>;
+}

package/dist/dll.service.js

@@ -0,0 +1,148 @@
+export class Node {
+    constructor(data) {
+        this.prev = null;
+        this.next = null;
+        this.data = data;
+    }
+    forward(n) {
+        let currentNode = this;
+        for (let i = 0; i < n; i++) {
+            if (currentNode === null) {
+                return currentNode;
+            }
+            currentNode = currentNode.next;
+        }
+        return currentNode;
+    }
+    backward(n) {
+        let currentNode = this;
+        for (let i = 0; i < n; i++) {
+            if (currentNode === null) {
+                return currentNode;
+            }
+            currentNode = currentNode.prev;
+        }
+        return currentNode;
+    }
+}
+export class DoublyLinkedList {
+    constructor() {
+        this.size = DoublyLinkedList.EMPTY_SIZE;
+        this.head = null;
+        this.tail = null;
+    }
+    getSize() {
+        return this.size;
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+    getHead() {
+        return this.head;
+    }
+    getTail() {
+        return this.tail;
+    }
+    append(node) {
+        if (this.head === null || this.tail === null) {
+            this.size++;
+            this.head = node;
+            this.tail = node;
+        }
+        else {
+            this.size++;
+            this.tail.next = node;
+            node.prev = this.tail;
+            this.tail = node;
+        }
+    }
+    prepend(node) {
+        if (this.head === null || this.tail === null) {
+            this.size++;
+            this.head = node;
+            this.tail = node;
+        }
+        else {
+            this.size++;
+            node.next = this.head;
+            this.head.prev = node;
+            this.head = node;
+        }
+    }
+    clear() {
+        this.size = 0;
+        this.head = null;
+        this.tail = null;
+    }
+    remove(node) {
+        if (node.prev) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+        this.size--;
+        node.prev = null;
+        node.next = null;
+    }
+    insertAfter(node, target) {
+        if (target === this.tail) {
+            this.append(node);
+        }
+        else {
+            this.size++;
+            node.prev = target;
+            node.next = target.next;
+            // biome-ignore lint: lint/style/noNonNullAssertion
+            target.next.prev = node;
+            target.next = node;
+        }
+    }
+    insertBefore(node, target) {
+        if (target === this.head) {
+            this.prepend(node);
+        }
+        else {
+            this.size++;
+            node.next = target;
+            node.prev = target.prev;
+            // biome-ignore lint: lint/style/noNonNullAssertion
+            target.prev.next = node;
+            target.prev = node;
+        }
+    }
+    find(callback) {
+        return Array.from(this).find(callback) ?? null;
+    }
+    reverse() {
+        [this.head, this.tail] = [this.tail, this.head];
+        // @ts-ignore
+        for (const node of this) {
+            [node.prev, node.next] = [node.next, node.prev];
+        }
+    }
+    toArray() {
+        return Array.from(this);
+    }
+    static fromArray(array) {
+        const dll = new DoublyLinkedList();
+        for (const item of array) {
+            dll.append(new Node(item));
+        }
+        return dll;
+    }
+    *[Symbol.iterator]() {
+        let current = this.head;
+        while (current) {
+            yield current;
+            current = current.next;
+        }
+    }
+}
+DoublyLinkedList.EMPTY_SIZE = 0;

package/dist/email-mask.service.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+export declare const Email: z.ZodEmail;
+export type EmailType = z.infer<typeof Email>;
+export declare class EmailMask {
+    static censor(email: EmailType): EmailType;
+}

package/dist/email-mask.service.js

@@ -0,0 +1,14 @@
+import { z } from "zod/v4";
+export const Email = z.email();
+export class EmailMask {
+    static censor(email) {
+        const [beforeAt, afterAt] = email.split("@");
+        const local = beforeAt;
+        const domain = afterAt;
+        if (local.length <= 2) {
+            return `${"*".repeat(local.length)}@${domain}`;
+        }
+        const censoredLocal = `${local.at(0)}${"*".repeat(local.length - 2)}${local.at(-1)}`;
+        return `${censoredLocal}@${domain}`;
+    }
+}

package/dist/feature-flag.vo.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod/v4";
+export declare enum FeatureFlagEnum {
+    yes = "yes",
+    no = "no"
+}
+export declare const FeatureFlagValue: z.ZodEnum<typeof FeatureFlagEnum>;
+export type FeatureFlagValueType = z.infer<typeof FeatureFlagValue>;
+export declare class FeatureFlag {
+    static isEnabled(flag: FeatureFlagValueType): boolean;
+    static isDisabled(flag: FeatureFlagValueType): boolean;
+}

package/dist/feature-flag.vo.js

@@ -0,0 +1,15 @@
+import { z } from "zod/v4";
+export var FeatureFlagEnum;
+(function (FeatureFlagEnum) {
+    FeatureFlagEnum["yes"] = "yes";
+    FeatureFlagEnum["no"] = "no";
+})(FeatureFlagEnum || (FeatureFlagEnum = {}));
+export const FeatureFlagValue = z.enum(FeatureFlagEnum);
+export class FeatureFlag {
+    static isEnabled(flag) {
+        return flag === FeatureFlagEnum.yes;
+    }
+    static isDisabled(flag) {
+        return flag === FeatureFlagEnum.no;
+    }
+}

package/dist/filter.vo.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod/v4";
+export type DefaultFilterSchemaType = z.ZodRawShape;
+export type FilterValuesType = Record<string, unknown>;
+export type FilterSchemaType<T extends DefaultFilterSchemaType> = z.ZodObject<T>;
+export type FilterParseConfigType<T extends DefaultFilterSchemaType> = {
+    schema: FilterSchemaType<T>;
+    values: FilterValuesType;
+};
+export declare class Filter<T extends DefaultFilterSchemaType> {
+    private readonly schema;
+    constructor(schema: FilterSchemaType<T>);
+    parse(values: FilterValuesType): z.core.$InferObjectOutput<T, Record<string, unknown>> | undefined;
+    default(): z.core.$InferObjectOutput<T, Record<string, unknown>> | undefined;
+    static parse<T extends DefaultFilterSchemaType>(config: FilterParseConfigType<T>): z.core.$InferObjectOutput<T, Record<string, unknown>> | undefined;
+    static default<T extends DefaultFilterSchemaType>(config: Omit<FilterParseConfigType<T>, "values">): z.core.$InferObjectOutput<T, Record<string, unknown>> | undefined;
+    private static _parse;
+}

package/dist/filter.vo.js

@@ -0,0 +1,21 @@
+export class Filter {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    parse(values) {
+        return Filter._parse({ schema: this.schema, values });
+    }
+    default() {
+        return this.parse({});
+    }
+    static parse(config) {
+        return Filter._parse(config);
+    }
+    static default(config) {
+        return Filter._parse({ schema: config.schema, values: {} });
+    }
+    static _parse(config) {
+        const result = config.schema.safeParse(config.values);
+        return result.success ? result.data : undefined;
+    }
+}

package/dist/hour.vo.d.ts

@@ -0,0 +1,24 @@
+export type HourFormatter = (value: Hour["value"]) => string;
+export declare enum HourFormatterEnum {
+    TWENTY_FOUR_HOURS = "TWENTY_FOUR_HOURS",
+    TWENTY_FOUR_HOURS_WO_PADDING = "TWENTY_FOUR_HOURS_WO_PADDING",
+    AM_PM = "AM_PM",
+    TWELVE_HOURS = "TWELVE_HOURS",
+    TWELVE_HOURS_WO_PADDING = "TWELVE_HOURS_WO_PADDING"
+}
+export declare const HourFormatters: Record<HourFormatterEnum, HourFormatter>;
+export declare class Hour {
+    private readonly value;
+    private readonly formatter;
+    static readonly ZERO: Hour;
+    static readonly MAX: Hour;
+    constructor(candidate: number, formatter?: HourFormatter);
+    get(formatter?: HourFormatter): {
+        raw: number;
+        formatted: string;
+    };
+    equals(another: Hour): boolean;
+    isAfter(another: Hour): boolean;
+    isBefore(another: Hour): boolean;
+    static list(formatter?: HourFormatter): Hour[];
+}

package/dist/hour.vo.js

@@ -0,0 +1,52 @@
+export var HourFormatterEnum;
+(function (HourFormatterEnum) {
+    HourFormatterEnum["TWENTY_FOUR_HOURS"] = "TWENTY_FOUR_HOURS";
+    HourFormatterEnum["TWENTY_FOUR_HOURS_WO_PADDING"] = "TWENTY_FOUR_HOURS_WO_PADDING";
+    HourFormatterEnum["AM_PM"] = "AM_PM";
+    HourFormatterEnum["TWELVE_HOURS"] = "TWELVE_HOURS";
+    HourFormatterEnum["TWELVE_HOURS_WO_PADDING"] = "TWELVE_HOURS_WO_PADDING";
+})(HourFormatterEnum || (HourFormatterEnum = {}));
+export const HourFormatters = {
+    TWENTY_FOUR_HOURS: (value) => value.toString().padStart(2, "0"),
+    TWENTY_FOUR_HOURS_WO_PADDING: (value) => value.toString(),
+    AM_PM: (value) => {
+        if (value < 12)
+            return `${value.toString()} a.m.`;
+        return `${value.toString()} p.m.`;
+    },
+    TWELVE_HOURS: (value) => (value % 12).toString().padStart(2, "0"),
+    TWELVE_HOURS_WO_PADDING: (value) => (value % 12).toString(),
+};
+export class Hour {
+    constructor(candidate, formatter) {
+        if (!Number.isInteger(candidate)) {
+            throw new Error("Invalid hour");
+        }
+        if (candidate < 0) {
+            throw new Error("Invalid hour");
+        }
+        if (candidate >= 24) {
+            throw new Error("Invalid hour");
+        }
+        this.value = candidate;
+        this.formatter = formatter ?? HourFormatters.TWENTY_FOUR_HOURS;
+    }
+    get(formatter) {
+        const format = formatter ?? this.formatter;
+        return { raw: this.value, formatted: format(this.value) };
+    }
+    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(formatter) {
+        return Array.from({ length: 24 }).map((_, index) => new Hour(index, formatter));
+    }
+}
+Hour.ZERO = new Hour(0);
+Hour.MAX = new Hour(23);

package/dist/image.vo.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod/v4";
+export declare const Width: z.ZodNumber;
+export type WidthType = z.infer<typeof Width>;
+export declare const Height: z.ZodNumber;
+export type HeightType = z.infer<typeof Height>;

package/dist/image.vo.js

@@ -0,0 +1,3 @@
+import { z } from "zod/v4";
+export const Width = z.number().int().positive().max(10000);
+export const Height = z.number().int().positive().max(10000);

package/dist/index.d.ts

@@ -1,21 +1,48 @@
 export * from "./api-key.vo";
 export * from "./build-version.vo";
+export * from "./clock.vo";
 export * from "./date-calculator.service";
 export * from "./date-formatter.service";
 export * from "./dates-of-the-week.vo";
+export * from "./dll.service";
+export * from "./email-mask.service";
 export * from "./etags.vo";
+export * from "./feature-flag.vo";
+export * from "./filter.vo";
+export * from "./hour.vo";
+export * from "./image.vo";
 export * from "./language.vo";
+export * from "./leap-year-checker.service";
+export * from "./mean.service";
+export * from "./mime-types.vo";
 export * from "./mime.vo";
+export * from "./min-max-scaler.service";
+export * from "./minute.vo";
+export * from "./money.vo";
 export * from "./noop.service";
+export * from "./outlier-detector.service";
 export * from "./package-version.vo";
+export * from "./pagination.service";
+export * from "./percentage.service";
+export * from "./population-standard-deviation.service";
+export * from "./random.service";
 export * from "./rate-limiter.service";
 export * from "./relative-date.vo";
+export * from "./reordering.service";
+export * from "./revision.vo";
 export * from "./rounding.service";
+export * from "./simple-linear-regression.service";
 export * from "./size.vo";
 export * from "./sleep.service";
+export * from "./stepper.service";
 export * from "./stopwatch.service";
+export * from "./streak-calculator.service";
+export * from "./sum.service";
+export * from "./thousands-separator.service";
 export * from "./time-zone-offset-value.vo";
 export * from "./time.service";
 export * from "./timestamp.vo";
 export * from "./timezone.vo";
 export * from "./ts-utils";
+export * from "./visually-unambiguous-characters-generator.service";
+export * from "./z-score.service";

package/dist/index.js

@@ -1,21 +1,48 @@
 export * from "./api-key.vo";
 export * from "./build-version.vo";
+export * from "./clock.vo";
 export * from "./date-calculator.service";
 export * from "./date-formatter.service";
 export * from "./dates-of-the-week.vo";
+export * from "./dll.service";
+export * from "./email-mask.service";
 export * from "./etags.vo";
+export * from "./feature-flag.vo";
+export * from "./filter.vo";
+export * from "./hour.vo";
+export * from "./image.vo";
 export * from "./language.vo";
+export * from "./leap-year-checker.service";
+export * from "./mean.service";
+export * from "./mime-types.vo";
 export * from "./mime.vo";
+export * from "./min-max-scaler.service";
+export * from "./minute.vo";
+export * from "./money.vo";
 export * from "./noop.service";
+export * from "./outlier-detector.service";
 export * from "./package-version.vo";
+export * from "./pagination.service";
+export * from "./percentage.service";
+export * from "./population-standard-deviation.service";
+export * from "./random.service";
 export * from "./rate-limiter.service";
 export * from "./relative-date.vo";
+export * from "./reordering.service";
+export * from "./revision.vo";
 export * from "./rounding.service";
+export * from "./simple-linear-regression.service";
 export * from "./size.vo";
 export * from "./sleep.service";
+export * from "./stepper.service";
 export * from "./stopwatch.service";
+export * from "./streak-calculator.service";
+export * from "./sum.service";
+export * from "./thousands-separator.service";
 export * from "./time-zone-offset-value.vo";
 export * from "./time.service";
 export * from "./timestamp.vo";
 export * from "./timezone.vo";
 export * from "./ts-utils";
+export * from "./visually-unambiguous-characters-generator.service";
+export * from "./z-score.service";

package/dist/leap-year-checker.service.d.ts

@@ -0,0 +1,4 @@
+export declare class LeapYearChecker {
+    static isLeapYear(year: number): boolean;
+    static isCurrentYearLeapYear(): boolean;
+}

package/dist/leap-year-checker.service.js

@@ -0,0 +1,9 @@
+export class LeapYearChecker {
+    static isLeapYear(year) {
+        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    }
+    static isCurrentYearLeapYear() {
+        const year = new Date().getFullYear();
+        return LeapYearChecker.isLeapYear(year);
+    }
+}

package/dist/mean.service.d.ts

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

package/dist/mean.service.js

@@ -0,0 +1,11 @@
+import { RoundToDecimal } from "./rounding.service";
+import { Sum } from "./sum.service";
+export class Mean {
+    static calculate(values, rounding = new RoundToDecimal(2)) {
+        if (values.length === 0) {
+            throw new Error("Values should not be empty");
+        }
+        const mean = Sum.of(values) / values.length;
+        return rounding.round(mean);
+    }
+}

package/dist/mime-types.vo.d.ts

@@ -0,0 +1,2 @@
+import type { MimeRawType } from "./mime.vo";
+export declare const MIME_TYPES: Record<string, MimeRawType[]>;

package/dist/mime-types.vo.js

@@ -0,0 +1,7 @@
+export const MIME_TYPES = {
+    wildcard: ["*/*"],
+    jpeg: ["image/jpeg"],
+    png: ["image/png"],
+    wav: ["audio/x-wav", "audio/wav"],
+    mp4: ["video/mp4"],
+};

package/dist/mime.vo.d.ts

@@ -1,4 +1,4 @@
-type MimeRawType = string;
+export type MimeRawType = string;
 type MimeTypeType = string;
 type MimeSubtypeType = string;
 export declare class Mime {

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

@@ -0,0 +1,36 @@
+import { RoundingStrategy } from "./rounding.service";
+type MinMaxScalerValueType = number;
+type MinMaxScalerConfigType = {
+    min: MinMaxScalerValueType;
+    max: MinMaxScalerValueType;
+    bound?: {
+        lower: MinMaxScalerValueType;
+        upper: MinMaxScalerValueType;
+    };
+    rounding?: RoundingStrategy;
+};
+export declare class MinMaxScaler {
+    private readonly min;
+    private readonly max;
+    private readonly lower;
+    private readonly upper;
+    private readonly rounding;
+    constructor(config: MinMaxScalerConfigType);
+    scale(value: MinMaxScalerValueType): {
+        original: number;
+        scaled: number;
+        isMin: boolean;
+        isMax: boolean;
+    };
+    descale(scaled: MinMaxScalerValueType): {
+        original: number;
+        scaled: number;
+        isLowerBound: boolean;
+        isUpperBound: boolean;
+    };
+    static getMinMax(values: MinMaxScalerValueType[]): {
+        min: number;
+        max: number;
+    };
+}
+export {};