@develia/commons 0.3.43 → 0.4.0

package/src/array.ts

@@ -1,3 +1,5 @@
+import type {Predicate} from "./types.js";
+
 /**
  * Removes all given values from the provided array and returns the number of removed elements.
  * The operation mutates the original array.
@@ -17,4 +19,51 @@ export function pull<T>(array: Array<T>, ...items: Array<T>): number {
         }
     }
     return output;
+}
+
+/**
+ * Splits an array into chunks of a given size.
+ * @template T
+ * @param {Array<T>} array - The array to split.
+ * @param {number} size - The size of each chunk.
+ * @return {Array<Array<T>>} The array of chunks.
+ */
+export function chunk<T>(array: Array<T>, size: number): Array<Array<T>> {
+    if (size <= 0) throw new Error("Size must be greater than 0");
+    const result: Array<Array<T>> = [];
+    for (let i = 0; i < array.length; i += size) {
+        result.push(array.slice(i, i + size));
+    }
+    return result;
+}
+
+/**
+ * Removes all elements from the array, mutating it.
+ * @template T
+ * @param {Array<T>} array - The array to clear.
+ */
+export function clear<T>(array: Array<T>): void {
+    array.length = 0;
+}
+
+/**
+ * Removes all elements from the array that satisfy the predicate.
+ * The operation mutates the original array.
+ * @template T
+ * @return {Array<T>} An array of removed elements.
+ */
+export function remove<T>(array: Array<T>,predicate: Predicate<T>): Array<T> {
+    const removed: Array<T> = [];
+    let i = 0;
+
+    while (i < array.length) {
+        if (predicate(array[i])) {
+            removed.push(array[i]);
+            array.splice(i, 1); // muta el array
+        } else {
+            i++;
+        }
+    }
+
+    return removed;
 }

package/src/async-pool-executor.ts

@@ -1,5 +1,5 @@
-import {Supplier} from "./types";
-import {delay} from "./utilities";
+import type {Supplier} from "./types.js";
+import {delay} from "./utilities.js";
 
 export default class AsyncPoolExecutor {
     private _checkIntervalMs: number;

package/src/collections/default-map.ts

@@ -0,0 +1,42 @@
+import type {UnaryFunction} from "../types.js";
+
+/**
+ * DefaultMap<K, V>
+ * Un Map que crea y guarda automáticamente un valor por defecto
+ * cuando accedes a una clave inexistente con get(key).
+ *
+ * Ejemplo rápido:
+ *   const m = new DefaultMap<string, number>(() => 0);
+ *   m.get("a") += 1;  // ahora m.get("a") === 1
+ */
+export default class DefaultMap<K, V> extends Map<K, V> {
+    private readonly _factoryMethod: (key: K) => V;
+
+    /**
+     * @param factoryMethod Función que produce el valor por defecto para una clave.
+     * @param entries Entradas iniciales.
+     */
+    constructor(factoryMethod: UnaryFunction<K, V>, entries?: Iterable<[K, V]>) {
+        super(entries);
+        if (typeof factoryMethod !== "function") {
+            throw new TypeError("DefaultMap necesita una factory (key => defaultValue).");
+        }
+        this._factoryMethod = factoryMethod;
+    }
+
+    /**
+     * Obtiene el valor de la clave. Si no existe, lo crea con la factory,
+     * lo guarda y lo devuelve.
+     */
+    override get(key: K): V {
+        if (!super.has(key)) {
+            const value = this._factoryMethod(key);
+            super.set(key, value);
+            return value;
+        }
+        // ¡super.get puede devolver undefined si no existe! Pero ya comprobamos has(key)
+        return super.get(key)!;
+    }
+
+
+}

package/src/collections/lazy-map.ts

@@ -0,0 +1,24 @@
+import {isFunction} from "../utilities.js";
+
+export default 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/collections.ts

@@ -1,24 +1,2 @@
-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;
-    }
-}
+export {default as LazyMap} from './collections/lazy-map.js'
+export {default as DefaultMap} from './collections/default-map.js'

package/src/from.ts

@@ -1,7 +1,7 @@
-import {Consumer, EqualityComparer, UnaryFunction, Predicate, Supplier, Optional, Nullable} from "./types";
-import {shallowEqual, toPairs} from "./utilities";
-import KeyValuePair from "./key-value-pair";
-import Order from "./order";
+import type {Consumer, EqualityComparer, UnaryFunction, Predicate, Supplier, Optional, Nullable} from "./types.js";
+import {shallowEqual, toPairs} from "./utilities.js";
+import KeyValuePair from "./key-value-pair.js";
+import Order from "./order.js";
 
 
 export default function from<T>(source: Iterable<T> | Supplier<Iterable<T>>): From<T> | From<KeyValuePair<any, any>> {

package/src/index.ts

@@ -1,22 +1,28 @@
-import CleanURLSearchParams from "./clean-url-search-params";
-
-export * from './types';
-export {Type} from "./typing";
-export * from './utilities';
-export * from './string';
-export * from './math';
-export {default as CacheDictionary} from './cache-dictionary';
-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 KeyValuePair} from './key-value-pair'
-export {default as array, ArrayManipulator} from './array-manipulator';
-export {default as AsyncPoolExecutor} from './async-pool-executor';
-export {default as Order} from './order';
-export {default as CleanURLSearchParams} from './clean-url-search-params'
-export {default as Stopwatch} from './stopwatch'
-export * from './array'
-
-
-
+export * from './types.js';
+export {default as Tipe} from "./type.js";
+
+export * from './utilities.js';
+export * from './string.js';
+export * from './math.js';
+export {default as CacheDictionary} from './cache-dictionary.js';
+export {default as from, From} from './from.js';
+export {default as Timer} from './timer.js'
+export {default as TimeSpan} from './timespan.js'
+export {default as Lazy} from './lazy.js'
+export {default as KeyValuePair} from './key-value-pair.js'
+export {default as AsyncPoolExecutor} from './async-pool-executor.js';
+export {default as Order} from './order.js';
+export {default as CleanURLSearchParams} from './clean-url-search-params.js'
+export {default as Stopwatch} from './stopwatch.js'
+
+/** @deprecated */
+export * from './array.js'
+export * as array from "./array.js";
+
+
+export * from './collections.js'
+
+
+
+
+

package/src/lazy.ts

@@ -1,4 +1,4 @@
-import {Nullable, Supplier} from "./types";
+import type {Nullable, Supplier} from "./types.js";
 
 
 /**

package/src/patch.ts

@@ -0,0 +1,80 @@
+import type {AbstractConstructor} 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 AbstractConstructor<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 AbstractConstructor<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/stopwatch.ts

@@ -1,4 +1,4 @@
-import TimeSpan from "./timespan";
+import TimeSpan from "./timespan.js";
 
 export default class Stopwatch {
     private startTime: number | null = null;

package/src/{typing.ts → type.ts}

@@ -3,7 +3,7 @@
  * Represents different types in JavaScript.
  * @enum {string}
  */
-export enum Type {
+enum Type {
     Undefined = "undefined",
     Number = "number",
     String = "string",
@@ -15,3 +15,5 @@ export enum Type {
     Null = "null"
 }
 
+export default Type;
+

package/src/types.ts

@@ -1,6 +1,5 @@
 export type EqualityComparer<T> = (arg1: T, arg2: T) => boolean;
 
-
 export type Consumer<T> = (arg: T) => void
 
 export type Predicate<T> = (arg: T) => boolean;
@@ -26,4 +25,8 @@ export type QuaternaryFunction<T1, T2, T3, T4, R> = (
     arg4: T4
 ) => R;
 
+export type Constructor<T = object, A extends any[] = any[]> =
+  new (...args: A) => T;
 
+export type AbstractConstructor<T = object, A extends any[] = any[]> =
+  abstract new (...args: A) => T;

package/src/utilities.ts

@@ -1,9 +1,9 @@
 // noinspection JSUnusedGlobalSymbols
 
 
-import KeyValuePair from "./key-value-pair";
-import {Optional, Resolvable, Supplier} from "./types";
-import {Type} from "./typing";
+import KeyValuePair from "./key-value-pair.js";
+import type {Optional, Resolvable, Supplier} from "./types.js";
+import Type from "./type.js";
 
 /**
  * Checks if an object is iterable.
@@ -453,6 +453,26 @@ export function getType(value: any): Type {
     return value === null ? Type.Null : Type[typeof value as keyof typeof Type];
 }
 
+export function formToObject(form: HTMLFormElement): Record<string, FormDataEntryValue | FormDataEntryValue[]> {
+    const fd = new FormData(form);
+    const out: Record<string, FormDataEntryValue | FormDataEntryValue[]> = {};
+
+    for (const [key, value] of fd.entries()) {
+        if (key in out) {
+            const current = out[key];
+            if (Array.isArray(current)) {
+                current.push(value);
+            } else {
+                out[key] = [current, value];
+            }
+        } else {
+            out[key] = value;
+        }
+    }
+
+    return out;
+}
+
 /**
  * Converts an object to `FormData` format recursively.
  *