@chriscdn/memoize 1.0.5 → 1.0.7

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Christopher Meyer
+Copyright (c) 2024-2025 Christopher Meyer
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -18,21 +18,22 @@ yarn add @chriscdn/memoize
 
 ## Usage
 
-The package comes with two functions: `Memoize` and `MemoizeAsync`.
+The package provides two functions: `Memoize` and `MemoizeAsync`.
 
 ```ts
 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 cache is based [quick-lru](https://www.npmjs.com/package/quick-lru).
+- **`Memoize`** is used to memoize a _synchronous_ function.
+- **`MemoizeAsync`** is used to memoize an _asynchronous_ function.
 
-Each call to `Memoize` or `MemoizeAsync` will create a new cache instance.
+The cache is powered by [quick-lru](https://www.npmjs.com/package/quick-lru). Each call to `Memoize` or `MemoizeAsync` creates a new cache instance.
 
-The `MemoizeAsync` function prevents duplicate evaluations by ensuring multiple calls with an identical cache key is only processed once.
+The `MemoizeAsync` function prevents duplicate evaluations by ensuring that multiple calls with the same cache key are processed only once.
 
-By default, the cache key is generated by calling `JSON.stringify()` on the function arguments. This can be customized (see below).
+By default, the cache key is generated by calling `JSON.stringify()` on the function arguments. This behavior can be customized (see below).
 
-**Example (synchronous)**
+### Example (Synchronous)
 
 To memoize a function:
 
@@ -49,9 +50,15 @@ const result = add(5, 7);
 // 12
 ```
 
-**Example (asynchronous)**
+You can also define the function in a single line:
 
-The asynchronous case is similar:
+```ts
+const add = Memoize((x: number, y: number) => x + y);
+```
+
+### Example (Asynchronous)
+
+Memoizing an asynchronous function is similar:
 
 ```ts
 const _add = async (x: number, y: number) => x + y;
@@ -64,44 +71,52 @@ const result = await add(5, 7);
 
 ## Options
 
-The `Memoize` and `MemoizeAsync` functions accept an `Options` parameter to control the behaviour of the cache.
+Both `Memoize` and `MemoizeAsync` accept an `options` parameter to control the cache behavior:
 
 ```ts
 const add = MemoizeAsync(_add, options);
 ```
 
-The available options are as follows, with their defaults:
+Available options (with defaults):
 
 ```ts
 const options = {
-  // maximum number of items in the cache
+  // Maximum number of items in the cache
   maxSize: 1000,
 
-  // maximum number of milliseconds an item is to remain in the cache, undefined implies forever
+  // Maximum lifespan of an item in milliseconds; undefined means items never expire
   maxAge: undefined,
 
-  // a synchronous function for generating a cache key (must return a String)
+  // A synchronous function whether to add the returnValue to the cache.
+  shouldCache: (returnValue: Return, key: string) => true,
+
+  // A synchronous function to generate cache keys (must return a string)
   resolver: (...args) => JSON.stringify(args),
 };
 ```
 
 ## Cache
 
-The underlying [quick-lru](https://www.npmjs.com/package/quick-lru) instance can be accessed with the `.cache` property on the memoized function.
+The underlying [quick-lru](https://www.npmjs.com/package/quick-lru) instance is accessible via the `.cache` property on the memoized function:
 
 ```ts
 const add = MemoizeAsync(_add);
 const result = await add(5, 7);
 
-console.log(addCachedAsync.cache.size === 1);
+console.log(add.cache.size === 1);
 // true
+
+// Clear the cache
+add.cache.clear();
 ```
 
+The values `null` and `undefined` are cached by default, but this behavior can be adjusted using the `shouldCache` option.
+
 ## Class Methods
 
-Class methods can also be memoized, though this requires overriding the method within the constructor. When doing so, it's important to bind the method to the instance to ensure it maintains the correct context.
+Class methods can also be memoized, but this requires overriding the method within the constructor. Ensure you bind the method to the instance to maintain the correct context.
 
-Consider the following example, where the `add` method is memoized by reassigning it within the constructor after binding it to the current instance. This ensures the memoized version retains access to instance properties like `count` and keeps TypeScript happy by preserving the method's type signature.
+Here's an example where the `add` method is memoized by reassigning it within the constructor. This approach preserves access to instance properties (like `count`) and maintains the correct method signature in TypeScript:
 
 ```ts
 class AddClass {
@@ -118,10 +133,12 @@ class AddClass {
 }
 ```
 
-Keep in mind that each instance of a class will maintain its own separate cache.
+Each memoized method in each class instance maintains its own cache.
 
 ## Tests
 
+Run the tests using:
+
 ```bash
 yarn test
 ```

package/__tests__/memoize.test.ts

@@ -102,3 +102,62 @@ describe("Memoization of Class methods", () => {
     expect(obj.count).toBe(2);
   });
 });
+
+describe("Null & Undefined Cases", () => {
+  const UndefinedFunc = Memoize((key: string) => undefined, {
+    resolver: (key) => key,
+  });
+
+  const NullFunc = Memoize((key: string) => undefined, {
+    resolver: (key) => key,
+  });
+
+  it("Undefined", () => {
+    expect(UndefinedFunc.cache.has("hello")).toBe(false);
+    expect(UndefinedFunc("hello")).toBe(undefined);
+    expect(UndefinedFunc.cache.has("hello")).toBe(true);
+    expect(UndefinedFunc("hello")).toBe(undefined);
+  });
+
+  it("Null", () => {
+    expect(NullFunc.cache.has("hello")).toBe(false);
+    expect(NullFunc("hello")).toBe(undefined);
+    expect(NullFunc.cache.has("hello")).toBe(true);
+    expect(NullFunc("hello")).toBe(undefined);
+  });
+});
+
+describe("Object Reference", () => {
+  const a = { hello: "world" };
+
+  const funny = Memoize(() => a);
+
+  it("Null", () => {
+    expect(funny().hello).toBe("world");
+  });
+
+  it("Null", () => {
+    a.hello = "mars";
+    expect(funny().hello).toBe("mars");
+  });
+});
+
+describe("ShouldCache", () => {
+  const doNotCache = "do not cache";
+
+  const myFunction = Memoize((word: string) => word, {
+    shouldCache: (value) => value !== doNotCache,
+    resolver: (value) => value,
+  });
+
+  myFunction("hi");
+  myFunction(doNotCache);
+
+  it("should be cached", () => {
+    expect(myFunction.cache.has("hi")).toBe(true);
+  });
+
+  it("should not be cached", () => {
+    expect(myFunction.cache.has(doNotCache)).toBe(false);
+  });
+});

package/lib/index.d.ts

@@ -1,13 +1,14 @@
 import QuickLRU from "quick-lru";
-type Options<T extends any[]> = {
+type Options<T extends any[], Return> = {
     maxSize: number;
     maxAge?: number;
+    shouldCache: (returnValue: Return, key: string) => boolean;
     resolver: (...args: T) => string;
 };
 /**
  * Memoize a synchronous function.
  */
-declare const Memoize: <Args extends unknown[], Return>(cb: (...args: Args) => Return, options?: Partial<Options<Args>>) => {
+declare const Memoize: <Args extends unknown[], Return>(cb: (...args: Args) => Return, options?: Partial<Options<Args, Return>>) => {
     (...args: Args): Return;
     cache: QuickLRU<string, Return>;
 };
@@ -19,7 +20,7 @@ declare const Memoize: <Args extends unknown[], Return>(cb: (...args: Args) => R
  * semaphore, which forces redundant calls to wait until the first call
  * completes.
  */
-declare const MemoizeAsync: <Args extends unknown[], Return>(cb: (...args: Args) => Promise<Return>, options?: Partial<Options<Args>>) => {
+declare const MemoizeAsync: <Args extends unknown[], Return>(cb: (...args: Args) => Promise<Return>, options?: Partial<Options<Args, Return>>) => {
     (...args: Args): Promise<Return>;
     cache: QuickLRU<string, Return>;
 };

package/lib/memoize.cjs

@@ -1,2 +1,2 @@
-var e=require("@chriscdn/promise-semaphore"),r=require("quick-lru");function n(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var t=/*#__PURE__*/n(e),i=/*#__PURE__*/n(r);exports.Memoize=function(e,r){var n,t;void 0===r&&(r={});var a=null!=(n=r.maxSize)?n:1e3,u=null!=(t=r.resolver)?t:function(){return JSON.stringify([].slice.call(arguments))},l=new i.default({maxAge:r.maxAge,maxSize:a}),o=function(){var r=[].slice.call(arguments),n=u.apply(void 0,r);if(l.has(n))return l.get(n);var t=e.apply(void 0,r);return l.set(n,t),t};return o.cache=l,o},exports.MemoizeAsync=function(e,r){var n,a;void 0===r&&(r={});var u=r.maxAge,l=null!=(n=r.maxSize)?n:1e3,o=null!=(a=r.resolver)?a:function(){return JSON.stringify([].slice.call(arguments))},c=new t.default,s=new i.default({maxAge:u,maxSize:l}),f=function(){try{var r=[].slice.call(arguments),n=o.apply(void 0,r);return Promise.resolve(s.has(n)?s.get(n):function(t,i){try{var a=Promise.resolve(c.acquire(n)).then(function(){return s.has(n)?s.get(n):Promise.resolve(e.apply(void 0,r)).then(function(e){return s.set(n,e),e})})}catch(e){return i(!0,e)}return a&&a.then?a.then(i.bind(null,!1),i.bind(null,!0)):i(!1,a)}(0,function(e,r){if(c.release(n),e)throw r;return r}))}catch(e){return Promise.reject(e)}};return f.cache=s,f};
+var e=require("@chriscdn/promise-semaphore"),r=require("quick-lru");function n(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var t=/*#__PURE__*/n(e),u=/*#__PURE__*/n(r);exports.Memoize=function(e,r){var n,t,i;void 0===r&&(r={});var l=null!=(n=r.maxSize)?n:1e3,a=null!=(t=r.shouldCache)?t:function(){return!0},o=null!=(i=r.resolver)?i:function(){return JSON.stringify([].slice.call(arguments))},c=new u.default({maxAge:r.maxAge,maxSize:l}),s=function(){var r=[].slice.call(arguments),n=o.apply(void 0,r);if(c.has(n))return c.get(n);var t=e.apply(void 0,r);return a(t,n)&&c.set(n,t),t};return s.cache=c,s},exports.MemoizeAsync=function(e,r){var n,i,l;void 0===r&&(r={});var a=r.maxAge,o=null!=(n=r.maxSize)?n:1e3,c=null!=(i=r.shouldCache)?i:function(){return!0},s=null!=(l=r.resolver)?l:function(){return JSON.stringify([].slice.call(arguments))},f=new t.default,v=new u.default({maxAge:a,maxSize:o}),h=function(){try{var r=[].slice.call(arguments),n=s.apply(void 0,r);return Promise.resolve(v.has(n)?v.get(n):function(t,u){try{var i=Promise.resolve(f.acquire(n)).then(function(){return v.has(n)?v.get(n):Promise.resolve(e.apply(void 0,r)).then(function(e){return c(e,n)&&v.set(n,e),e})})}catch(e){return u(!0,e)}return i&&i.then?i.then(u.bind(null,!1),u.bind(null,!0)):u(!1,i)}(0,function(e,r){if(f.release(n),e)throw r;return r}))}catch(e){return Promise.reject(e)}};return h.cache=v,h};
 //# sourceMappingURL=memoize.cjs.map

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 */\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 =\n    options.resolver ?? ((...args: Args) => JSON.stringify(args));\n\n  const cache = new QuickLRU<string, Return>({\n    maxAge,\n    maxSize,\n  });\n\n  const memoizedFunction = (...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  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the synchronous 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 =\n    options.resolver ?? ((...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  const memoizedFunction = 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  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","memoizedFunction","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,SACdA,EACAC,GACEC,IAAAA,EAAAC,OADFF,IAAAA,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAhBT,IAkBhBG,EACY,OADJF,EACZF,EAAQI,UAAQF,EAAK,WAAmB,OAAAG,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAExDC,EAAQ,IAAIC,EAAAA,QAAyB,CACzCC,OAPiCZ,EAAQY,OAQzCT,QAAAA,IAGIU,EAAmB,WAAI,IAAAC,EAAUP,GAAAA,MAAAC,KAAAC,WAC/BM,EAAMX,EAAQY,WAAIF,EAAAA,GAExB,GAAIJ,EAAMO,IAAIF,GACZ,OAAOL,EAAMQ,IAAIH,GAEjB,IAAMI,EAAcpB,EAAEiB,WAAIF,EAAAA,GAE1B,OADAJ,EAAMU,IAAIL,EAAKI,GACRA,CAEX,EAIA,OAFAN,EAAiBH,MAAQA,EAElBG,CACT,uBAUqB,SACnBd,EACAC,GACEqB,IAAAA,EAAAC,OADFtB,IAAAA,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyBkB,OAAlBA,EAAGrB,EAAQG,SAAOkB,EAxDT,IA0DhBjB,EACYkB,OADJA,EACZtB,EAAQI,UAAQkB,EAAK,WAAmB,OAAAjB,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAExDc,EAAY,IAAIC,EAAW,QAE3Bd,EAAQ,IAAIC,EAAAA,QAAyB,CACzCC,OAAAA,EACAT,QAAAA,IAGIU,EAAA,eAA4DY,IAA/BX,EAAU,GAAAP,MAAAC,KAAqBC,WAC1DM,EAAMX,EAAQY,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BjB,EAAMO,IAAIF,GACLL,EAAMQ,IAAIH,2BAEbW,QAAAC,QACIJ,EAAUK,QAAQb,IAAIc,KAAA,WAAA,OAExBnB,EAAMO,IAAIF,GACLL,EAAMQ,IAAIH,GAAKW,QAAAC,QAEI5B,EAAEiB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAEN,OADAT,EAAMU,IAAIL,EAAKI,GACRA,CAAY,EAEtB,4FAZsBW,CAEnB,EAUHC,SAAAA,EAAAC,GACwB,GAAvBT,EAAUU,QAAQlB,GAAKgB,EAAA,MAAAC,EAAA,OAAAA,CAAA,GAG7B,CAAC,MAAAE,GAAA,OAAAR,QAAAS,OAAAD,EAEDrB,CAAAA,EAEA,OAFAA,EAAiBH,MAAQA,EAElBG,CACT"}
+{"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[], Return> = {\n  maxSize: number;\n  maxAge?: number;\n  shouldCache: (returnValue: Return, key: string) => boolean;\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, Return>> = {},\n) => {\n  const maxAge: number | undefined = options.maxAge;\n  const maxSize = options.maxSize ?? kDefaultMaxSize;\n  const shouldCache = options.shouldCache ?? (() => true);\n\n  const resolver =\n    options.resolver ?? ((...args: Args) => JSON.stringify(args));\n\n  const cache = new QuickLRU<string, Return>({\n    maxAge,\n    maxSize,\n  });\n\n  const memoizedFunction = (...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      if (shouldCache(returnValue, key)) {\n        cache.set(key, returnValue);\n      }\n      return returnValue;\n    }\n  };\n\n  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the synchronous 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, Return>> = {},\n) => {\n  const maxAge: number | undefined = options.maxAge;\n  const maxSize = options.maxSize ?? kDefaultMaxSize;\n  const shouldCache = options.shouldCache ?? (() => true);\n\n  const resolver =\n    options.resolver ?? ((...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  const memoizedFunction = 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\n          if (shouldCache(returnValue, key)) {\n            cache.set(key, returnValue);\n          }\n\n          return returnValue;\n        }\n      } finally {\n        semaphore.release(key);\n      }\n    }\n  };\n\n  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["cb","options","_options$maxSize","_options$shouldCache","_options$resolver","maxSize","shouldCache","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","memoizedFunction","args","key","apply","has","get","returnValue","set","_options$maxSize2","_options$shouldCache2","_options$resolver2","semaphore","Semaphore","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"wMAegB,SACdA,EACAC,GACE,IAAAC,EAAAC,EAAAC,OADFH,IAAAA,IAAAA,EAA0C,CAAA,GAE1C,IACMI,EAAyBH,OAAlBA,EAAGD,EAAQI,SAAOH,EAjBT,IAkBhBI,EAAiCH,OAAtBA,EAAGF,EAAQK,aAAWH,EAAK,WAAM,OAAA,CAAI,EAEhDI,EACYH,OADJA,EACZH,EAAQM,UAAQH,EAAK,WAAA,OAAmBI,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAExDC,EAAQ,IAAIC,UAAyB,CACzCC,OARiCd,EAAQc,OASzCV,QAAAA,IAGIW,EAAmB,WAAI,IAAAC,EAAU,GAAAP,MAAAC,KAAAC,WAC/BM,EAAMX,EAAQY,WAAA,EAAIF,GAExB,GAAIJ,EAAMO,IAAIF,GACZ,OAAOL,EAAMQ,IAAIH,GAEjB,IAAMI,EAActB,EAAEmB,WAAIF,EAAAA,GAI1B,OAHIX,EAAYgB,EAAaJ,IAC3BL,EAAMU,IAAIL,EAAKI,GAEVA,CAEX,EAIA,OAFAN,EAAiBH,MAAQA,EAElBG,CACT,uBAUqB,SACnBhB,EACAC,GACEuB,IAAAA,EAAAC,EAAAC,OADwC,IAA1CzB,IAAAA,EAA0C,IAE1C,IAAMc,EAA6Bd,EAAQc,OACrCV,EAAyBmB,OAAlBA,EAAGvB,EAAQI,SAAOmB,EA5DT,IA6DhBlB,EAAiCmB,OAAtBA,EAAGxB,EAAQK,aAAWmB,EAAK,WAAM,OAAA,CAAI,EAEhDlB,SAAQmB,EACZzB,EAAQM,UAAQmB,EAAK,WAAmB,OAAAlB,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAExDe,EAAY,IAAIC,EAAW,QAE3Bf,EAAQ,IAAIC,EAAAA,QAAyB,CACzCC,OAAAA,EACAV,QAAAA,IAGIW,EAAA,WAA4D,IAAA,IAA/BC,EAAUP,GAAAA,MAAAC,KAAqBC,WAC1DM,EAAMX,EAAQY,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BjB,EAAMO,IAAIF,GACLL,EAAMQ,IAAIH,2BAEbW,QAAAC,QACIH,EAAUI,QAAQb,IAAIc,KAExBnB,WAAAA,OAAAA,EAAMO,IAAIF,GACLL,EAAMQ,IAAIH,GAAKW,QAAAC,QAEI9B,EAAEmB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAMN,OAJIhB,EAAYgB,EAAaJ,IAC3BL,EAAMU,IAAIL,EAAKI,GAGVA,CAAY,EAEtB,4FAhBsBW,YAgBtBC,EAAAC,GACwB,GAAvBR,EAAUS,QAAQlB,GAAKgB,QAAAC,EAAA,OAAAA,CAAA,GAG7B,CAAC,MAAAE,GAAA,OAAAR,QAAAS,OAAAD,EAEDrB,CAAAA,EAEA,OAFAA,EAAiBH,MAAQA,EAElBG,CACT"}

package/lib/memoize.modern.js

@@ -1,2 +1,2 @@
-import e from"@chriscdn/promise-semaphore";import r from"quick-lru";const t=(e,t={})=>{var n,a;const s=null!=(n=t.maxSize)?n:1e3,i=null!=(a=t.resolver)?a:(...e)=>JSON.stringify(e),c=new r({maxAge:t.maxAge,maxSize:s}),o=(...r)=>{const t=i(...r);if(c.has(t))return c.get(t);{const n=e(...r);return c.set(t,n),n}};return o.cache=c,o},n=(t,n={})=>{var a,s;const i=n.maxAge,c=null!=(a=n.maxSize)?a:1e3,o=null!=(s=n.resolver)?s:(...e)=>JSON.stringify(e),l=new e,m=new r({maxAge:i,maxSize:c}),u=async(...e)=>{const r=o(...e);if(m.has(r))return m.get(r);try{if(await l.acquire(r),m.has(r))return m.get(r);{const n=await t(...e);return m.set(r,n),n}}finally{l.release(r)}};return u.cache=m,u};export{t as Memoize,n as MemoizeAsync};
+import e from"@chriscdn/promise-semaphore";import r from"quick-lru";const n=(e,n={})=>{var t,a,s;const i=null!=(t=n.maxSize)?t:1e3,l=null!=(a=n.shouldCache)?a:()=>!0,c=null!=(s=n.resolver)?s:(...e)=>JSON.stringify(e),o=new r({maxAge:n.maxAge,maxSize:i}),u=(...r)=>{const n=c(...r);if(o.has(n))return o.get(n);{const t=e(...r);return l(t,n)&&o.set(n,t),t}};return u.cache=o,u},t=(n,t={})=>{var a,s,i;const l=t.maxAge,c=null!=(a=t.maxSize)?a:1e3,o=null!=(s=t.shouldCache)?s:()=>!0,u=null!=(i=t.resolver)?i:(...e)=>JSON.stringify(e),m=new e,h=new r({maxAge:l,maxSize:c}),g=async(...e)=>{const r=u(...e);if(h.has(r))return h.get(r);try{if(await m.acquire(r),h.has(r))return h.get(r);{const t=await n(...e);return o(t,r)&&h.set(r,t),t}}finally{m.release(r)}};return g.cache=h,g};export{n as Memoize,t as MemoizeAsync};
 //# sourceMappingURL=memoize.modern.js.map

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 */\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 =\n    options.resolver ?? ((...args: Args) => JSON.stringify(args));\n\n  const cache = new QuickLRU<string, Return>({\n    maxAge,\n    maxSize,\n  });\n\n  const memoizedFunction = (...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  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the synchronous 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 =\n    options.resolver ?? ((...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  const memoizedFunction = 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  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$resolver","maxSize","resolver","args","JSON","stringify","cache","QuickLRU","maxAge","memoizedFunction","key","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$resolver2","semaphore","Semaphore","async","acquire","release"],"mappings":"oEAGA,MAWMA,EAAUA,CACdC,EACAC,EAAkC,CAAA,KAChC,IAAAC,EAAAC,EACF,MACMC,SAAOF,EAAGD,EAAQG,SAAOF,EAhBT,IAkBhBG,EACY,OADJF,EACZF,EAAQI,UAAQF,EAAK,IAAIG,IAAeC,KAAKC,UAAUF,GAEnDG,EAAQ,IAAIC,EAAyB,CACzCC,OAPiCV,EAAQU,OAQzCP,YAGIQ,EAAmBA,IAAIN,KAC3B,MAAMO,EAAMR,KAAYC,GAExB,GAAIG,EAAMK,IAAID,GACZ,OAAOJ,EAAMM,IAAIF,GACZ,CACL,MAAMG,EAAchB,KAAMM,GAE1B,OADAG,EAAMQ,IAAIJ,EAAKG,GACRA,CACR,GAKH,OAFAJ,EAAiBH,MAAQA,EAElBG,GAWHM,EAAeA,CACnBlB,EACAC,EAAkC,CAAA,KAChC,IAAAkB,EAAAC,EACF,MAAMT,EAA6BV,EAAQU,OACrCP,EAAyBe,OAAlBA,EAAGlB,EAAQG,SAAOe,EAxDT,IA0DhBd,SAAQe,EACZnB,EAAQI,UAAQe,EAAK,IAAId,IAAeC,KAAKC,UAAUF,GAEnDe,EAAY,IAAIC,EAEhBb,EAAQ,IAAIC,EAAyB,CACzCC,SACAP,YAGIQ,EAAmBW,SAAUjB,KACjC,MAAMO,EAAMR,KAAYC,GAExB,GAAIG,EAAMK,IAAID,GACZ,OAAOJ,EAAMM,IAAIF,GAEjB,IAGE,SAFMQ,EAAUG,QAAQX,GAEpBJ,EAAMK,IAAID,GACZ,OAAOJ,EAAMM,IAAIF,GACZ,CACL,MAAMG,QAAoBhB,KAAMM,GAEhC,OADAG,EAAMQ,IAAIJ,EAAKG,GACRA,CACR,CACF,CAAA,QACCK,EAAUI,QAAQZ,EACnB,CACF,EAKH,OAFAD,EAAiBH,MAAQA,EAElBG"}
+{"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[], Return> = {\n  maxSize: number;\n  maxAge?: number;\n  shouldCache: (returnValue: Return, key: string) => boolean;\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, Return>> = {},\n) => {\n  const maxAge: number | undefined = options.maxAge;\n  const maxSize = options.maxSize ?? kDefaultMaxSize;\n  const shouldCache = options.shouldCache ?? (() => true);\n\n  const resolver =\n    options.resolver ?? ((...args: Args) => JSON.stringify(args));\n\n  const cache = new QuickLRU<string, Return>({\n    maxAge,\n    maxSize,\n  });\n\n  const memoizedFunction = (...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      if (shouldCache(returnValue, key)) {\n        cache.set(key, returnValue);\n      }\n      return returnValue;\n    }\n  };\n\n  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the synchronous 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, Return>> = {},\n) => {\n  const maxAge: number | undefined = options.maxAge;\n  const maxSize = options.maxSize ?? kDefaultMaxSize;\n  const shouldCache = options.shouldCache ?? (() => true);\n\n  const resolver =\n    options.resolver ?? ((...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  const memoizedFunction = 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\n          if (shouldCache(returnValue, key)) {\n            cache.set(key, returnValue);\n          }\n\n          return returnValue;\n        }\n      } finally {\n        semaphore.release(key);\n      }\n    }\n  };\n\n  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$shouldCache","_options$resolver","maxSize","shouldCache","resolver","args","JSON","stringify","cache","QuickLRU","maxAge","memoizedFunction","key","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$shouldCache2","_options$resolver2","semaphore","Semaphore","async","acquire","release"],"mappings":"oEAGA,MAYMA,EAAUA,CACdC,EACAC,EAA0C,CAAA,KACxCC,IAAAA,EAAAC,EAAAC,EACF,MACMC,EAAyBH,OAAlBA,EAAGD,EAAQI,SAAOH,EAjBT,IAkBhBI,EAAiC,OAAtBH,EAAGF,EAAQK,aAAWH,EAAK,KAAM,EAE5CI,SAAQH,EACZH,EAAQM,UAAQH,EAAK,IAAII,IAAeC,KAAKC,UAAUF,GAEnDG,EAAQ,IAAIC,EAAyB,CACzCC,OARiCZ,EAAQY,OASzCR,YAGIS,EAAmBA,IAAIN,KAC3B,MAAMO,EAAMR,KAAYC,GAExB,GAAIG,EAAMK,IAAID,GACZ,OAAOJ,EAAMM,IAAIF,GACZ,CACL,MAAMG,EAAclB,KAAMQ,GAI1B,OAHIF,EAAYY,EAAaH,IAC3BJ,EAAMQ,IAAIJ,EAAKG,GAEVA,CACR,GAKH,OAFAJ,EAAiBH,MAAQA,EAElBG,GAWHM,EAAeA,CACnBpB,EACAC,EAA0C,CAAE,SAC1CoB,EAAAC,EAAAC,EACF,MAAMV,EAA6BZ,EAAQY,OACrCR,EAAyB,OAAlBgB,EAAGpB,EAAQI,SAAOgB,EA5DT,IA6DhBf,EAAiCgB,OAAtBA,EAAGrB,EAAQK,aAAWgB,EAAK,KAAM,EAE5Cf,EACY,OADJgB,EACZtB,EAAQM,UAAQgB,EAAK,IAAIf,IAAeC,KAAKC,UAAUF,GAEnDgB,EAAY,IAAIC,EAEhBd,EAAQ,IAAIC,EAAyB,CACzCC,SACAR,YAGIS,EAAmBY,SAAUlB,KACjC,MAAMO,EAAMR,KAAYC,GAExB,GAAIG,EAAMK,IAAID,GACZ,OAAOJ,EAAMM,IAAIF,GAEjB,IAGE,SAFMS,EAAUG,QAAQZ,GAEpBJ,EAAMK,IAAID,GACZ,OAAOJ,EAAMM,IAAIF,GACZ,CACL,MAAMG,QAAoBlB,KAAMQ,GAMhC,OAJIF,EAAYY,EAAaH,IAC3BJ,EAAMQ,IAAIJ,EAAKG,GAGVA,CACR,CACF,CAAA,QACCM,EAAUI,QAAQb,EACnB,CACF,EAKH,OAFAD,EAAiBH,MAAQA,EAElBG"}

package/lib/memoize.module.js

@@ -1,2 +1,2 @@
-import e from"@chriscdn/promise-semaphore";import r from"quick-lru";var n=function(e,n){var t,i;void 0===n&&(n={});var a=null!=(t=n.maxSize)?t:1e3,l=null!=(i=n.resolver)?i:function(){return JSON.stringify([].slice.call(arguments))},o=new r({maxAge:n.maxAge,maxSize:a}),u=function(){var r=[].slice.call(arguments),n=l.apply(void 0,r);if(o.has(n))return o.get(n);var t=e.apply(void 0,r);return o.set(n,t),t};return u.cache=o,u},t=function(n,t){var i,a;void 0===t&&(t={});var l=t.maxAge,o=null!=(i=t.maxSize)?i:1e3,u=null!=(a=t.resolver)?a:function(){return JSON.stringify([].slice.call(arguments))},c=new e,s=new r({maxAge:l,maxSize:o}),v=function(){try{var e=[].slice.call(arguments),r=u.apply(void 0,e);return Promise.resolve(s.has(r)?s.get(r):function(t,i){try{var a=Promise.resolve(c.acquire(r)).then(function(){return s.has(r)?s.get(r):Promise.resolve(n.apply(void 0,e)).then(function(e){return s.set(r,e),e})})}catch(e){return i(!0,e)}return a&&a.then?a.then(i.bind(null,!1),i.bind(null,!0)):i(!1,a)}(0,function(e,n){if(c.release(r),e)throw n;return n}))}catch(e){return Promise.reject(e)}};return v.cache=s,v};export{n as Memoize,t as MemoizeAsync};
+import e from"@chriscdn/promise-semaphore";import r from"quick-lru";var n=function(e,n){var t,i,l;void 0===n&&(n={});var u=null!=(t=n.maxSize)?t:1e3,a=null!=(i=n.shouldCache)?i:function(){return!0},o=null!=(l=n.resolver)?l:function(){return JSON.stringify([].slice.call(arguments))},c=new r({maxAge:n.maxAge,maxSize:u}),s=function(){var r=[].slice.call(arguments),n=o.apply(void 0,r);if(c.has(n))return c.get(n);var t=e.apply(void 0,r);return a(t,n)&&c.set(n,t),t};return s.cache=c,s},t=function(n,t){var i,l,u;void 0===t&&(t={});var a=t.maxAge,o=null!=(i=t.maxSize)?i:1e3,c=null!=(l=t.shouldCache)?l:function(){return!0},s=null!=(u=t.resolver)?u:function(){return JSON.stringify([].slice.call(arguments))},v=new e,f=new r({maxAge:a,maxSize:o}),h=function(){try{var e=[].slice.call(arguments),r=s.apply(void 0,e);return Promise.resolve(f.has(r)?f.get(r):function(t,i){try{var l=Promise.resolve(v.acquire(r)).then(function(){return f.has(r)?f.get(r):Promise.resolve(n.apply(void 0,e)).then(function(e){return c(e,r)&&f.set(r,e),e})})}catch(e){return i(!0,e)}return l&&l.then?l.then(i.bind(null,!1),i.bind(null,!0)):i(!1,l)}(0,function(e,n){if(v.release(r),e)throw n;return n}))}catch(e){return Promise.reject(e)}};return h.cache=f,h};export{n as Memoize,t as MemoizeAsync};
 //# sourceMappingURL=memoize.module.js.map

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 */\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 =\n    options.resolver ?? ((...args: Args) => JSON.stringify(args));\n\n  const cache = new QuickLRU<string, Return>({\n    maxAge,\n    maxSize,\n  });\n\n  const memoizedFunction = (...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  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the synchronous 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 =\n    options.resolver ?? ((...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  const memoizedFunction = 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  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$resolver","maxSize","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","memoizedFunction","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,SACdC,EACAC,GACEC,IAAAA,EAAAC,OADFF,IAAAA,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAhBT,IAkBhBG,EACY,OADJF,EACZF,EAAQI,UAAQF,EAAK,WAAmB,OAAAG,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAExDC,EAAQ,IAAIC,EAAyB,CACzCC,OAPiCZ,EAAQY,OAQzCT,QAAAA,IAGIU,EAAmB,WAAI,IAAAC,EAAUP,GAAAA,MAAAC,KAAAC,WAC/BM,EAAMX,EAAQY,WAAIF,EAAAA,GAExB,GAAIJ,EAAMO,IAAIF,GACZ,OAAOL,EAAMQ,IAAIH,GAEjB,IAAMI,EAAcpB,EAAEiB,WAAIF,EAAAA,GAE1B,OADAJ,EAAMU,IAAIL,EAAKI,GACRA,CAEX,EAIA,OAFAN,EAAiBH,MAAQA,EAElBG,CACT,EAUMQ,EAAe,SACnBtB,EACAC,GACEsB,IAAAA,EAAAC,OADFvB,IAAAA,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyBmB,OAAlBA,EAAGtB,EAAQG,SAAOmB,EAxDT,IA0DhBlB,EACYmB,OADJA,EACZvB,EAAQI,UAAQmB,EAAK,WAAmB,OAAAlB,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAExDe,EAAY,IAAIC,EAEhBf,EAAQ,IAAIC,EAAyB,CACzCC,OAAAA,EACAT,QAAAA,IAGIU,EAAA,eAA4Da,IAA/BZ,EAAU,GAAAP,MAAAC,KAAqBC,WAC1DM,EAAMX,EAAQY,WAAIF,EAAAA,GAAM,OAAAa,QAAAC,QAE1BlB,EAAMO,IAAIF,GACLL,EAAMQ,IAAIH,2BAEbY,QAAAC,QACIJ,EAAUK,QAAQd,IAAIe,KAAA,WAAA,OAExBpB,EAAMO,IAAIF,GACLL,EAAMQ,IAAIH,GAAKY,QAAAC,QAEI7B,EAAEiB,WAAIF,EAAAA,IAAKgB,KAAA,SAA/BX,GAEN,OADAT,EAAMU,IAAIL,EAAKI,GACRA,CAAY,EAEtB,4FAZsBY,CAEnB,EAUHC,SAAAA,EAAAC,GACwB,GAAvBT,EAAUU,QAAQnB,GAAKiB,EAAA,MAAAC,EAAA,OAAAA,CAAA,GAG7B,CAAC,MAAAE,GAAA,OAAAR,QAAAS,OAAAD,EAEDtB,CAAAA,EAEA,OAFAA,EAAiBH,MAAQA,EAElBG,CACT"}
+{"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[], Return> = {\n  maxSize: number;\n  maxAge?: number;\n  shouldCache: (returnValue: Return, key: string) => boolean;\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, Return>> = {},\n) => {\n  const maxAge: number | undefined = options.maxAge;\n  const maxSize = options.maxSize ?? kDefaultMaxSize;\n  const shouldCache = options.shouldCache ?? (() => true);\n\n  const resolver =\n    options.resolver ?? ((...args: Args) => JSON.stringify(args));\n\n  const cache = new QuickLRU<string, Return>({\n    maxAge,\n    maxSize,\n  });\n\n  const memoizedFunction = (...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      if (shouldCache(returnValue, key)) {\n        cache.set(key, returnValue);\n      }\n      return returnValue;\n    }\n  };\n\n  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\n/**\n * Memoize an asynchronous function.\n *\n * This differs from the synchronous 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, Return>> = {},\n) => {\n  const maxAge: number | undefined = options.maxAge;\n  const maxSize = options.maxSize ?? kDefaultMaxSize;\n  const shouldCache = options.shouldCache ?? (() => true);\n\n  const resolver =\n    options.resolver ?? ((...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  const memoizedFunction = 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\n          if (shouldCache(returnValue, key)) {\n            cache.set(key, returnValue);\n          }\n\n          return returnValue;\n        }\n      } finally {\n        semaphore.release(key);\n      }\n    }\n  };\n\n  memoizedFunction.cache = cache;\n\n  return memoizedFunction;\n};\n\nexport { Memoize, MemoizeAsync };\n"],"names":["Memoize","cb","options","_options$maxSize","_options$shouldCache","_options$resolver","maxSize","shouldCache","resolver","JSON","stringify","slice","call","arguments","cache","QuickLRU","maxAge","memoizedFunction","args","key","apply","has","get","returnValue","set","MemoizeAsync","_options$maxSize2","_options$shouldCache2","_options$resolver2","semaphore","Semaphore","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"oEAGA,IAYMA,EAAU,SACdC,EACAC,GACE,IAAAC,EAAAC,EAAAC,OADFH,IAAAA,IAAAA,EAA0C,CAAA,GAE1C,IACMI,EAAyBH,OAAlBA,EAAGD,EAAQI,SAAOH,EAjBT,IAkBhBI,EAAiCH,OAAtBA,EAAGF,EAAQK,aAAWH,EAAK,WAAM,OAAA,CAAI,EAEhDI,EACYH,OADJA,EACZH,EAAQM,UAAQH,EAAK,WAAA,OAAmBI,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAExDC,EAAQ,IAAIC,EAAyB,CACzCC,OARiCd,EAAQc,OASzCV,QAAAA,IAGIW,EAAmB,WAAI,IAAAC,EAAU,GAAAP,MAAAC,KAAAC,WAC/BM,EAAMX,EAAQY,WAAA,EAAIF,GAExB,GAAIJ,EAAMO,IAAIF,GACZ,OAAOL,EAAMQ,IAAIH,GAEjB,IAAMI,EAActB,EAAEmB,WAAIF,EAAAA,GAI1B,OAHIX,EAAYgB,EAAaJ,IAC3BL,EAAMU,IAAIL,EAAKI,GAEVA,CAEX,EAIA,OAFAN,EAAiBH,MAAQA,EAElBG,CACT,EAUMQ,EAAe,SACnBxB,EACAC,GACEwB,IAAAA,EAAAC,EAAAC,OADwC,IAA1C1B,IAAAA,EAA0C,IAE1C,IAAMc,EAA6Bd,EAAQc,OACrCV,EAAyBoB,OAAlBA,EAAGxB,EAAQI,SAAOoB,EA5DT,IA6DhBnB,EAAiCoB,OAAtBA,EAAGzB,EAAQK,aAAWoB,EAAK,WAAM,OAAA,CAAI,EAEhDnB,SAAQoB,EACZ1B,EAAQM,UAAQoB,EAAK,WAAmB,OAAAnB,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAExDgB,EAAY,IAAIC,EAEhBhB,EAAQ,IAAIC,EAAyB,CACzCC,OAAAA,EACAV,QAAAA,IAGIW,EAAA,WAA4D,IAAA,IAA/BC,EAAUP,GAAAA,MAAAC,KAAqBC,WAC1DM,EAAMX,EAAQY,WAAIF,EAAAA,GAAM,OAAAa,QAAAC,QAE1BlB,EAAMO,IAAIF,GACLL,EAAMQ,IAAIH,2BAEbY,QAAAC,QACIH,EAAUI,QAAQd,IAAIe,KAExBpB,WAAAA,OAAAA,EAAMO,IAAIF,GACLL,EAAMQ,IAAIH,GAAKY,QAAAC,QAEI/B,EAAEmB,WAAIF,EAAAA,IAAKgB,KAAA,SAA/BX,GAMN,OAJIhB,EAAYgB,EAAaJ,IAC3BL,EAAMU,IAAIL,EAAKI,GAGVA,CAAY,EAEtB,4FAhBsBY,YAgBtBC,EAAAC,GACwB,GAAvBR,EAAUS,QAAQnB,GAAKiB,QAAAC,EAAA,OAAAA,CAAA,GAG7B,CAAC,MAAAE,GAAA,OAAAR,QAAAS,OAAAD,EAEDtB,CAAAA,EAEA,OAFAA,EAAiBH,MAAQA,EAElBG,CACT"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chriscdn/memoize",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Memoize a synchronous or asynchronous function.",
   "repository": "https://github.com/chriscdn/memoize",
   "author": "Christopher Meyer <chris@schwiiz.org>",

package/src/index.ts

@@ -3,9 +3,10 @@ import QuickLRU from "quick-lru";
 
 const kDefaultMaxSize = 1000;
 
-type Options<T extends any[]> = {
+type Options<T extends any[], Return> = {
   maxSize: number;
   maxAge?: number;
+  shouldCache: (returnValue: Return, key: string) => boolean;
   resolver: (...args: T) => string;
 };
 
@@ -14,10 +15,11 @@ type Options<T extends any[]> = {
  */
 const Memoize = <Args extends unknown[], Return>(
   cb: (...args: Args) => Return,
-  options: Partial<Options<Args>> = {},
+  options: Partial<Options<Args, Return>> = {},
 ) => {
   const maxAge: number | undefined = options.maxAge;
   const maxSize = options.maxSize ?? kDefaultMaxSize;
+  const shouldCache = options.shouldCache ?? (() => true);
 
   const resolver =
     options.resolver ?? ((...args: Args) => JSON.stringify(args));
@@ -34,7 +36,9 @@ const Memoize = <Args extends unknown[], Return>(
       return cache.get(key);
     } else {
       const returnValue = cb(...args);
-      cache.set(key, returnValue);
+      if (shouldCache(returnValue, key)) {
+        cache.set(key, returnValue);
+      }
       return returnValue;
     }
   };
@@ -54,10 +58,11 @@ const Memoize = <Args extends unknown[], Return>(
  */
 const MemoizeAsync = <Args extends unknown[], Return>(
   cb: (...args: Args) => Promise<Return>,
-  options: Partial<Options<Args>> = {},
+  options: Partial<Options<Args, Return>> = {},
 ) => {
   const maxAge: number | undefined = options.maxAge;
   const maxSize = options.maxSize ?? kDefaultMaxSize;
+  const shouldCache = options.shouldCache ?? (() => true);
 
   const resolver =
     options.resolver ?? ((...args: Args) => JSON.stringify(args));
@@ -82,7 +87,11 @@ const MemoizeAsync = <Args extends unknown[], Return>(
           return cache.get(key);
         } else {
           const returnValue = await cb(...args);
-          cache.set(key, returnValue);
+
+          if (shouldCache(returnValue, key)) {
+            cache.set(key, returnValue);
+          }
+
           return returnValue;
         }
       } finally {