@develia/commons 0.3.29 → 0.3.31

package/src/async-pool-executor.ts

@@ -1,59 +1,85 @@
-import {Deferred} from "./types";
-import {promisify} from "./utilities";
+import {Supplier} from "./types";
+import {delay} from "./utilities";
 
 export default class AsyncPoolExecutor {
+    private _checkIntervalMs: number;
 
-    private readonly _maxConcurrency: number;
-    private _taskQueue: Array<() => Deferred<any>> = [];
-    private _activeTasks: number = 0;
+    get maxConcurrency(): number {
+        return this._maxConcurrency;
+    }
+
+    set maxConcurrency(value: number) {
+        this._maxConcurrency = value;
 
-    constructor(maxConcurrency: number) {
-        this._maxConcurrency = maxConcurrency;
     }
 
+    private _proccess: any;
+    private _maxConcurrency: number;
+    private _activeTasks: number;
+    private _taskQueue: Array<Supplier<any>> = [];
+
+
+    /**
+     * @param {number} maxConcurrency - The maximum number of concurrent tasks allowed.
+     * @param {number} [checkInterval=50] - The interval, in milliseconds, to check for capacity to run new tasks. Defaults to 50 ms.
+     */
+    constructor(maxConcurrency: number, checkInterval: number = 50) {
+        this._maxConcurrency = maxConcurrency;
+        this._checkIntervalMs = checkInterval;
+        this._activeTasks = 0;
+    }
 
     /**
      * Submits a deferred task to a queue for asynchronous execution and returns a Promise resolving to its result.
      * @template T
-     * @param {Deferred<T>} task - The deferred task to be executed asynchronously.
-     * @return {Promise<T>} A Promise that resolves with the result of the executed task, or rejects if an error occurs during execution.
+     * @param {Supplier<T>} task - The deferred task to be executed asynchronously.
      */
-    public submit<T>(task: Deferred<T>): Promise<T> {
-        return new Promise<T>((resolve, reject) => {
-            this._taskQueue.push(async () => {
-                try {
+    public submit(task: Supplier<any>): void {
+
+        this._taskQueue.push(task);
+
+        if (this._proccess != null)
+            return;
+
+        this._proccess = setTimeout(async () => {
+
+            while (this._taskQueue.length > 0) {
+
+                while (this._activeTasks >= this._maxConcurrency) {
+                    await delay(this._checkIntervalMs);
+                }
+
+                const task = this._taskQueue.shift();
+                if (task) {
                     this._activeTasks++;
-                    resolve(await promisify(task));
-                } catch (error) {
-                    reject(error);
-                } finally {
-                    this._activeTasks--;
-                    this._runNext(); // Intenta ejecutar la siguiente tarea
+                    setTimeout(async () => {
+                        try {
+                            await task();
+                        } finally {
+                            this._activeTasks--;
+                        }
+                    });
                 }
-            });
-            this._runNext();
-        });
-    }
 
 
-    private _runNext(): void {
-        while (this._activeTasks < this._maxConcurrency && this._taskQueue.length > 0) {
-            const nextTask = this._taskQueue.shift();
-            nextTask && nextTask();
-        }
+            }
+
+            this._proccess = null;
+        }, 0);
+
+
     }
 
 
     /**
-     * Gracefully shuts down the system by waiting for all queued and active tasks to complete.
-     * The method ensures that no tasks remain in the queue and no tasks are actively running
-     * before resolving the promise.
+     * Waits until all tasks (both queued and active) are completed.
+     * This method resolves only when there are no pending tasks.
      *
-     * @return {Promise<void>} A promise that resolves when the shutdown process is complete.
+     * @return {Promise<void>} A promise that resolves when all tasks are complete.
      */
     public async shutdown(): Promise<void> {
         while (this._taskQueue.length > 0 || this._activeTasks > 0) {
-            await new Promise((resolve) => setTimeout(resolve, 50));
+            await delay(this._checkIntervalMs);
         }
     }
-}
+}

package/src/collections.ts

@@ -0,0 +1,24 @@
+import {isFunction} from "./utilities";
+
+export class LazyMap<K, V> extends Map<K, V> {
+
+    private readonly _factoryMethod: (key: K) => V;
+
+    constructor(factoryMethod: (key: K) => V, entries?: readonly (readonly [K, V])[] | null) {
+        super(entries);
+        if (!isFunction(factoryMethod)) {
+            throw new Error("factoryMethod is not a function");
+        }
+        this._factoryMethod = factoryMethod;
+    }
+
+    // Sobrescribir el método get
+    get(key: K): V {
+        if (!this.has(key)) {
+            const value = this._factoryMethod(key);
+            this.set(key, value);
+            return value;
+        }
+        return super.get(key) as V;
+    }
+}

package/src/from.ts

@@ -1,9 +1,9 @@
-import {Consumer, EqualityComparer, UnaryFunction, Predicate, Provider, Optional, Nullable} from "./types";
+import {Consumer, EqualityComparer, UnaryFunction, Predicate, Supplier, Optional, Nullable} from "./types";
 import {toPairs} from "./utilities";
-import Pair from "./pair";
+import KeyValuePair from "./key-value-pair";
 
 
-export default function from<T>(source: Iterable<T> | Provider<Iterable<T>>): From<T> | From<Pair<any, any>> {
+export default function from<T>(source: Iterable<T> | Supplier<Iterable<T>>): From<T> | From<KeyValuePair<any, any>> {
     if (source == null)
         throw "Source is null.";
     if (typeof source === 'function')
@@ -19,8 +19,8 @@ export default function from<T>(source: Iterable<T> | Provider<Iterable<T>>): Fr
 
 export class From<T> implements Iterable<T> {
 
-    public static object(obj: any): From<Pair<any, any>> {
-        return new From<Pair<any, any>>(function () {
+    public static object(obj: any): From<KeyValuePair<any, any>> {
+        return new From<KeyValuePair<any, any>>(function () {
             return toPairs(obj);
         });
     }
@@ -42,13 +42,13 @@ export class From<T> implements Iterable<T> {
         return true;
     }
 
-    private readonly _fn: Provider<Iterable<T>>
+    private readonly _fn: Supplier<Iterable<T>>
 
-    protected constructor(fn: Provider<Iterable<T>>) {
+    protected constructor(fn: Supplier<Iterable<T>>) {
         this._fn = fn;
     }
 
-    public static fn<T>(callable: Provider<Iterable<T>>): From<T> {
+    public static fn<T>(callable: Supplier<Iterable<T>>): From<T> {
         return new From<T>(callable);
     };
 

package/src/index.ts

@@ -8,9 +8,10 @@ export {default as from, From} from './from';
 export {default as Timer} from './timer'
 export {default as TimeSpan} from './timespan'
 export {default as Lazy} from './lazy'
-export {default as Pair} from './pair'
+export {default as KeyValuePair} from './key-value-pair'
 export {default as array, ArrayManipulator} from './array-manipulator';
 export {default as AsyncPoolExecutor} from './async-pool-executor';
+export * from './array'
 
 
 

package/src/{pair.ts → key-value-pair.ts}

@@ -4,7 +4,7 @@
  * @template TKey The type of the key.
  * @template TValue The type of the value.
  */
-export default class Pair<TKey, TValue> {
+export default class KeyValuePair<TKey, TValue> {
     get value(): TValue {
         return this._value;
     }

package/src/lazy.ts

@@ -1,4 +1,4 @@
-import {Nullable, Provider} from "./types";
+import {Nullable, Supplier} from "./types";
 
 
 /**
@@ -8,9 +8,9 @@ import {Nullable, Provider} from "./types";
 export default class Lazy<T> {
     private _valueCreated = false;
     private _value: Nullable<T> = null;
-    private readonly _factoryMethod: Provider<T>;
+    private readonly _factoryMethod: Supplier<T>;
 
-    constructor(getter: Provider<T>) {
+    constructor(getter: Supplier<T>) {
         this._factoryMethod = getter;
     }
 

package/src/types.ts

@@ -6,12 +6,14 @@ export type Consumer<T> = (arg: T) => void
 
 export type Predicate<T> = (arg: T) => boolean;
 
-export type Provider<T> = () => T;
+export type Supplier<T> = () => T;
 
 export type Nullable<T> = T | null;
 
 export type Optional<T> = T | undefined;
 
-export type Deferred<T> = Promise<T> | Provider<T>
+export type Resolvable<T> = Promise<T> | Supplier<T>
+
+export type PromiseExecutor = (resolve: Consumer<any>, reject: Consumer<any>) => any
 
 

package/src/utilities.ts

@@ -1,8 +1,8 @@
 // noinspection JSUnusedGlobalSymbols
 
 
-import Pair from "./pair";
-import {Deferred, Optional, Provider} from "./types";
+import KeyValuePair from "./key-value-pair";
+import {Optional, Resolvable, Supplier} from "./types";
 import {Type} from "./typing";
 
 /**
@@ -77,13 +77,68 @@ export function isFunction(value: any): value is Function {
 }
 
 
+/**
+ * Compares two objects or arrays to check if they have the same fields and values,
+ * or the same elements if they are arrays.
+ *
+ * @param {any} a - The first object or array.
+ * @param {any} b - The second object or array.
+ * @return {boolean} - Returns true if the objects/arrays are equal, otherwise false.
+ */
+export function deepEqual(a: any, b: any): boolean {
+    if (a === b) {
+        // If both values are strictly equal, return true
+        return true;
+    }
+
+    // If either value is null or their types differ, return false
+    if (a === null || b === null || typeof a !== typeof b) {
+        return false;
+    }
+
+    // Check if both values are arrays
+    if (Array.isArray(a) && Array.isArray(b)) {
+        // Compare lengths and elements recursively
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // Check if both values are objects
+    if (typeof a === "object" && typeof b === "object") {
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+
+        // Compare the keys length and check if all keys/values match
+        if (keysA.length !== keysB.length) {
+            return false;
+        }
+        for (const key of keysA) {
+            if (!keysB.includes(key) || !deepEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // For all other data types (e.g., numbers, strings, booleans), use strict equality
+    return false;
+}
+
+
 /**
  * Pauses the execution of an asynchronous function for a specified duration.
  *
  * @param {number} ms - The delay duration in milliseconds.
  * @return {Promise<void>} A promise that resolves after the specified delay.
  */
-export async function delay(ms: number): Promise<void>{
+export async function delay(ms: number): Promise<void> {
     await new Promise(resolve => setTimeout(resolve, ms));
 }
 
@@ -118,6 +173,7 @@ export function isNull(value: any): value is null {
     return value === null;
 }
 
+
 /**
  * Determines whether the given value is of type bigint.
  * @param {any} value - The value to be checked.
@@ -200,13 +256,13 @@ export async function ajaxSubmit(selectorOrElement: HTMLFormElement | string): P
  * Converts an object into an array of key-value pairs.
  *
  * @param {Record<string, any>} obj - The object to convert.
- * @return {Pair<string, any>[]} - The array of key-value pairs.
+ * @return {KeyValuePair<string, any>[]} - The array of key-value pairs.
  */
-export function toPairs(obj: Record<string, any>): Pair<string, any>[] {
+export function toPairs(obj: Record<string, any>): KeyValuePair<string, any>[] {
 
     let output = [];
     for (const key in obj) {
-        output.push(new Pair(key, obj[key]));
+        output.push(new KeyValuePair(key, obj[key]));
     }
     return output;
 
@@ -218,7 +274,7 @@ export function toPairs(obj: Record<string, any>): Pair<string, any>[] {
  * @param {any} thing - The thing to be converted into a Promise.
  * @returns {Promise<T>} - A Promise representing the given thing.
  */
-export function promisify<T>(thing: Deferred<T>): Promise<T> {
+export function promisify<T>(thing: Resolvable<T>): Promise<T> {
 
     if (thing instanceof Promise)
         return thing;
@@ -240,8 +296,8 @@ export function promisify<T>(thing: Deferred<T>): Promise<T> {
 
 
 export function ajaxSubmission(selectorOrElement: HTMLFormElement | string,
-                               onSuccess: Optional<Provider<any>> = undefined,
-                               onFailure: Optional<Provider<any>> = undefined) : void {
+                               onSuccess: Optional<Supplier<any>> = undefined,
+                               onFailure: Optional<Supplier<any>> = undefined): void {
 
     const form = typeof selectorOrElement === 'string'
         ? document.querySelector(selectorOrElement)