es-toolkit 1.37.2 → 1.38.0-dev.1285

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

@@ -0,0 +1,138 @@
+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.
+ *
+ * @template T - The type of the original function being memoized
+ * @param {T} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @return {MemoizedFunction<T>} 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,138 @@
+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.
+ *
+ * @template T - The type of the original function being memoized
+ * @param {T} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @return {MemoizedFunction<T>} 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,21 @@
+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 || Map;
+    memoized.cache = new CacheConstructor();
+    return memoized;
+}
+memoize.Cache = Map;
+
+export { memoize };

package/dist/compat/index.d.mts

@@ -30,6 +30,7 @@ export { initial } from './array/initial.mjs';
 export { intersection } from './array/intersection.mjs';
 export { intersectionBy } from './array/intersectionBy.mjs';
 export { intersectionWith } from './array/intersectionWith.mjs';
+export { invokeMap } from './array/invokeMap.mjs';
 export { join } from './array/join.mjs';
 export { keyBy } from './array/keyBy.mjs';
 export { last } from './array/last.mjs';
@@ -60,6 +61,7 @@ export { sortedIndexBy } from './array/sortedIndexBy.mjs';
 export { sortedIndexOf } from './array/sortedIndexOf.mjs';
 export { sortedLastIndex } from './array/sortedLastIndex.mjs';
 export { sortedLastIndexBy } from './array/sortedLastIndexBy.mjs';
+export { sortedLastIndexOf } from './array/sortedLastIndexOf.mjs';
 export { tail } from './array/tail.mjs';
 export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';
@@ -95,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';
@@ -133,9 +135,10 @@ export { assignIn, assignIn as extend } from './object/assignIn.mjs';
 export { assignInWith, assignInWith as extendWith } from './object/assignInWith.mjs';
 export { assignWith } from './object/assignWith.mjs';
 export { at } from './object/at.mjs';
-export { clone } from '../object/clone.mjs';
+export { clone } from './object/clone.mjs';
 export { cloneDeep } from './object/cloneDeep.mjs';
 export { cloneDeepWith } from './object/cloneDeepWith.mjs';
+export { cloneWith } from './object/cloneWith.mjs';
 export { create } from './object/create.mjs';
 export { defaults } from './object/defaults.mjs';
 export { findKey } from './object/findKey.mjs';
@@ -155,6 +158,7 @@ export { invertBy } from './object/invertBy.mjs';
 export { isEqual } from '../predicate/isEqual.mjs';
 export { isFunction } from '../predicate/isFunction.mjs';
 export { isLength } from '../predicate/isLength.mjs';
+export { isNative } from './predicate/isNative.mjs';
 export { isNull } from '../predicate/isNull.mjs';
 export { isUndefined } from '../predicate/isUndefined.mjs';
 export { keys } from './object/keys.mjs';
@@ -172,6 +176,7 @@ export { property } from './object/property.mjs';
 export { propertyOf } from './object/propertyOf.mjs';
 export { result } from './object/result.mjs';
 export { set } from './object/set.mjs';
+export { setWith } from './object/setWith.mjs';
 export { toDefaulted } from './object/toDefaulted.mjs';
 export { toPairs } from './object/toPairs.mjs';
 export { toPairsIn } from './object/toPairsIn.mjs';
@@ -181,6 +186,7 @@ export { update } from './object/update.mjs';
 export { updateWith } from './object/updateWith.mjs';
 export { values } from './object/values.mjs';
 export { valuesIn } from './object/valuesIn.mjs';
+export { bindAll } from './util/bindAll.mjs';
 export { capitalize } from '../string/capitalize.mjs';
 export { conforms } from './predicate/conforms.mjs';
 export { conformsTo } from './predicate/conformsTo.mjs';

package/dist/compat/index.d.ts

@@ -30,6 +30,7 @@ export { initial } from './array/initial.js';
 export { intersection } from './array/intersection.js';
 export { intersectionBy } from './array/intersectionBy.js';
 export { intersectionWith } from './array/intersectionWith.js';
+export { invokeMap } from './array/invokeMap.js';
 export { join } from './array/join.js';
 export { keyBy } from './array/keyBy.js';
 export { last } from './array/last.js';
@@ -60,6 +61,7 @@ export { sortedIndexBy } from './array/sortedIndexBy.js';
 export { sortedIndexOf } from './array/sortedIndexOf.js';
 export { sortedLastIndex } from './array/sortedLastIndex.js';
 export { sortedLastIndexBy } from './array/sortedLastIndexBy.js';
+export { sortedLastIndexOf } from './array/sortedLastIndexOf.js';
 export { tail } from './array/tail.js';
 export { take } from './array/take.js';
 export { takeRight } from './array/takeRight.js';
@@ -95,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';
@@ -133,9 +135,10 @@ export { assignIn, assignIn as extend } from './object/assignIn.js';
 export { assignInWith, assignInWith as extendWith } from './object/assignInWith.js';
 export { assignWith } from './object/assignWith.js';
 export { at } from './object/at.js';
-export { clone } from '../object/clone.js';
+export { clone } from './object/clone.js';
 export { cloneDeep } from './object/cloneDeep.js';
 export { cloneDeepWith } from './object/cloneDeepWith.js';
+export { cloneWith } from './object/cloneWith.js';
 export { create } from './object/create.js';
 export { defaults } from './object/defaults.js';
 export { findKey } from './object/findKey.js';
@@ -155,6 +158,7 @@ export { invertBy } from './object/invertBy.js';
 export { isEqual } from '../predicate/isEqual.js';
 export { isFunction } from '../predicate/isFunction.js';
 export { isLength } from '../predicate/isLength.js';
+export { isNative } from './predicate/isNative.js';
 export { isNull } from '../predicate/isNull.js';
 export { isUndefined } from '../predicate/isUndefined.js';
 export { keys } from './object/keys.js';
@@ -172,6 +176,7 @@ export { property } from './object/property.js';
 export { propertyOf } from './object/propertyOf.js';
 export { result } from './object/result.js';
 export { set } from './object/set.js';
+export { setWith } from './object/setWith.js';
 export { toDefaulted } from './object/toDefaulted.js';
 export { toPairs } from './object/toPairs.js';
 export { toPairsIn } from './object/toPairsIn.js';
@@ -181,6 +186,7 @@ export { update } from './object/update.js';
 export { updateWith } from './object/updateWith.js';
 export { values } from './object/values.js';
 export { valuesIn } from './object/valuesIn.js';
+export { bindAll } from './util/bindAll.js';
 export { capitalize } from '../string/capitalize.js';
 export { conforms } from './predicate/conforms.js';
 export { conformsTo } from './predicate/conformsTo.js';