@develia/commons 0.4.15 → 0.4.18

package/src/clean-url-search-params.ts

@@ -1,12 +1,37 @@
-export default class CleanURLSearchParams extends URLSearchParams {
-    constructor(params?: Record<string, any>) {
-        // Filtrar `null` y `undefined` antes de pasarlos al constructor de URLSearchParams
-        const cleanParams = Object.fromEntries(
-            Object.entries(params || {}).filter(([_, value]) => value !== null && value !== undefined)
-        );
-
-        super(cleanParams);
-    }
-
-
+type CleanURLSearchParamsInput = string | URLSearchParams | string[][] | Record<string, any>;
+
+function isRecordParams(params: unknown): params is Record<string, any> {
+    return params !== null &&
+        typeof params === 'object' &&
+        !(params instanceof URLSearchParams) &&
+        typeof (params as any)[Symbol.iterator] !== 'function';
+}
+
+function appendCleanValue(params: URLSearchParams, key: string, value: any): void {
+    if (value === null || value === undefined) return;
+
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            appendCleanValue(params, key, item);
+        }
+        return;
+    }
+
+    params.append(key, String(value));
+}
+
+export default class CleanURLSearchParams extends URLSearchParams {
+    constructor(params?: CleanURLSearchParamsInput) {
+        if (!isRecordParams(params)) {
+            super(params as string | URLSearchParams | string[][] | undefined);
+            return;
+        }
+
+        super();
+
+        // Filtrar `null` y `undefined` antes de añadirlos a URLSearchParams
+        for (const [key, value] of Object.entries(params)) {
+            appendCleanValue(this, key, value);
+        }
+    }
 }

package/src/collections/cache-dictionary.ts

@@ -1,116 +1,116 @@
-/**
- * A dictionary-like structure with caching and expiration capabilities.
- * @template T - The type of the values stored in the cache.
- */
-export default class CacheDictionary<T> {
-    private readonly fallback: ((key: string) => T) | null;
-    private readonly cache: { [key: string]: T };
-    private readonly defaultDuration: number | null;
-    private readonly expiration: { [key: string]: Date | undefined };
-
-    /**
-     * @param {((key: string) => T) | null} fallback - Optional function to call when a key is not found.
-     * @param {number | null} defaultDuration - Default duration in seconds for cache items.
-     */
-    constructor(fallback: ((key: string) => T) | null = null, defaultDuration: number | null = null) {
-        this.fallback = fallback;
-        this.cache = {};
-        this.defaultDuration = defaultDuration;
-        this.expiration = {};
-    }
-
-    /**
-     * Gets the expiration date for a specific key.
-     * @param {string} key - The key.
-     * @returns {Date | undefined} The expiration date or undefined.
-     */
-    public getExpiration(key: string): Date | undefined {
-        return this.expiration[key];
-    }
-
-    /**
-     * Sets a specific expiration date for a key.
-     * @param {string} key - The key.
-     * @param {Date | undefined} expiration - The expiration date.
-     */
-    public setExpiration(key: string, expiration: Date | undefined): void {
-        this.expiration[key] = expiration;
-    }
-
-    /**
-     * Sets a duration in seconds for a key's expiration.
-     * @param {string} key - The key.
-     * @param {number | null} duration - Duration in seconds. If null, expiration is removed.
-     */
-    public setDuration(key: string, duration: number | null): void {
-        if (duration === null) {
-            delete this.expiration[key];
-        } else {
-            const expiration = new Date();
-            expiration.setSeconds(expiration.getSeconds() + duration);
-            this.expiration[key] = expiration;
-        }
-    }
-
-    /**
-     * Gets a value from the cache. If not found and a fallback exists, it uses the fallback.
-     * If the item is expired, it's removed and null is returned.
-     * @param {string} key - The key to retrieve.
-     * @returns {T | null} The value or null if not found/expired.
-     */
-    public get(key: string): T | null {
-        if (!this.cache.hasOwnProperty(key)) {
-            if (this.fallback) {
-                this.cache[key] = this.fallback(key);
-                this.expiration[key] = this.calculateExpiration(this.defaultDuration);
-            } else {
-                return null;
-            }
-        }
-
-        if (this.isExpired(key)) {
-            this.remove(key);
-            return null;
-        }
-
-        return this.cache[key];
-    }
-
-    /**
-     * Sets a value in the cache with an optional duration.
-     * @param {string} key - The key.
-     * @param {T} value - The value to store.
-     * @param {number | null} duration - Duration in seconds.
-     */
-    public set(key: string, value: T, duration: number | null = null): void {
-        this.cache[key] = value;
-        this.expiration[key] = this.calculateExpiration(duration);
-    }
-
-    /**
-     * Removes an item from the cache.
-     * @param {string} key - The key to remove.
-     */
-    public remove(key: string): void {
-        delete this.cache[key];
-        delete this.expiration[key];
-    }
-
-    private isExpired(key: string): boolean {
-        const expiration = this.expiration[key];
-        if (expiration instanceof Date) {
-            return expiration < new Date();
-        }
-        return false;
-    }
-
-    private calculateExpiration(duration: number | null): Date | undefined {
-        if (duration === null) {
-            return undefined;
-        }
-
-        const expiration = new Date();
-        expiration.setSeconds(expiration.getSeconds() + duration);
-        return expiration;
-    }
+/**
+ * A dictionary-like structure with caching and expiration capabilities.
+ * @template T - The type of the values stored in the cache.
+ */
+export default class CacheDictionary<T> {
+    private readonly fallback: ((key: string) => T) | null;
+    private readonly cache: { [key: string]: T };
+    private readonly defaultDuration: number | null;
+    private readonly expiration: { [key: string]: Date | undefined };
+
+    /**
+     * @param {((key: string) => T) | null} fallback - Optional function to call when a key is not found.
+     * @param {number | null} defaultDuration - Default duration in seconds for cache items.
+     */
+    constructor(fallback: ((key: string) => T) | null = null, defaultDuration: number | null = null) {
+        this.fallback = fallback;
+        this.cache = Object.create(null);
+        this.defaultDuration = defaultDuration;
+        this.expiration = Object.create(null);
+    }
+
+    /**
+     * Gets the expiration date for a specific key.
+     * @param {string} key - The key.
+     * @returns {Date | undefined} The expiration date or undefined.
+     */
+    public getExpiration(key: string): Date | undefined {
+        return this.expiration[key];
+    }
+
+    /**
+     * Sets a specific expiration date for a key.
+     * @param {string} key - The key.
+     * @param {Date | undefined} expiration - The expiration date.
+     */
+    public setExpiration(key: string, expiration: Date | undefined): void {
+        this.expiration[key] = expiration;
+    }
+
+    /**
+     * Sets a duration in seconds for a key's expiration.
+     * @param {string} key - The key.
+     * @param {number | null} duration - Duration in seconds. If null, expiration is removed.
+     */
+    public setDuration(key: string, duration: number | null): void {
+        if (duration === null) {
+            delete this.expiration[key];
+        } else {
+            const expiration = new Date();
+            expiration.setSeconds(expiration.getSeconds() + duration);
+            this.expiration[key] = expiration;
+        }
+    }
+
+    /**
+     * Gets a value from the cache. If not found and a fallback exists, it uses the fallback.
+     * If the item is expired, it's removed and null is returned.
+     * @param {string} key - The key to retrieve.
+     * @returns {T | null} The value or null if not found/expired.
+     */
+    public get(key: string): T | null {
+        if (!Object.prototype.hasOwnProperty.call(this.cache, key)) {
+            if (this.fallback) {
+                this.cache[key] = this.fallback(key);
+                this.expiration[key] = this.calculateExpiration(this.defaultDuration);
+            } else {
+                return null;
+            }
+        }
+
+        if (this.isExpired(key)) {
+            this.remove(key);
+            return null;
+        }
+
+        return this.cache[key];
+    }
+
+    /**
+     * Sets a value in the cache with an optional duration.
+     * @param {string} key - The key.
+     * @param {T} value - The value to store.
+     * @param {number | null} duration - Duration in seconds.
+     */
+    public set(key: string, value: T, duration: number | null = null): void {
+        this.cache[key] = value;
+        this.expiration[key] = this.calculateExpiration(duration);
+    }
+
+    /**
+     * Removes an item from the cache.
+     * @param {string} key - The key to remove.
+     */
+    public remove(key: string): void {
+        delete this.cache[key];
+        delete this.expiration[key];
+    }
+
+    private isExpired(key: string): boolean {
+        const expiration = this.expiration[key];
+        if (expiration instanceof Date) {
+            return expiration < new Date();
+        }
+        return false;
+    }
+
+    private calculateExpiration(duration: number | null): Date | undefined {
+        if (duration === null) {
+            return undefined;
+        }
+
+        const expiration = new Date();
+        expiration.setSeconds(expiration.getSeconds() + duration);
+        return expiration;
+    }
 }

package/src/collections/default-map.ts

@@ -1,48 +1,48 @@
-import type {Optional, UnaryFunction} from "../types.js";
-
-/**
- * DefaultMap<K, V>
- * A Map that automatically creates and saves a default value
- * when accessing a non-existent key with get(key).
- *
- * @template K - The type of the keys.
- * @template V - The type of the values.
- * @example
- *   const m = new DefaultMap<string, number>(() => 0);
- *   m.get("a"); // 0
- *   m.set("a", m.get("a") + 1); // 1
- */
-export default class DefaultMap<K, V> extends Map<K, V> {
-    private readonly _factoryMethod: (key: K) => V;
-
-    /**
-     * @param {UnaryFunction<K, V>} factoryMethod - Function that produces the default value for a key.
-     * @param {Optional<Iterable<[K, V]>>} entries - Initial entries.
-     */
-    constructor(factoryMethod: UnaryFunction<K, V>, entries: Optional<Iterable<[K, V]>> = undefined) {
-        super(entries);
-        if (typeof factoryMethod !== "function") {
-            throw new TypeError("DefaultMap needs a factory (key => defaultValue).");
-        }
-        this._factoryMethod = factoryMethod;
-    }
-
-    /**
-     * Gets the value for the key. If it does not exist, it creates it using the factory,
-     * saves it, and returns it.
-     *
-     * @param {K} key - The key to get.
-     * @returns {V} The value associated with the key.
-     */
-    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)!;
-    }
-
-
-}
+import type {Optional, UnaryFunction} from "../types.js";
+
+/**
+ * DefaultMap<K, V>
+ * A Map that automatically creates and saves a default value
+ * when accessing a non-existent key with get(key).
+ *
+ * @template K - The type of the keys.
+ * @template V - The type of the values.
+ * @example
+ *   const m = new DefaultMap<string, number>(() => 0);
+ *   m.get("a"); // 0
+ *   m.set("a", m.get("a") + 1); // 1
+ */
+export default class DefaultMap<K, V> extends Map<K, V> {
+    private readonly _factoryMethod: (key: K) => V;
+
+    /**
+     * @param {UnaryFunction<K, V>} factoryMethod - Function that produces the default value for a key.
+     * @param {Optional<Iterable<[K, V]>>} entries - Initial entries.
+     */
+    constructor(factoryMethod: UnaryFunction<K, V>, entries: Optional<Iterable<[K, V]>> = undefined) {
+        super(entries);
+        if (typeof factoryMethod !== "function") {
+            throw new TypeError("DefaultMap needs a factory (key => defaultValue).");
+        }
+        this._factoryMethod = factoryMethod;
+    }
+
+    /**
+     * Gets the value for the key. If it does not exist, it creates it using the factory,
+     * saves it, and returns it.
+     *
+     * @param {K} key - The key to get.
+     * @returns {V} The value associated with the key.
+     */
+    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/default-weak-map.ts

@@ -1,51 +1,51 @@
-import type {Optional, UnaryFunction} from "../types.js";
-
-/**
- * DefaultWeakMap<K, V>
- * A WeakMap that automatically creates and saves a default value
- * when accessing a non-existent key with get(key).
- *
- * @template K - The type of the keys. Must be an object.
- * @template V - The type of the values.
- */
-export default class DefaultWeakMap<K extends object, V> extends WeakMap<K, V> {
-    private readonly _factoryMethod: (key: K) => V;
-
-    /**
-     * @param {UnaryFunction<K, V>} factoryMethod - Function that produces the default value for a key.
-     * @param {Optional<Iterable<[K, V]>>} entries - Initial entries.
-     */
-    constructor(factoryMethod: UnaryFunction<K, V>, entries: Optional<Iterable<[K, V]>> = undefined) {
-        super();
-
-        if (entries != null) {
-            for (const [key, value] of entries ?? []) {
-                this.set(key, value);
-            }
-        }
-
-        if (typeof factoryMethod !== "function") {
-            throw new TypeError("DefaultWeakMap needs a factory (key => defaultValue).");
-        }
-        this._factoryMethod = factoryMethod;
-    }
-
-    /**
-     * Gets the value for the key. If it does not exist, it creates it using the factory,
-     * saves it, and returns it.
-     *
-     * @param {K} key - The key to get.
-     * @returns {V} The value associated with the key.
-     */
-    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)!;
-    }
-
-
-}
+import type {Optional, UnaryFunction} from "../types.js";
+
+/**
+ * DefaultWeakMap<K, V>
+ * A WeakMap that automatically creates and saves a default value
+ * when accessing a non-existent key with get(key).
+ *
+ * @template K - The type of the keys. Must be an object.
+ * @template V - The type of the values.
+ */
+export default class DefaultWeakMap<K extends object, V> extends WeakMap<K, V> {
+    private readonly _factoryMethod: (key: K) => V;
+
+    /**
+     * @param {UnaryFunction<K, V>} factoryMethod - Function that produces the default value for a key.
+     * @param {Optional<Iterable<[K, V]>>} entries - Initial entries.
+     */
+    constructor(factoryMethod: UnaryFunction<K, V>, entries: Optional<Iterable<[K, V]>> = undefined) {
+        super();
+
+        if (entries != null) {
+            for (const [key, value] of entries ?? []) {
+                this.set(key, value);
+            }
+        }
+
+        if (typeof factoryMethod !== "function") {
+            throw new TypeError("DefaultWeakMap needs a factory (key => defaultValue).");
+        }
+        this._factoryMethod = factoryMethod;
+    }
+
+    /**
+     * Gets the value for the key. If it does not exist, it creates it using the factory,
+     * saves it, and returns it.
+     *
+     * @param {K} key - The key to get.
+     * @returns {V} The value associated with the key.
+     */
+    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)!;
+    }
+
+
+}