@chriscdn/memoize 1.0.6 → 1.0.7

package/README.md

@@ -87,6 +87,9 @@ const options = {
   // Maximum lifespan of an item in milliseconds; undefined means items never expire
   maxAge: undefined,
 
+  // 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),
 };
@@ -107,6 +110,8 @@ console.log(add.cache.size === 1);
 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, but this requires overriding the method within the constructor. Ensure you bind the method to the instance to maintain the correct context.

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.6",
+  "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 {