es-toolkit 1.15.1-dev.449 → 1.15.1-dev.451

package/dist/compat/index.d.mts

@@ -54,7 +54,7 @@ export { noop } from '../function/noop.mjs';
 export { once } from '../function/once.mjs';
 export { throttle } from '../function/throttle.mjs';
 export { negate } from '../function/negate.mjs';
-export { memoize } from '../function/memoize.mjs';
+export { MemoizeCache, memoize } from '../function/memoize.mjs';
 export { unary } from '../function/unary.mjs';
 export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';

package/dist/compat/index.d.ts

@@ -54,7 +54,7 @@ export { noop } from '../function/noop.js';
 export { once } from '../function/once.js';
 export { throttle } from '../function/throttle.js';
 export { negate } from '../function/negate.js';
-export { memoize } from '../function/memoize.js';
+export { MemoizeCache, memoize } from '../function/memoize.js';
 export { unary } from '../function/unary.js';
 export { partial } from '../function/partial.js';
 export { partialRight } from '../function/partialRight.js';

package/dist/function/index.d.mts

@@ -5,7 +5,7 @@ export { noop } from './noop.mjs';
 export { once } from './once.mjs';
 export { throttle } from './throttle.mjs';
 export { negate } from './negate.mjs';
-export { memoize } from './memoize.mjs';
+export { MemoizeCache, memoize } from './memoize.mjs';
 export { ary } from './ary.mjs';
 export { unary } from './unary.mjs';
 export { partial } from './partial.mjs';

package/dist/function/index.d.ts

@@ -5,7 +5,7 @@ export { noop } from './noop.js';
 export { once } from './once.js';
 export { throttle } from './throttle.js';
 export { negate } from './negate.js';
-export { memoize } from './memoize.js';
+export { MemoizeCache, memoize } from './memoize.js';
 export { ary } from './ary.js';
 export { unary } from './unary.js';
 export { partial } from './partial.js';

package/dist/function/index.js

@@ -88,16 +88,13 @@ function negate(func) {
 }
 
 function memoize(fn, options = {}) {
-    const { cache = new Map(), resolver } = options;
-    if (typeof fn !== 'function' || (resolver && typeof resolver !== 'function')) {
-        throw new TypeError('Expected a function and an optional resolver function');
-    }
-    const memoizedFn = function (...args) {
-        const key = resolver ? resolver.apply(this, args) : args[0];
+    const { cache = new Map(), getCacheKey } = options;
+    const memoizedFn = function (arg) {
+        const key = getCacheKey ? getCacheKey(arg) : arg;
         if (cache.has(key)) {
             return cache.get(key);
         }
-        const result = fn.apply(this, args);
+        const result = fn.call(this, arg);
         cache.set(key, result);
         return result;
     };

package/dist/function/memoize.d.mts

@@ -1,75 +1,81 @@
 /**
- * Memoizes a given function by caching its result based on the arguments provided.
+ * Creates a memoized version of the provided function. The memoized function caches
+ * results based on the argument it receives, so if the same argument is passed again,
+ * it returns the cached result instead of recomputing it.
  *
- * @template F - The type of the function to memoize.
- * @template K - The type of the cache key.
- * @param func
- * @param {F} fn - The function to memoize.
- * @param {MemoizeOptions<K, ReturnType<F>>} [options] - An options object with a resolver function and/or a custom cache object.
- * @returns {F & { cache: Cache<K, ReturnType<F>> }} - The memoized function with a cache property.
+ * This function works with functions that take zero or just one argument. If your function
+ * originally takes multiple arguments, you should refactor it to take a single object or array
+ * that combines those arguments.
  *
- * @throws {TypeError} If the provided function or resolver is not valid.
+ * If the argument is not primitive (e.g., arrays or objects), provide a
+ * `getCacheKey` function to generate a unique cache key for proper caching.
+ *
+ * @param {F} fn - The function to be memoized. It should accept a single argument and return a value.
+ * @param {MemoizeOptions<Parameters<F>[0], ReturnType<F>>} [options={}] - Optional configuration for the memoization.
+ * @param {MemoizeCache<any, V>} [options.cache] - The cache object used to store results. Defaults to a new `Map`.
+ * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument.
+ *
+ * @returns {F & { cache: MemoizeCache<any, ReturnType<F>> }} - The memoized function with an additional `cache` property that exposes the internal cache.
  *
  * @example
- * // Basic usage with default cache
- * const add = (a, b) => a + b;
+ * // Example using the default cache
+ * const add = (x: number) => x + 10;
  * const memoizedAdd = memoize(add);
- * console.log(memoizedAdd(1, 2)); // 3
+ *
+ * console.log(memoizedAdd(5)); // 15
+ * console.log(memoizedAdd(5)); // 15 (cached result)
  * console.log(memoizedAdd.cache.size); // 1
  *
  * @example
- * // Using a custom resolver
- * const resolver = (...args) => args.join('-');
- * const memoizedAddWithResolver = memoize(add, { resolver });
- * console.log(memoizedAddWithResolver(1, 2)); // 3
- * console.log(memoizedAddWithResolver.cache.size); // 1
+ * // Example using a custom resolver
+ * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0);
+ * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') });
+ * console.log(memoizedSum([1, 2])); // 3
+ * console.log(memoizedSum([1, 2])); // 3 (cached result)
+ * console.log(memoizedSum.cache.size); // 1
  *
  * @example
- * // Using a custom cache
- * class CustomCache {
- *   constructor() {
- *     this.store = {};
- *   }
- *   set(key, value) {
- *     this.store[key] = value;
+ * // Example using a custom cache implementation
+ * class CustomCache<K, T> implements MemoizeCache<K, T> {
+ *   private cache = new Map<K, T>();
+ *
+ *   set(key: K, value: T): void {
+ *     this.cache.set(key, value);
  *   }
- *   get(key) {
- *     return this.store[key];
+ *
+ *   get(key: K): T | undefined {
+ *     return this.cache.get(key);
  *   }
- *   has(key) {
- *     return key in this.store;
+ *
+ *   has(key: K): boolean {
+ *     return this.cache.has(key);
  *   }
- *   delete(key) {
- *     delete this.store[key];
+ *
+ *   delete(key: K): boolean {
+ *     return this.cache.delete(key);
  *   }
- *   clear() {
- *     this.store = {};
+ *
+ *   clear(): void {
+ *     this.cache.clear();
  *   }
- *   get size() {
- *     return Object.keys(this.store).length;
+ *
+ *   get size(): number {
+ *     return this.cache.size;
  *   }
  * }
- * const customCache = new CustomCache();
- * const memoizedAddWithCustomCache = memoize(add, { cache: customCache });
- * console.log(memoizedAddWithCustomCache(1, 2)); // 3
+ * const customCache = new CustomCache<string, number>();
+ * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
  * console.log(memoizedAddWithCustomCache.cache.size); // 1
- *
- * @example
- * // Using both custom resolver and custom cache
- * const resolver = (...args) => args.join('-');
- * const customCache = new CustomCache();
- * const memoizedAddWithBoth = memoize(add, { resolver, cache: customCache });
- * console.log(memoizedAddWithBoth(1, 2)); // 3
- * console.log(memoizedAddWithBoth.cache.size); // 1
  */
-declare function memoize<F extends (...args: any[]) => any, K = Parameters<F>[0]>(fn: F, options?: MemoizeOptions<K, ReturnType<F>>): F & {
-    cache: Cache<K, ReturnType<F>>;
+declare function memoize<F extends (...args: any) => any>(fn: F, options?: {
+    cache?: MemoizeCache<any, ReturnType<F>>;
+    getCacheKey?: (args: Parameters<F>[0]) => unknown;
+}): F & {
+    cache: MemoizeCache<any, ReturnType<F>>;
 };
-interface MemoizeOptions<K, V> {
-    cache?: Cache<K, V>;
-    resolver?: (...args: any[]) => K;
-}
-interface Cache<K, V> {
+interface MemoizeCache<K, V> {
     set(key: K, value: V): void;
     get(key: K): V | undefined;
     has(key: K): boolean;
@@ -78,4 +84,4 @@ interface Cache<K, V> {
     size: number;
 }
 
-export { type Cache, type MemoizeOptions, memoize };
+export { type MemoizeCache, memoize };

package/dist/function/memoize.d.ts

@@ -1,75 +1,81 @@
 /**
- * Memoizes a given function by caching its result based on the arguments provided.
+ * Creates a memoized version of the provided function. The memoized function caches
+ * results based on the argument it receives, so if the same argument is passed again,
+ * it returns the cached result instead of recomputing it.
  *
- * @template F - The type of the function to memoize.
- * @template K - The type of the cache key.
- * @param func
- * @param {F} fn - The function to memoize.
- * @param {MemoizeOptions<K, ReturnType<F>>} [options] - An options object with a resolver function and/or a custom cache object.
- * @returns {F & { cache: Cache<K, ReturnType<F>> }} - The memoized function with a cache property.
+ * This function works with functions that take zero or just one argument. If your function
+ * originally takes multiple arguments, you should refactor it to take a single object or array
+ * that combines those arguments.
  *
- * @throws {TypeError} If the provided function or resolver is not valid.
+ * If the argument is not primitive (e.g., arrays or objects), provide a
+ * `getCacheKey` function to generate a unique cache key for proper caching.
+ *
+ * @param {F} fn - The function to be memoized. It should accept a single argument and return a value.
+ * @param {MemoizeOptions<Parameters<F>[0], ReturnType<F>>} [options={}] - Optional configuration for the memoization.
+ * @param {MemoizeCache<any, V>} [options.cache] - The cache object used to store results. Defaults to a new `Map`.
+ * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument.
+ *
+ * @returns {F & { cache: MemoizeCache<any, ReturnType<F>> }} - The memoized function with an additional `cache` property that exposes the internal cache.
  *
  * @example
- * // Basic usage with default cache
- * const add = (a, b) => a + b;
+ * // Example using the default cache
+ * const add = (x: number) => x + 10;
  * const memoizedAdd = memoize(add);
- * console.log(memoizedAdd(1, 2)); // 3
+ *
+ * console.log(memoizedAdd(5)); // 15
+ * console.log(memoizedAdd(5)); // 15 (cached result)
  * console.log(memoizedAdd.cache.size); // 1
  *
  * @example
- * // Using a custom resolver
- * const resolver = (...args) => args.join('-');
- * const memoizedAddWithResolver = memoize(add, { resolver });
- * console.log(memoizedAddWithResolver(1, 2)); // 3
- * console.log(memoizedAddWithResolver.cache.size); // 1
+ * // Example using a custom resolver
+ * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0);
+ * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') });
+ * console.log(memoizedSum([1, 2])); // 3
+ * console.log(memoizedSum([1, 2])); // 3 (cached result)
+ * console.log(memoizedSum.cache.size); // 1
  *
  * @example
- * // Using a custom cache
- * class CustomCache {
- *   constructor() {
- *     this.store = {};
- *   }
- *   set(key, value) {
- *     this.store[key] = value;
+ * // Example using a custom cache implementation
+ * class CustomCache<K, T> implements MemoizeCache<K, T> {
+ *   private cache = new Map<K, T>();
+ *
+ *   set(key: K, value: T): void {
+ *     this.cache.set(key, value);
  *   }
- *   get(key) {
- *     return this.store[key];
+ *
+ *   get(key: K): T | undefined {
+ *     return this.cache.get(key);
  *   }
- *   has(key) {
- *     return key in this.store;
+ *
+ *   has(key: K): boolean {
+ *     return this.cache.has(key);
  *   }
- *   delete(key) {
- *     delete this.store[key];
+ *
+ *   delete(key: K): boolean {
+ *     return this.cache.delete(key);
  *   }
- *   clear() {
- *     this.store = {};
+ *
+ *   clear(): void {
+ *     this.cache.clear();
  *   }
- *   get size() {
- *     return Object.keys(this.store).length;
+ *
+ *   get size(): number {
+ *     return this.cache.size;
  *   }
  * }
- * const customCache = new CustomCache();
- * const memoizedAddWithCustomCache = memoize(add, { cache: customCache });
- * console.log(memoizedAddWithCustomCache(1, 2)); // 3
+ * const customCache = new CustomCache<string, number>();
+ * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
  * console.log(memoizedAddWithCustomCache.cache.size); // 1
- *
- * @example
- * // Using both custom resolver and custom cache
- * const resolver = (...args) => args.join('-');
- * const customCache = new CustomCache();
- * const memoizedAddWithBoth = memoize(add, { resolver, cache: customCache });
- * console.log(memoizedAddWithBoth(1, 2)); // 3
- * console.log(memoizedAddWithBoth.cache.size); // 1
  */
-declare function memoize<F extends (...args: any[]) => any, K = Parameters<F>[0]>(fn: F, options?: MemoizeOptions<K, ReturnType<F>>): F & {
-    cache: Cache<K, ReturnType<F>>;
+declare function memoize<F extends (...args: any) => any>(fn: F, options?: {
+    cache?: MemoizeCache<any, ReturnType<F>>;
+    getCacheKey?: (args: Parameters<F>[0]) => unknown;
+}): F & {
+    cache: MemoizeCache<any, ReturnType<F>>;
 };
-interface MemoizeOptions<K, V> {
-    cache?: Cache<K, V>;
-    resolver?: (...args: any[]) => K;
-}
-interface Cache<K, V> {
+interface MemoizeCache<K, V> {
     set(key: K, value: V): void;
     get(key: K): V | undefined;
     has(key: K): boolean;
@@ -78,4 +84,4 @@ interface Cache<K, V> {
     size: number;
 }
 
-export { type Cache, type MemoizeOptions, memoize };
+export { type MemoizeCache, memoize };

package/dist/function/memoize.mjs

@@ -1,14 +1,11 @@
 function memoize(fn, options = {}) {
-    const { cache = new Map(), resolver } = options;
-    if (typeof fn !== 'function' || (resolver && typeof resolver !== 'function')) {
-        throw new TypeError('Expected a function and an optional resolver function');
-    }
-    const memoizedFn = function (...args) {
-        const key = resolver ? resolver.apply(this, args) : args[0];
+    const { cache = new Map(), getCacheKey } = options;
+    const memoizedFn = function (arg) {
+        const key = getCacheKey ? getCacheKey(arg) : arg;
         if (cache.has(key)) {
             return cache.get(key);
         }
-        const result = fn.apply(this, args);
+        const result = fn.call(this, arg);
         cache.set(key, result);
         return result;
     };

package/dist/index.d.mts

@@ -60,7 +60,7 @@ export { noop } from './function/noop.mjs';
 export { once } from './function/once.mjs';
 export { throttle } from './function/throttle.mjs';
 export { negate } from './function/negate.mjs';
-export { memoize } from './function/memoize.mjs';
+export { MemoizeCache, memoize } from './function/memoize.mjs';
 export { ary } from './function/ary.mjs';
 export { unary } from './function/unary.mjs';
 export { partial } from './function/partial.mjs';

package/dist/index.d.ts

@@ -60,7 +60,7 @@ export { noop } from './function/noop.js';
 export { once } from './function/once.js';
 export { throttle } from './function/throttle.js';
 export { negate } from './function/negate.js';
-export { memoize } from './function/memoize.js';
+export { MemoizeCache, memoize } from './function/memoize.js';
 export { ary } from './function/ary.js';
 export { unary } from './function/unary.js';
 export { partial } from './function/partial.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "es-toolkit",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
-  "version": "1.15.1-dev.449+3cb5c804",
+  "version": "1.15.1-dev.451+9d68f567",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {