es-toolkit 1.37.2-dev.1261 → 1.37.2-dev.1263

package/dist/compat/compat.d.mts

@@ -97,7 +97,7 @@ export { delay } from './function/delay.mjs';
 export { flip } from './function/flip.mjs';
 export { flow } from './function/flow.mjs';
 export { flowRight } from './function/flowRight.mjs';
-export { memoize } from '../function/memoize.mjs';
+export { memoize } from './function/memoize.mjs';
 export { negate } from './function/negate.mjs';
 export { nthArg } from './function/nthArg.mjs';
 export { once } from '../function/once.mjs';

package/dist/compat/compat.d.ts

@@ -97,7 +97,7 @@ export { delay } from './function/delay.js';
 export { flip } from './function/flip.js';
 export { flow } from './function/flow.js';
 export { flowRight } from './function/flowRight.js';
-export { memoize } from '../function/memoize.js';
+export { memoize } from './function/memoize.js';
 export { negate } from './function/negate.js';
 export { nthArg } from './function/nthArg.js';
 export { once } from '../function/once.js';

package/dist/compat/compat.mjs

@@ -97,7 +97,7 @@ export { delay } from './function/delay.mjs';
 export { flip } from './function/flip.mjs';
 export { flow } from './function/flow.mjs';
 export { flowRight } from './function/flowRight.mjs';
-export { memoize } from '../function/memoize.mjs';
+export { memoize } from './function/memoize.mjs';
 export { negate } from './function/negate.mjs';
 export { nthArg } from './function/nthArg.mjs';
 export { once } from '../function/once.mjs';

package/dist/compat/function/memoize.d.mts

@@ -0,0 +1,170 @@
+/**
+ * Interface defining a cache implementation for the memoize function.
+ * Provides methods for storing, retrieving, and managing cached values.
+ *
+ * @example
+ * ```typescript
+ * // Implementing a simple MemoizeCache
+ * class SimpleCache implements MemoizeCache {
+ *   private entries = new Map<any, any>();
+ *
+ *   delete(key: any): boolean {
+ *     return this.entries.delete(key);
+ *   }
+ *
+ *   get(key: any): any {
+ *     return this.entries.get(key);
+ *   }
+ *
+ *   has(key: any): boolean {
+ *     return this.entries.has(key);
+ *   }
+ *
+ *   set(key: any, value: any): this {
+ *     this.entries.set(key, value);
+ *     return this;
+ *   }
+ *
+ *   clear(): void {
+ *     this.entries.clear();
+ *   }
+ * }
+ * ```
+ */
+interface MemoizeCache {
+    /**
+     * Optional internal data structure for the cache implementation.
+     * This is primarily used for testing and internal operations.
+     */
+    __data__?: any;
+    /**
+     * Removes the value associated with the specified key from the cache.
+     *
+     * @param key - The key of the value to remove
+     * @returns `true` if an element was removed, `false` if the key wasn't found
+     *
+     * @example
+     * ```typescript
+     * cache.set('user', { id: 123, name: 'John' });
+     * cache.delete('user'); // Returns true
+     * cache.delete('unknown'); // Returns false
+     * ```
+     */
+    delete(key: any): boolean;
+    /**
+     * Retrieves the value associated with the specified key from the cache.
+     *
+     * @param key - The key of the value to retrieve
+     * @returns The cached value or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * cache.set('user', { id: 123, name: 'John' });
+     * cache.get('user'); // Returns { id: 123, name: 'John' }
+     * cache.get('unknown'); // Returns undefined
+     * ```
+     */
+    get(key: any): any;
+    /**
+     * Checks if the cache contains a value for the specified key.
+     *
+     * @param key - The key to check for existence
+     * @returns `true` if the key exists in the cache, otherwise `false`
+     *
+     * @example
+     * ```typescript
+     * cache.set('user', { id: 123, name: 'John' });
+     * cache.has('user'); // Returns true
+     * cache.has('unknown'); // Returns false
+     * ```
+     */
+    has(key: any): boolean;
+    /**
+     * Stores a value in the cache with the specified key.
+     * If the key already exists, its value is updated.
+     *
+     * @param key - The key to associate with the value
+     * @param value - The value to store in the cache
+     * @returns The cache instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * cache.set('user', { id: 123, name: 'John' })
+     *      .set('settings', { theme: 'dark' });
+     * ```
+     */
+    set(key: any, value: any): this;
+    /**
+     * Removes all key-value pairs from the cache.
+     * This method is optional as some cache implementations may be immutable.
+     *
+     * @example
+     * ```typescript
+     * cache.set('user', { id: 123, name: 'John' });
+     * cache.set('settings', { theme: 'dark' });
+     * cache.clear(); // Cache is now empty
+     * ```
+     */
+    clear?(): void;
+}
+/**
+ * Interface for the constructor of cache implementations.
+ * This allows for creating new cache instances with optional initial entries.
+ *
+ * @example
+ * ```typescript
+ * // Use a custom cache constructor with memoize
+ * memoize.Cache = CustomCache;
+ *
+ * // Create a cache with initial entries
+ * const cache = new CustomCache([
+ *   ['key1', 'value1'],
+ *   ['key2', 'value2']
+ * ]);
+ * ```
+ */
+interface MemoizeCacheConstructor {
+    /**
+     * Creates a new cache instance.
+     *
+     * @param entries - Optional array of key-value pairs to initialize the cache with
+     * @returns A new cache instance
+     */
+    new (entries?: Array<[any, any]>): MemoizeCache;
+}
+/**
+ * Represents a function that has been memoized.
+ * A memoized function maintains the same signature as the original function
+ * but adds a cache property to store previously computed results.
+ *
+ * @template T - The type of the original function being memoized
+ */
+interface MemoizedFunction<T extends (...args: any) => any> {
+    /**
+     * Calls the function with the provided arguments, using cached results when available
+     *
+     * @param {...Parameters<T>} args - The arguments to pass to the original function
+     * @returns {ReturnType<T>} The result of the function call, either from cache or freshly computed
+     */
+    (...args: Parameters<T>): ReturnType<T>;
+    /**
+     * The cache storing previously computed results
+     */
+    cache: MemoizeCache;
+}
+/**
+ * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for
+ * storing the result based on the arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with
+ * the this binding of the memoized function.
+ *
+ * @param func The function to have its output memoized.
+ * @param resolver The function to resolve the cache key.
+ * @return Returns the new memoizing function.
+ */
+declare function memoize<T extends (...args: any) => any>(func: T, resolver?: (...args: Parameters<T>) => any): MemoizedFunction<T>;
+declare namespace memoize {
+    var Cache: MemoizeCacheConstructor;
+}
+
+export { memoize };

package/dist/compat/function/memoize.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Interface defining a cache implementation for the memoize function.
+ * Provides methods for storing, retrieving, and managing cached values.
+ *
+ * @example
+ * ```typescript
+ * // Implementing a simple MemoizeCache
+ * class SimpleCache implements MemoizeCache {
+ *   private entries = new Map<any, any>();
+ *
+ *   delete(key: any): boolean {
+ *     return this.entries.delete(key);
+ *   }
+ *
+ *   get(key: any): any {
+ *     return this.entries.get(key);
+ *   }
+ *
+ *   has(key: any): boolean {
+ *     return this.entries.has(key);
+ *   }
+ *
+ *   set(key: any, value: any): this {
+ *     this.entries.set(key, value);
+ *     return this;
+ *   }
+ *
+ *   clear(): void {
+ *     this.entries.clear();
+ *   }
+ * }
+ * ```
+ */
+interface MemoizeCache {
+    /**
+     * Optional internal data structure for the cache implementation.
+     * This is primarily used for testing and internal operations.
+     */
+    __data__?: any;
+    /**
+     * Removes the value associated with the specified key from the cache.
+     *
+     * @param key - The key of the value to remove
+     * @returns `true` if an element was removed, `false` if the key wasn't found
+     *
+     * @example
+     * ```typescript
+     * cache.set('user', { id: 123, name: 'John' });
+     * cache.delete('user'); // Returns true
+     * cache.delete('unknown'); // Returns false
+     * ```
+     */
+    delete(key: any): boolean;
+    /**
+     * Retrieves the value associated with the specified key from the cache.
+     *
+     * @param key - The key of the value to retrieve
+     * @returns The cached value or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * cache.set('user', { id: 123, name: 'John' });
+     * cache.get('user'); // Returns { id: 123, name: 'John' }
+     * cache.get('unknown'); // Returns undefined
+     * ```
+     */
+    get(key: any): any;
+    /**
+     * Checks if the cache contains a value for the specified key.
+     *
+     * @param key - The key to check for existence
+     * @returns `true` if the key exists in the cache, otherwise `false`
+     *
+     * @example
+     * ```typescript
+     * cache.set('user', { id: 123, name: 'John' });
+     * cache.has('user'); // Returns true
+     * cache.has('unknown'); // Returns false
+     * ```
+     */
+    has(key: any): boolean;
+    /**
+     * Stores a value in the cache with the specified key.
+     * If the key already exists, its value is updated.
+     *
+     * @param key - The key to associate with the value
+     * @param value - The value to store in the cache
+     * @returns The cache instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * cache.set('user', { id: 123, name: 'John' })
+     *      .set('settings', { theme: 'dark' });
+     * ```
+     */
+    set(key: any, value: any): this;
+    /**
+     * Removes all key-value pairs from the cache.
+     * This method is optional as some cache implementations may be immutable.
+     *
+     * @example
+     * ```typescript
+     * cache.set('user', { id: 123, name: 'John' });
+     * cache.set('settings', { theme: 'dark' });
+     * cache.clear(); // Cache is now empty
+     * ```
+     */
+    clear?(): void;
+}
+/**
+ * Interface for the constructor of cache implementations.
+ * This allows for creating new cache instances with optional initial entries.
+ *
+ * @example
+ * ```typescript
+ * // Use a custom cache constructor with memoize
+ * memoize.Cache = CustomCache;
+ *
+ * // Create a cache with initial entries
+ * const cache = new CustomCache([
+ *   ['key1', 'value1'],
+ *   ['key2', 'value2']
+ * ]);
+ * ```
+ */
+interface MemoizeCacheConstructor {
+    /**
+     * Creates a new cache instance.
+     *
+     * @param entries - Optional array of key-value pairs to initialize the cache with
+     * @returns A new cache instance
+     */
+    new (entries?: Array<[any, any]>): MemoizeCache;
+}
+/**
+ * Represents a function that has been memoized.
+ * A memoized function maintains the same signature as the original function
+ * but adds a cache property to store previously computed results.
+ *
+ * @template T - The type of the original function being memoized
+ */
+interface MemoizedFunction<T extends (...args: any) => any> {
+    /**
+     * Calls the function with the provided arguments, using cached results when available
+     *
+     * @param {...Parameters<T>} args - The arguments to pass to the original function
+     * @returns {ReturnType<T>} The result of the function call, either from cache or freshly computed
+     */
+    (...args: Parameters<T>): ReturnType<T>;
+    /**
+     * The cache storing previously computed results
+     */
+    cache: MemoizeCache;
+}
+/**
+ * Creates a function that memoizes the result of func. If resolver is provided it determines the cache key for
+ * storing the result based on the arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is coerced to a string and used as the cache key. The func is invoked with
+ * the this binding of the memoized function.
+ *
+ * @param func The function to have its output memoized.
+ * @param resolver The function to resolve the cache key.
+ * @return Returns the new memoizing function.
+ */
+declare function memoize<T extends (...args: any) => any>(func: T, resolver?: (...args: Parameters<T>) => any): MemoizedFunction<T>;
+declare namespace memoize {
+    var Cache: MemoizeCacheConstructor;
+}
+
+export { memoize };

package/dist/compat/function/memoize.mjs

@@ -0,0 +1,171 @@
+import { eq } from '../util/eq.mjs';
+
+class Hash {
+    static hasOwnProperty = Object.prototype.hasOwnProperty;
+    __data__ = {};
+    size = 0;
+    constructor(entries = []) {
+        if (entries && entries.length) {
+            const length = entries.length;
+            for (let i = 0; i < length; i++) {
+                const [key, value] = entries[i];
+                this.set(key, value);
+            }
+        }
+    }
+    clear() {
+        this.__data__ = {};
+        this.size = 0;
+    }
+    delete(key) {
+        const hasKey = this.has(key);
+        if (hasKey) {
+            delete this.__data__[key];
+            this.size--;
+        }
+        return hasKey;
+    }
+    get(key) {
+        const data = this.__data__;
+        return Hash.hasOwnProperty.call(data, key) ? data[key] : undefined;
+    }
+    has(key) {
+        return Hash.hasOwnProperty.call(this.__data__, key);
+    }
+    set(key, value) {
+        const hadKey = this.has(key);
+        this.__data__[key] = value === undefined ? '__lodash_hash_undefined__' : value;
+        if (!hadKey) {
+            this.size++;
+        }
+        return this;
+    }
+}
+class ListCache {
+    __data__ = [];
+    size = 0;
+    constructor(entries = []) {
+        if (entries && entries.length) {
+            const length = entries.length;
+            for (let i = 0; i < length; i++) {
+                const [key, value] = entries[i];
+                this.set(key, value);
+            }
+        }
+    }
+    clear() {
+        this.__data__ = [];
+        this.size = 0;
+    }
+    delete(key) {
+        const index = this.findIndex(key);
+        if (index < 0) {
+            return false;
+        }
+        this.__data__.splice(index, 1);
+        this.size--;
+        return true;
+    }
+    get(key) {
+        const index = this.findIndex(key);
+        return index < 0 ? undefined : this.__data__[index][1];
+    }
+    has(key) {
+        return this.findIndex(key) >= 0;
+    }
+    set(key, value) {
+        const index = this.findIndex(key);
+        if (index < 0) {
+            this.__data__.push([key, value]);
+            this.size++;
+        }
+        else {
+            this.__data__[index][1] = value;
+        }
+        return this;
+    }
+    findIndex(key) {
+        const data = this.__data__;
+        let length = data.length;
+        while (length--) {
+            if (eq(data[length][0], key)) {
+                return length;
+            }
+        }
+        return -1;
+    }
+}
+class MapCache {
+    size = 0;
+    __data__ = {
+        hash: new Hash(),
+        map: typeof Map !== 'undefined' ? new Map() : new ListCache(),
+        string: new Hash(),
+    };
+    constructor(entries = []) {
+        if (entries && entries.length) {
+            const length = entries.length;
+            for (let i = 0; i < length; i++) {
+                const [key, value] = entries[i];
+                this.set(key, value);
+            }
+        }
+    }
+    clear() {
+        this.size = 0;
+        this.__data__ = {
+            hash: new Hash(),
+            map: typeof Map !== 'undefined' ? new Map() : new ListCache(),
+            string: new Hash(),
+        };
+    }
+    delete(key) {
+        const result = this.getMapData(key)['delete'](key);
+        this.size -= result ? 1 : 0;
+        return result;
+    }
+    get(key) {
+        return this.getMapData(key).get(key);
+    }
+    has(key) {
+        return this.getMapData(key).has(key);
+    }
+    set(key, value) {
+        const data = this.getMapData(key);
+        const size = data.size;
+        data.set(key, value);
+        this.size += data.size === size ? 0 : 1;
+        return this;
+    }
+    isKeyable(value) {
+        const type = typeof value;
+        return type === 'string' || type === 'number' || type === 'symbol' || type === 'boolean'
+            ? value !== '__proto__'
+            : value === null;
+    }
+    getMapData(key) {
+        const data = this.__data__;
+        return this.isKeyable(key) ? data[typeof key === 'string' ? 'string' : 'hash'] : data.map;
+    }
+}
+function memoize(func, resolver) {
+    if (typeof func !== 'function' || (resolver != null && typeof resolver !== 'function')) {
+        throw new TypeError('Expected a function');
+    }
+    const memoized = function (...args) {
+        const key = resolver ? resolver.apply(this, args) : args[0];
+        const cache = memoized.cache;
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = func.apply(this, args);
+        memoized.cache = cache.set(key, result) || cache;
+        return result;
+    };
+    const CacheConstructor = memoize.Cache || MapCache;
+    memoized.cache = new CacheConstructor();
+    return memoized;
+}
+memoize.Cache = MapCache;
+
+export { memoize };

package/dist/compat/index.d.mts

@@ -97,7 +97,7 @@ export { delay } from './function/delay.mjs';
 export { flip } from './function/flip.mjs';
 export { flow } from './function/flow.mjs';
 export { flowRight } from './function/flowRight.mjs';
-export { memoize } from '../function/memoize.mjs';
+export { memoize } from './function/memoize.mjs';
 export { negate } from './function/negate.mjs';
 export { nthArg } from './function/nthArg.mjs';
 export { once } from '../function/once.mjs';

package/dist/compat/index.d.ts

@@ -97,7 +97,7 @@ export { delay } from './function/delay.js';
 export { flip } from './function/flip.js';
 export { flow } from './function/flow.js';
 export { flowRight } from './function/flowRight.js';
-export { memoize } from '../function/memoize.js';
+export { memoize } from './function/memoize.js';
 export { negate } from './function/negate.js';
 export { nthArg } from './function/nthArg.js';
 export { once } from '../function/once.js';