@develia/commons 0.4.15 → 0.4.18

package/src/patch.ts

@@ -1,80 +1,80 @@
-import type {Constructor} from "./types.js";
-
-export type PureMethod<T extends object, A extends any[] = any[], R = any> =
-    (obj: T, ...args: A) => R;
-
-export type PatchSpec<T extends object> =
-    | Record<string, PureMethod<T, any[], any>>
-    | Map<PropertyKey, PureMethod<T, any[], any>>;
-
-
-export function patch<C extends Constructor<any>>(
-    targetOrCtor: C,
-    fns: PatchSpec<InstanceType<C>>
-): Map<PropertyKey, PropertyDescriptor | null>;
-
-export function patch<T extends object>(
-    targetOrCtor: T,
-    fns: PatchSpec<T>
-): Map<PropertyKey, PropertyDescriptor | null>;
-
-/**
- * Devuelve un Map donde:
- *  - clave -> null    (método añadido nuevo)
- *  - clave -> descriptorOriginal (método sustituido)
- */
-export function patch(
-    targetOrCtor: any,
-    fns: PatchSpec<any>
-): Map<PropertyKey, PropertyDescriptor | null> {
-    const target = typeof targetOrCtor === "function" ? targetOrCtor.prototype : targetOrCtor;
-
-    const result = new Map<PropertyKey, PropertyDescriptor | null>();
-    const entries: Array<[PropertyKey, PureMethod<any>]> =
-        fns instanceof Map ? [...fns.entries()] : Object.entries(fns) as any;
-
-    for (const [key, fn] of entries) {
-        const prev = Object.getOwnPropertyDescriptor(target, key);
-        const method = function (this: unknown, ...args: unknown[]) {
-            return (fn as any)(this, ...args);
-        };
-        try {
-            Object.defineProperty(target, key, {
-                value: method,
-                writable: true,
-                configurable: true,
-                enumerable: false,
-            });
-            result.set(key, prev ?? null);
-        } catch { /* ignorar */
-        }
-    }
-    return result;
-}
-
-// Overloads unpatch
-export function unpatch<C extends Constructor<any>>(
-    targetOrCtor: C,
-    changes: Map<PropertyKey, PropertyDescriptor | null>
-): void;
-export function unpatch<T extends object>(
-    targetOrCtor: T,
-    changes: Map<PropertyKey, PropertyDescriptor | null>
-): void;
-
-/**
- * Revierte un patch a partir del mapa devuelto por `patch`.
- */
-export function unpatch(targetOrCtor: any, changes: Map<PropertyKey, PropertyDescriptor | null>): void {
-    const target = typeof targetOrCtor === "function" ? targetOrCtor.prototype : targetOrCtor;
-    for (const [key, prev] of changes) {
-        try {
-            if (prev === null) {
-                if (Object.prototype.hasOwnProperty.call(target, key)) delete target[key];
-            } else {
-                Object.defineProperty(target, key, prev);
-            }
-        } catch { /* ignorar */
-        }
-    }
+import type {Constructor} from "./types.js";
+
+export type PureMethod<T extends object, A extends any[] = any[], R = any> =
+    (obj: T, ...args: A) => R;
+
+export type PatchSpec<T extends object> =
+    | Record<string, PureMethod<T, any[], any>>
+    | Map<PropertyKey, PureMethod<T, any[], any>>;
+
+
+export function patch<C extends Constructor<any>>(
+    targetOrCtor: C,
+    fns: PatchSpec<InstanceType<C>>
+): Map<PropertyKey, PropertyDescriptor | null>;
+
+export function patch<T extends object>(
+    targetOrCtor: T,
+    fns: PatchSpec<T>
+): Map<PropertyKey, PropertyDescriptor | null>;
+
+/**
+ * Devuelve un Map donde:
+ *  - clave -> null    (método añadido nuevo)
+ *  - clave -> descriptorOriginal (método sustituido)
+ */
+export function patch(
+    targetOrCtor: any,
+    fns: PatchSpec<any>
+): Map<PropertyKey, PropertyDescriptor | null> {
+    const target = typeof targetOrCtor === "function" ? targetOrCtor.prototype : targetOrCtor;
+
+    const result = new Map<PropertyKey, PropertyDescriptor | null>();
+    const entries: Array<[PropertyKey, PureMethod<any>]> =
+        fns instanceof Map ? [...fns.entries()] : Object.entries(fns) as any;
+
+    for (const [key, fn] of entries) {
+        const prev = Object.getOwnPropertyDescriptor(target, key);
+        const method = function (this: unknown, ...args: unknown[]) {
+            return (fn as any)(this, ...args);
+        };
+        try {
+            Object.defineProperty(target, key, {
+                value: method,
+                writable: true,
+                configurable: true,
+                enumerable: false,
+            });
+            result.set(key, prev ?? null);
+        } catch { /* ignorar */
+        }
+    }
+    return result;
+}
+
+// Overloads unpatch
+export function unpatch<C extends Constructor<any>>(
+    targetOrCtor: C,
+    changes: Map<PropertyKey, PropertyDescriptor | null>
+): void;
+export function unpatch<T extends object>(
+    targetOrCtor: T,
+    changes: Map<PropertyKey, PropertyDescriptor | null>
+): void;
+
+/**
+ * Revierte un patch a partir del mapa devuelto por `patch`.
+ */
+export function unpatch(targetOrCtor: any, changes: Map<PropertyKey, PropertyDescriptor | null>): void {
+    const target = typeof targetOrCtor === "function" ? targetOrCtor.prototype : targetOrCtor;
+    for (const [key, prev] of changes) {
+        try {
+            if (prev === null) {
+                if (Object.prototype.hasOwnProperty.call(target, key)) delete target[key];
+            } else {
+                Object.defineProperty(target, key, prev);
+            }
+        } catch { /* ignorar */
+        }
+    }
 }

package/src/range.ts

@@ -0,0 +1,165 @@
+export default class Range<T> {
+
+    private readonly start: T;
+    private readonly end: T;
+
+    /**
+     * Range constructor.
+     * @param start
+     * @param end
+     */
+    constructor(start: T, end: T) {
+        this.start = start;
+        this.end = end;
+    }
+
+    /**
+     * Finds the intersection between two ranges.
+     *
+     * @param other The Range object to intersect with.
+     * @returns The intersected Range object, or null if there is no intersection.
+     */
+    public intersect(other: Range<T>): Range<T> | null {
+        const start = (this.start > other.start) ? this.start : other.start;
+        const end = (this.end < other.end) ? this.end : other.end;
+
+        if (start < end) {
+            return new Range(start, end);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Subtract the given range from this range.
+     *
+     * @param other The range to subtract from this range.
+     * @returns An array of Range objects representing the result of the subtraction.
+     */
+    public subtract(other: Range<T>): Range<T>[] {
+        const result: Range<T>[] = [];
+
+        if (this.start >= other.end || this.end <= other.start) {
+            result.push(new Range(this.start, this.end));
+        } else if (other.start <= this.start && other.end >= this.end) {
+            return result;
+        } else {
+            if (this.start < other.start) {
+                result.push(new Range(this.start, other.start));
+            }
+
+            if (this.end > other.end) {
+                result.push(new Range(other.end, this.end));
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Determines if the given range overlaps with the current range.
+     *
+     * @param other The range to be checked for overlap.
+     * @returns Returns true if there is an overlap between the ranges, false otherwise.
+     */
+    public overlaps(other: Range<T>): boolean {
+        const s1 = this.start;
+        const e1 = this.end;
+        const s2 = other.start;
+        const e2 = other.end;
+
+        return (s2 > s1 && s2 < e1 || e2 > s1 && e2 < e1) ||
+            (s1 > s2 && s1 < e2 || e1 > s2 && e1 < e2) ||
+            (s1 === s2 && e1 === e2);
+    }
+
+    /**
+     * Determines whether the specified value is within the range defined by the start and end values.
+     *
+     * @param obj The value to check if it is within the range.
+     * @param inclusive Optional. If set to true, the range boundaries are considered inclusive.
+     * @returns Returns true if the specified value is within the range, false otherwise.
+     */
+    public contains(obj: T, inclusive: boolean = true): boolean {
+        return inclusive ?
+            (this.start <= obj && this.end >= obj) :
+            (this.start < obj && this.end > obj);
+    }
+
+    /**
+     * @returns T
+     */
+    public getStart(): T {
+        return this.start;
+    }
+
+    /**
+     * @returns T
+     */
+    public getEnd(): T {
+        return this.end;
+    }
+
+    /**
+     * Finds the intersection between two sets of ranges.
+     *
+     * @param ranges1
+     * @param ranges2
+     * @returns
+     */
+    public static intersectRanges<T>(ranges1: Range<T>[], ranges2: Range<T>[]): Range<T>[] {
+        const result: Range<T>[] = [];
+        for (const r1 of ranges1) {
+            for (const r2 of ranges2) {
+                const intersection = r1.intersect(r2);
+                if (intersection !== null) {
+                    result.push(intersection);
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Determines if any range in the first set overlaps with any range in the second set.
+     *
+     * @param ranges1
+     * @param ranges2
+     * @returns
+     */
+    public static overlapsAny<T>(ranges1: Range<T>[], ranges2: Range<T>[]): boolean {
+        for (const r1 of ranges1) {
+            for (const r2 of ranges2) {
+                if (r1.overlaps(r2)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Subtracts the second set of ranges from the first set of ranges.
+     *
+     * @param ranges1
+     * @param ranges2
+     * @returns
+     */
+    public static subtractRanges<T>(ranges1: Range<T>[], ranges2: Range<T>[]): Range<T>[] {
+        let currentRanges = ranges1;
+        for (const r2 of ranges2) {
+            const nextRanges: Range<T>[] = [];
+            for (const r1 of currentRanges) {
+                const subtracted = r1.subtract(r2);
+                for (const s of subtracted) {
+                    nextRanges.push(s);
+                }
+            }
+            currentRanges = nextRanges;
+            if (currentRanges.length === 0) {
+                break;
+            }
+        }
+        return currentRanges;
+    }
+}

package/src/stopwatch.ts

@@ -1,43 +1,43 @@
-import TimeSpan from "./timespan.js";
-
-export default class Stopwatch {
-    private startTime: number | null = null;
-    private elapsedTime: number | null = null;
-
-    /*static measure<T>(callback: () => T, measure: { value: TimeSpan | null }): T {
-        const stopwatch = new Stopwatch();
-        stopwatch.start();
-        try {
-            return callback();
-        } finally {
-            stopwatch.stop();
-            measure.value = stopwatch.getElapsedTime();
-        }
-    }*/
-
-    start(): void {
-        this.startTime = performance.now();
-        this.elapsedTime = null;
-    }
-
-    stop(): void {
-        if (this.startTime !== null) {
-            this.elapsedTime = performance.now() - this.startTime;
-            this.startTime = null;
-        }
-    }
-
-    resume(): void {
-        if (this.elapsedTime !== null) {
-            this.startTime = performance.now() - this.elapsedTime;
-            this.elapsedTime = null;
-        }
-    }
-
-    getElapsedTime(): TimeSpan {
-        if (this.startTime !== null) {
-            return TimeSpan.fromMilliseconds(performance.now() - this.startTime);
-        }
-        return TimeSpan.fromMilliseconds(this.elapsedTime ?? 0.0);
-    }
-}
+import TimeSpan from "./timespan.js";
+
+export default class Stopwatch {
+    private startTime: number | null = null;
+    private elapsedTime: number | null = null;
+
+    /*static measure<T>(callback: () => T, measure: { value: TimeSpan | null }): T {
+        const stopwatch = new Stopwatch();
+        stopwatch.start();
+        try {
+            return callback();
+        } finally {
+            stopwatch.stop();
+            measure.value = stopwatch.getElapsedTime();
+        }
+    }*/
+
+    start(): void {
+        this.startTime = performance.now();
+        this.elapsedTime = null;
+    }
+
+    stop(): void {
+        if (this.startTime !== null) {
+            this.elapsedTime = performance.now() - this.startTime;
+            this.startTime = null;
+        }
+    }
+
+    resume(): void {
+        if (this.elapsedTime !== null) {
+            this.startTime = performance.now() - this.elapsedTime;
+            this.elapsedTime = null;
+        }
+    }
+
+    getElapsedTime(): TimeSpan {
+        if (this.startTime !== null) {
+            return TimeSpan.fromMilliseconds(performance.now() - this.startTime);
+        }
+        return TimeSpan.fromMilliseconds(this.elapsedTime ?? 0.0);
+    }
+}

package/src/string.ts

@@ -36,7 +36,8 @@ export function ensureSuffix(str: string, suffix: string): string {
 export function format(template: string, ...args: any[]): string {
 
     let regex: RegExp;
-    if (args.length === 1 && typeof args[0] === 'object') {
+    const hasNamedPlaceholders = /{(?!\d+})[^{}]+}/.test(template);
+    if (args.length === 1 && args[0] !== null && typeof args[0] === 'object' && hasNamedPlaceholders) {
         args = args[0];
         regex = /{(.+?)}/g;
     } else {
@@ -44,7 +45,9 @@ export function format(template: string, ...args: any[]): string {
     }
 
     return template.replace(regex, (match, key) => {
-        return typeof args[key] !== 'undefined' ? args[key] : "";
+        return Object.prototype.hasOwnProperty.call(args, key) && typeof args[key] !== 'undefined'
+            ? args[key]
+            : "";
     });
 }
 
@@ -61,11 +64,11 @@ function toWords(str: string): string[] {
 
     return str
         // Insert a space between a lowercase/digit and an uppercase letter (camelCase -> camel Case)
-        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, '$1 $2')
         // Insert a space between consecutive uppercase letters followed by a lowercase letter (XMLParser -> XML Parser)
-        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .replace(/(\p{Lu}+)(\p{Lu}\p{Ll})/gu, '$1 $2')
         // Replace any non-alphanumeric character with a space
-        .replace(/[^a-zA-Z0-9]+/g, ' ')
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
         .trim()
         .toLowerCase()
         .split(/\s+/)

package/src/timer.ts

@@ -1,68 +1,68 @@
-/**
- * A class representing a timer that executes a callback function at a specified interval.
- */
-export default class Timer {
-
-    private _callback: () => void;
-    private _interval: number;
-    private _intervalId: any | null;
-
-    /**
-     * @param callback Callback
-     * @param interval Seconds between calls
-     */
-    constructor(callback: () => void, interval: number) {
-        this._callback = callback;
-        this._interval = interval;
-        this._intervalId = null;
-    }
-
-    
-    get running(): boolean {
-        return this._intervalId !== null && this._intervalId !== undefined;
-    }
-
-    get interval(): number {
-        return this._interval;
-    }
-
-    set interval(value: number) {
-        if (value != this._interval) {
-            this._interval = value;
-            if (this.running)
-                this.restart();
-        }
-    }
-
-    get callback(): () => void {
-        return this._callback;
-    }
-
-    set callback(value: () => void) {
-        if (value != this._callback) {
-            this._callback = value;
-        }
-    }
-
-
-    start(): void {
-        if (this._intervalId === null) {
-            this._intervalId = setInterval(() => {
-                if (this._callback != null)
-                    this._callback();
-            }, this._interval);
-        }
-    }
-
-    stop(): void {
-        if (this._intervalId !== null) {
-            clearInterval(this._intervalId);
-            this._intervalId = null;
-        }
-    }
-
-    restart(): void {
-        this.stop();
-        this.start();
-    }
+/**
+ * A class representing a timer that executes a callback function at a specified interval.
+ */
+export default class Timer {
+
+    private _callback: () => void;
+    private _interval: number;
+    private _intervalId: any | null;
+
+    /**
+     * @param callback Callback
+     * @param interval Milliseconds between calls
+     */
+    constructor(callback: () => void, interval: number) {
+        this._callback = callback;
+        this._interval = interval;
+        this._intervalId = null;
+    }
+
+    
+    get running(): boolean {
+        return this._intervalId !== null && this._intervalId !== undefined;
+    }
+
+    get interval(): number {
+        return this._interval;
+    }
+
+    set interval(value: number) {
+        if (value != this._interval) {
+            this._interval = value;
+            if (this.running)
+                this.restart();
+        }
+    }
+
+    get callback(): () => void {
+        return this._callback;
+    }
+
+    set callback(value: () => void) {
+        if (value != this._callback) {
+            this._callback = value;
+        }
+    }
+
+
+    start(): void {
+        if (this._intervalId === null) {
+            this._intervalId = setInterval(() => {
+                if (this._callback != null)
+                    this._callback();
+            }, this._interval);
+        }
+    }
+
+    stop(): void {
+        if (this._intervalId !== null) {
+            clearInterval(this._intervalId);
+            this._intervalId = null;
+        }
+    }
+
+    restart(): void {
+        this.stop();
+        this.start();
+    }
 }