@chriscdn/memoize 1.0.0 → 1.0.2

package/README.md

@@ -24,9 +24,13 @@ The package comes with two functions: `Memoize` and `MemoizeAsync`.
 import { Memoize, MemoizeAsync } from "@chriscdn/memoize";
 ```
 
-The `Memoize` function can be used to memoize a _synchronous_ function. The `MemoizeAsync` function can be used to memoize an _asynchronous_ function.
+The `Memoize` function can be used to memoize a _synchronous_ function. The `MemoizeAsync` function can be used to memoize an _asynchronous_ function. The cache is based [quick-lru](https://www.npmjs.com/package/quick-lru).
 
-The `MemoizeAsync` function prevents duplicate evaluations by ensuring that multiple calls with identical parameters are only processed once.
+Each call to `Memoize` or `MemoizeAsync` will create a new cache instance.
+
+The `MemoizeAsync` function prevents duplicate evaluations by ensuring multiple calls with an identical cache key is only processed once.
+
+By default, the cache key is generated by calling `JSON.stringify()` on the function arguments. This can be customized (see below).
 
 **Example (synchronous)**
 
@@ -34,6 +38,7 @@ To memoize a function:
 
 ```ts
 const _add = (x: number, y: number) => x + y;
+
 const add = Memoize(_add);
 ```
 
@@ -50,6 +55,7 @@ The asynchronous case is similar:
 
 ```ts
 const _add = async (x: number, y: number) => x + y;
+
 const add = MemoizeAsync(_add);
 
 const result = await add(5, 7);
@@ -58,17 +64,23 @@ const result = await add(5, 7);
 
 ## Options
 
-The `Memoize` and `MemoizeAsync` functions accept an `Options` parameter to control the behaviour of the cache. Each option is optional. See the section below for the defaults:
+The `Memoize` and `MemoizeAsync` functions accept an `Options` parameter to control the behaviour of the cache.
+
+```ts
+const add = MemoizeAsync(_add, options);
+```
+
+The available options are as follows, with their defaults:
 
 ```ts
 const options = {
   // maximum number of items in the cache
   maxSize: 1000,
 
-  // maximum number of milliseconds an item is to remain in the cache, undefined implies Infinity
+  // maximum number of milliseconds an item is to remain in the cache, undefined implies forever
   maxAge: undefined,
 
-  // a function for generating the cache key (must return a String)
+  // a synchronous function for generating a cache key (must return a String)
   resolver: (...args) => JSON.stringify(args),
 };
 ```

package/__tests__/memoize.test.ts

@@ -8,15 +8,15 @@ const add = (x: number, y: number) => {
   addSyncCount += 1;
   return x + y;
 };
-const addCached = Memoize(add);
 
 const addAsync = async (x: number, y: number) => {
   addAsyncCount += 1;
   return x + y;
 };
-const addCachedAsync = MemoizeAsync(addAsync);
 
 test("sync", async () => {
+  const addCached = Memoize(add);
+
   expect(addCached(1, 2)).toBe(3);
   expect(addCached(1, 2)).toBe(3);
   expect(addCached(1, 2)).toBe(3);
@@ -29,6 +29,8 @@ test("sync", async () => {
 });
 
 test("async", async () => {
+  const addCachedAsync = MemoizeAsync(addAsync);
+
   await Promise.all([
     addCachedAsync(1, 2).then((value) => expect(value).toBe(3)),
     addCachedAsync(1, 2).then((value) => expect(value).toBe(3)),
@@ -41,3 +43,14 @@ test("async", async () => {
 
   expect(addAsyncCount).toBe(2);
 });
+
+test("resolver", () => {
+  // This tests the resolver function to ensure the same value is returned for
+  // the same key.
+
+  const addCachedSameKey = Memoize(add, { resolver: (x, y) => "key" });
+
+  expect(addCachedSameKey(5, 7)).toBe(12);
+  expect(addCachedSameKey(1, 1)).toBe(12);
+  expect(addCachedSameKey(5, 1)).toBe(12);
+});

package/lib/index.d.ts

@@ -5,14 +5,8 @@ type Options<T extends any[]> = {
 };
 /**
  * Memoize a synchronous function.
- *
- * @template {any[]} Args
- * @template {{}} Return
- * @param {(...args: Args) => Return} cb
- * @param {Partial<Options<Args>>} [options={}]
- * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}
  */
-declare const Memoize: <Args extends any[], Return extends {}>(cb: (...args: Args) => Return, options?: Partial<Options<Args>>) => (...args: Args) => Return;
+declare const Memoize: <Args extends unknown[], Return>(cb: (...args: Args) => Return, options?: Partial<Options<Args>>) => (...args: Args) => Return;
 /**
  * Memoize an asynchronous function.
  *
@@ -20,10 +14,6 @@ declare const Memoize: <Args extends any[], Return extends {}>(cb: (...args: Arg
  * same arguments is only evaluated once. This is controlled by using a
  * semaphore, which forces redundant calls to wait until the first call
  * completes.
- *
- * @param cb
- * @param options
- * @returns
  */
-declare const MemoizeAsync: <Args extends any[], Return extends {}>(cb: (...args: Args) => Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>;
+declare const MemoizeAsync: <Args extends unknown[], Return>(cb: (...args: Args) => Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>;
 export { Memoize, MemoizeAsync };

package/lib/memoize.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.cjs","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Return} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}\n */\nconst Memoize = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n *\n * @param cb\n * @param options\n * @returns\n */\nconst MemoizeAsync = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key)!;\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"wMAoBgB,SACZA,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAtBX,IAwBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,uBAcqB,SACjBnB,EACAC,GACA,IAAAoB,EAAAC,OADkC,IAAlCrB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBiB,EAAGpB,EAAQG,SAAOiB,EA9DX,IAgEdhB,EAA2B,OAAnBiB,EAAGrB,EAAQI,UAAQiB,EAC5B,WAAA,OAAmBhB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCa,EAAY,IAAIC,EAAW,QAE3Bb,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDqB,IAA/BX,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BhB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbW,QAAAC,QACMJ,EAAUK,QAAQb,IAAIc,KAAA,WAAA,OAExBlB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAMW,QAAAC,QAEG3B,EAAEgB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBW,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQlB,GAAKgB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}
+{"version":3,"file":"memoize.cjs","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n */\nconst Memoize = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"wMAcgB,SACZA,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,uBAUqB,SACjBnB,EACAC,GACA,IAAAoB,EAAAC,OADkC,IAAlCrB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBiB,EAAGpB,EAAQG,SAAOiB,EApDX,IAsDdhB,EAA2B,OAAnBiB,EAAGrB,EAAQI,UAAQiB,EAC5B,WAAA,OAAmBhB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCa,EAAY,IAAIC,EAAW,QAE3Bb,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDqB,IAA/BX,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BhB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbW,QAAAC,QACMJ,EAAUK,QAAQb,IAAIc,KAAA,WAAA,OAExBlB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAKW,QAAAC,QAEI3B,EAAEgB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBW,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQlB,GAAKgB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}

package/lib/memoize.modern.js.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.modern.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Return} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}\n */\nconst Memoize = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n *\n * @param cb\n * @param options\n * @returns\n */\nconst MemoizeAsync = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key)!;\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$resolver","maxSize","resolver","args","JSON","stringify","cache","QuickLRU","maxAge","key","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$resolver2","semaphore","Semaphore","async","acquire","release"],"mappings":"oEAGA,MAiBMA,EAAUA,CACZC,EACAC,EAAkC,CAAA,KAClCC,IAAAA,EAAAC,EACA,MACMC,EAAyBF,OAAlBA,EAAGD,EAAQG,SAAOF,EAtBX,IAwBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,IAAIG,IAAeC,KAAKC,UAAUF,GAEjCG,EAAQ,IAAIC,EAAyB,CACvCC,OAP+BV,EAAQU,OAQvCP,YAGJ,MAAO,IAAIE,KACP,MAAMM,EAAMP,KAAYC,GAExB,GAAIG,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GACd,CACH,MAAMG,EAAcf,KAAMM,GAE1B,OADAG,EAAMO,IAAIJ,EAAKG,GACRA,CACV,EACL,EAeEE,EAAeA,CACjBjB,EACAC,EAAkC,CAAE,KACpC,IAAAiB,EAAAC,EACA,MAAMR,EAA6BV,EAAQU,OACrCP,EAAyB,OAAlBc,EAAGjB,EAAQG,SAAOc,EA9DX,IAgEdb,EAA2B,OAAnBc,EAAGlB,EAAQI,UAAQc,EAC5B,IAAIb,IAAeC,KAAKC,UAAUF,GAEjCc,EAAY,IAAIC,EAEhBZ,EAAQ,IAAIC,EAAyB,CACvCC,SACAP,YAGJ,OAAOkB,SAAUhB,KACb,MAAMM,EAAMP,KAAYC,GAExB,GAAIG,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GAEjB,IAGI,SAFMQ,EAAUG,QAAQX,GAEpBH,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GACd,CACH,MAAMG,QAAoBf,KAAMM,GAEhC,OADAG,EAAMO,IAAIJ,EAAKG,GACRA,CACV,CACJ,CAAA,QACGK,EAAUI,QAAQZ,EACrB,CACJ,CACL"}
+{"version":3,"file":"memoize.modern.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n */\nconst Memoize = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$resolver","maxSize","resolver","args","JSON","stringify","cache","QuickLRU","maxAge","key","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$resolver2","semaphore","Semaphore","async","acquire","release"],"mappings":"oEAGA,MAWMA,EAAUA,CACZC,EACAC,EAAkC,CAAA,KAClCC,IAAAA,EAAAC,EACA,MACMC,EAAyBF,OAAlBA,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,IAAIG,IAAeC,KAAKC,UAAUF,GAEjCG,EAAQ,IAAIC,EAAyB,CACvCC,OAP+BV,EAAQU,OAQvCP,YAGJ,MAAO,IAAIE,KACP,MAAMM,EAAMP,KAAYC,GAExB,GAAIG,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GACd,CACH,MAAMG,EAAcf,KAAMM,GAE1B,OADAG,EAAMO,IAAIJ,EAAKG,GACRA,CACV,EACL,EAWEE,EAAeA,CACjBjB,EACAC,EAAkC,CAAE,KACpC,IAAAiB,EAAAC,EACA,MAAMR,EAA6BV,EAAQU,OACrCP,EAAyB,OAAlBc,EAAGjB,EAAQG,SAAOc,EApDX,IAsDdb,EAA2B,OAAnBc,EAAGlB,EAAQI,UAAQc,EAC5B,IAAIb,IAAeC,KAAKC,UAAUF,GAEjCc,EAAY,IAAIC,EAEhBZ,EAAQ,IAAIC,EAAyB,CACvCC,SACAP,YAGJ,OAAOkB,SAAUhB,KACb,MAAMM,EAAMP,KAAYC,GAExB,GAAIG,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GAEjB,IAGI,SAFMQ,EAAUG,QAAQX,GAEpBH,EAAMI,IAAID,GACV,OAAOH,EAAMK,IAAIF,GACd,CACH,MAAMG,QAAoBf,KAAMM,GAEhC,OADAG,EAAMO,IAAIJ,EAAKG,GACRA,CACV,CACJ,CAAA,QACGK,EAAUI,QAAQZ,EACrB,CACJ,CACL"}

package/lib/memoize.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.module.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Return} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}\n */\nconst Memoize = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n *\n * @param cb\n * @param options\n * @returns\n */\nconst MemoizeAsync = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key)!;\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"oEAGA,IAiBMA,EAAU,SACZC,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAtBX,IAwBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAyB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,EAcME,EAAe,SACjBrB,EACAC,GACA,IAAAqB,EAAAC,OADkC,IAAlCtB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBkB,EAAGrB,EAAQG,SAAOkB,EA9DX,IAgEdjB,EAA2B,OAAnBkB,EAAGtB,EAAQI,UAAQkB,EAC5B,WAAA,OAAmBjB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCc,EAAY,IAAIC,EAEhBd,EAAQ,IAAIC,EAAyB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDsB,IAA/BZ,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAa,QAAAC,QAE1BjB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbY,QAAAC,QACMJ,EAAUK,QAAQd,IAAIe,KAAA,WAAA,OAExBnB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAMY,QAAAC,QAEG5B,EAAEgB,WAAIF,EAAAA,IAAKgB,KAAA,SAA/BX,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBY,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQnB,GAAKiB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}
+{"version":3,"file":"memoize.module.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n */\nconst Memoize = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"oEAGA,IAWMA,EAAU,SACZC,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAyB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,EAUME,EAAe,SACjBrB,EACAC,GACA,IAAAqB,EAAAC,OADkC,IAAlCtB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBkB,EAAGrB,EAAQG,SAAOkB,EApDX,IAsDdjB,EAA2B,OAAnBkB,EAAGtB,EAAQI,UAAQkB,EAC5B,WAAA,OAAmBjB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCc,EAAY,IAAIC,EAEhBd,EAAQ,IAAIC,EAAyB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDsB,IAA/BZ,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAa,QAAAC,QAE1BjB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbY,QAAAC,QACMJ,EAAUK,QAAQd,IAAIe,KAAA,WAAA,OAExBnB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAKY,QAAAC,QAEI5B,EAAEgB,WAAIF,EAAAA,IAAKgB,KAAA,SAA/BX,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBY,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQnB,GAAKiB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}

package/lib/memoize.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.umd.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n *\n * @template {any[]} Args\n * @template {{}} Return\n * @param {(...args: Args) => Return} cb\n * @param {Partial<Options<Args>>} [options={}]\n * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}\n */\nconst Memoize = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n *\n * @param cb\n * @param options\n * @returns\n */\nconst MemoizeAsync = <Args extends any[], Return extends {}>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key)!;\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"geAoBgB,SACZA,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAtBX,IAwBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,iBAcqB,SACjBnB,EACAC,GACA,IAAAoB,EAAAC,OADkC,IAAlCrB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBiB,EAAGpB,EAAQG,SAAOiB,EA9DX,IAgEdhB,EAA2B,OAAnBiB,EAAGrB,EAAQI,UAAQiB,EAC5B,WAAA,OAAmBhB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCa,EAAY,IAAIC,EAAW,QAE3Bb,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDqB,IAA/BX,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BhB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbW,QAAAC,QACMJ,EAAUK,QAAQb,IAAIc,KAAA,WAAA,OAExBlB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAMW,QAAAC,QAEG3B,EAAEgB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBW,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQlB,GAAKgB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}
+{"version":3,"file":"memoize.umd.js","sources":["../src/index.ts"],"sourcesContent":["import Semaphore from \"@chriscdn/promise-semaphore\";\nimport QuickLRU from \"quick-lru\";\n\nconst kDefaultMaxSize = 1000;\n\ntype Options<T extends any[]> = {\n    maxSize: number;\n    maxAge?: number;\n    resolver: (...args: T) => string;\n};\n\n/**\n * Memoize a synchronous function.\n */\nconst Memoize = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Return,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return (...args: Args): Return => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key);\n        } else {\n            const returnValue = cb(...args);\n            cache.set(key, returnValue);\n            return returnValue;\n        }\n    };\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    return async (...args: Args): Promise<Return> => {\n        const key = resolver(...args);\n\n        if (cache.has(key)) {\n            return cache.get(key)!;\n        } else {\n            try {\n                await semaphore.acquire(key);\n\n                if (cache.has(key)) {\n                    return cache.get(key);\n                } else {\n                    const returnValue = await cb(...args);\n                    cache.set(key, returnValue);\n                    return returnValue;\n                }\n            } finally {\n                semaphore.release(key);\n            }\n        }\n    };\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","args","key","apply","has","get","returnValue","set","_options$maxSize2","_options$resolver2","semaphore","Semaphore","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"geAcgB,SACZA,EACAC,GACA,IAAAC,EAAAC,OADkC,IAAlCF,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGJ,kBAAW,IAAAU,EAAU,GAAAN,MAAAC,KAAAC,WACXK,EAAMV,EAAQW,WAAA,EAAIF,GAExB,GAAIH,EAAMM,IAAIF,GACV,OAAOJ,EAAMO,IAAIH,GAEjB,IAAMI,EAAcnB,EAAEgB,WAAIF,EAAAA,GAE1B,OADAH,EAAMS,IAAIL,EAAKI,GACRA,CAEf,CACJ,iBAUqB,SACjBnB,EACAC,GACA,IAAAoB,EAAAC,OADkC,IAAlCrB,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyB,OAAlBiB,EAAGpB,EAAQG,SAAOiB,EApDX,IAsDdhB,EAA2B,OAAnBiB,EAAGrB,EAAQI,UAAQiB,EAC5B,WAAA,OAAmBhB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEtCa,EAAY,IAAIC,EAAW,QAE3Bb,EAAQ,IAAIC,EAAQ,QAAiB,CACvCC,OAAAA,EACAT,QAAAA,IAGJ,OAAA,WAAA,IAAgDqB,IAA/BX,EAAU,GAAAN,MAAAC,KAAqBC,WACtCK,EAAMV,EAAQW,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BhB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,2BAEbW,QAAAC,QACMJ,EAAUK,QAAQb,IAAIc,KAAA,WAAA,OAExBlB,EAAMM,IAAIF,GACHJ,EAAMO,IAAIH,GAAKW,QAAAC,QAEI3B,EAAEgB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAEN,OADAR,EAAMS,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBW,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQlB,GAAKgB,EAAAC,MAAAA,EAAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EACL,CAAA,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chriscdn/memoize",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Memoize a synchronous or asynchronous function.",
   "repository": "https://github.com/chriscdn/memoize",
   "author": "Christopher Meyer <chris@schwiiz.org>",
@@ -27,6 +27,6 @@
   },
   "devDependencies": {
     "microbundle": "^0.15.1",
-    "vitest": "^2.1.3"
+    "vitest": "^2.1.4"
   }
 }

package/src/index.ts

@@ -11,14 +11,8 @@ type Options<T extends any[]> = {
 
 /**
  * Memoize a synchronous function.
- *
- * @template {any[]} Args
- * @template {{}} Return
- * @param {(...args: Args) => Return} cb
- * @param {Partial<Options<Args>>} [options={}]
- * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}
  */
-const Memoize = <Args extends any[], Return extends {}>(
+const Memoize = <Args extends unknown[], Return>(
     cb: (...args: Args) => Return,
     options: Partial<Options<Args>> = {},
 ) => {
@@ -37,7 +31,7 @@ const Memoize = <Args extends any[], Return extends {}>(
         const key = resolver(...args);
 
         if (cache.has(key)) {
-            return cache.get(key)!;
+            return cache.get(key);
         } else {
             const returnValue = cb(...args);
             cache.set(key, returnValue);
@@ -53,12 +47,8 @@ const Memoize = <Args extends any[], Return extends {}>(
  * same arguments is only evaluated once. This is controlled by using a
  * semaphore, which forces redundant calls to wait until the first call
  * completes.
- *
- * @param cb
- * @param options
- * @returns
  */
-const MemoizeAsync = <Args extends any[], Return extends {}>(
+const MemoizeAsync = <Args extends unknown[], Return>(
     cb: (...args: Args) => Promise<Return>,
     options: Partial<Options<Args>> = {},
 ) => {
@@ -85,7 +75,7 @@ const MemoizeAsync = <Args extends any[], Return extends {}>(
                 await semaphore.acquire(key);
 
                 if (cache.has(key)) {
-                    return cache.get(key)!;
+                    return cache.get(key);
                 } else {
                     const returnValue = await cb(...args);
                     cache.set(key, returnValue);