@chriscdn/memoize 1.0.9 → 1.0.11

package/README.md

@@ -92,6 +92,14 @@ const options = {
 };
 ```
 
+**Note**: `Memoize` works with both _synchronous_ and _asynchronous_ functions. However, when using the `shouldCache` callback with an asynchronous function, the `returnValue` passed to `shouldCache` is a `Promise`. This is effectively useless since caching decisions should be based on the resolved value.
+
+To address this, use `MemoizeAsync` instead. It has the same interface as `Memoize`, but works with asynchronous functions and passes the resolved value to `shouldCache`.
+
+```ts
+import { MemoizeAsync } from "@chriscdn/memoize";
+```
+
 ## Cache
 
 The underlying [quick-lru](https://www.npmjs.com/package/quick-lru) instance is accessible via the `.cache` property on the memoized function:

package/lib/index.d.ts

@@ -13,10 +13,10 @@ declare const Memoize: <Args extends unknown[], Return>(cb: (...args: Args) => R
     cache: QuickLRU<string, Return>;
 };
 /**
- * @deprecated `Memoize` can be used  for asynchronous functions.
+ * Memoize an asynchronous function.
  */
-declare const MemoizeAsync: <Args extends unknown[], Return>(cb: (...args: Args) => Return, options?: Partial<Options<Args, Return>>) => {
-    (...args: Args): Return;
+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>;
 };
 export { Memoize, MemoizeAsync };

package/lib/memoize.cjs

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

package/lib/memoize.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.cjs","sources":["../src/index.ts"],"sourcesContent":["import 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 = options.resolver ??\n    ((...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) as Return;\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 * @deprecated `Memoize` can be used  for asynchronous functions.\n */\nconst MemoizeAsync = Memoize;\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"],"mappings":"mHAcMA,EAAU,SACdC,EACAC,GACE,IAAAC,EAAAC,EAAAC,OADFH,IAAAA,IAAAA,EAA0C,CAAE,GAE5C,IACMI,EAAyB,OAAlBH,EAAGD,EAAQI,SAAOH,EAjBT,IAkBhBI,EAAiC,OAAtBH,EAAGF,EAAQK,aAAWH,EAAK,WAAA,OAAU,CAAA,EAEhDI,SAAQH,EAAGH,EAAQM,UAAQH,EAC9B,WAAmB,OAAAI,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEpCC,EAAQ,IAAIC,EAAQ,QAAiB,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,EAKMQ,EAAezB"}
+{"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 = options.resolver ??\n    ((...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) as Return;\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 */\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 = options.resolver ??\n    ((...args: Args) => JSON.stringify(args));\n\n  const cache = new QuickLRU<string, Return>({\n    maxAge,\n    maxSize,\n  });\n\n  const semaphore = new Semaphore();\n\n  const memoizedFunction = async (...args: Args): Promise<Return> => {\n    const key = resolver(...args);\n\n    try {\n      await semaphore.acquire(key);\n\n      if (cache.has(key)) {\n        return cache.get(key) as Return;\n      } else {\n        const returnValue = await cb(...args);\n        if (shouldCache(returnValue, key)) {\n          cache.set(key, returnValue);\n        }\n        return returnValue;\n      }\n    } finally {\n      semaphore.release(key);\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","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"gLAegB,SACdA,EACAC,GACEC,IAAAA,EAAAC,EAAAC,WADFH,IAAAA,EAA0C,CAAE,GAE5C,IACMI,EAAyBH,OAAlBA,EAAGD,EAAQI,SAAOH,EAjBT,IAkBhBI,EAAiC,OAAtBH,EAAGF,EAAQK,aAAWH,EAAK,WAAM,OAAA,CAAI,EAEhDI,SAAQH,EAAGH,EAAQM,UAAQH,EAC9B,WAAmB,OAAAI,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAEpCC,EAAQ,IAAIC,EAAAA,QAAyB,CACzCC,OARiCd,EAAQc,OASzCV,QAAAA,IAGIW,EAAmB,WAAI,IAAAC,EAAU,GAAAP,MAAAC,KAAAC,WAC/BM,EAAMX,EAAQY,WAAIF,EAAAA,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,uBAKqB,SACnBhB,EACAC,GACEuB,IAAAA,EAAAC,EAAAC,OADwC,IAA1CzB,IAAAA,EAA0C,CAAA,GAE1C,IACMI,EAAyBmB,OAAlBA,EAAGvB,EAAQI,SAAOmB,EAvDT,IAwDhBlB,EAAiCmB,OAAtBA,EAAGxB,EAAQK,aAAWmB,EAAK,WAAA,OAAU,CAAA,EAEhDlB,EAA2B,OAAnBmB,EAAGzB,EAAQM,UAAQmB,EAC9B,WAAmB,OAAAlB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEpCC,EAAQ,IAAIC,EAAQ,QAAiB,CACzCC,OARiCd,EAAQc,OASzCV,QAAAA,IAGIsB,EAAY,IAAIC,EAAAA,UAEhBZ,EAAA,eAA4Da,IAA/BZ,EAAU,GAAAP,MAAAC,KAAqBC,WAC1DM,EAAMX,EAAQY,WAAIF,EAAAA,GAAM,OAAAa,QAAAC,gCAE1BD,QAAAC,QACIJ,EAAUK,QAAQd,IAAIe,KAAA,WAAA,OAExBpB,EAAMO,IAAIF,GACLL,EAAMQ,IAAIH,GAAeY,QAAAC,QAEN/B,EAAEmB,WAAA,EAAIF,IAAKgB,KAAA,SAA/BX,GAIN,OAHIhB,EAAYgB,EAAaJ,IAC3BL,EAAMU,IAAIL,EAAKI,GAEVA,CAAY,EAEtB,4FAd6BY,CAAA,EAc7BC,SAAAA,EAAAC,GACwB,GAAvBT,EAAUU,QAAQnB,GAAKiB,EAAA,MAAAC,EAAAA,OAAAA,CAAA,GAE3B,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EAAA,CAAA,EAID,OAFAtB,EAAiBH,MAAQA,EAElBG,CACT"}

package/lib/memoize.modern.js

@@ -1,2 +1,2 @@
-import e from"quick-lru";const r=(r,n={})=>{var t,l,o;const s=null!=(t=n.maxSize)?t:1e3,u=null!=(l=n.shouldCache)?l:()=>!0,a=null!=(o=n.resolver)?o:(...e)=>JSON.stringify(e),c=new e({maxAge:n.maxAge,maxSize:s}),i=(...e)=>{const n=a(...e);if(c.has(n))return c.get(n);{const t=r(...e);return u(t,n)&&c.set(n,t),t}};return i.cache=c,i},n=r;export{r as Memoize,n as MemoizeAsync};
+import{Semaphore as e}from"@chriscdn/promise-semaphore";import r from"quick-lru";const n=(e,n={})=>{var a,t,s;const l=null!=(a=n.maxSize)?a:1e3,i=null!=(t=n.shouldCache)?t:()=>!0,c=null!=(s=n.resolver)?s:(...e)=>JSON.stringify(e),o=new r({maxAge:n.maxAge,maxSize:l}),u=(...r)=>{const n=c(...r);if(o.has(n))return o.get(n);{const a=e(...r);return i(a,n)&&o.set(n,a),a}};return u.cache=o,u},a=(n,a={})=>{var t,s,l;const i=null!=(t=a.maxSize)?t:1e3,c=null!=(s=a.shouldCache)?s:()=>!0,o=null!=(l=a.resolver)?l:(...e)=>JSON.stringify(e),u=new r({maxAge:a.maxAge,maxSize:i}),m=new e,h=async(...e)=>{const r=o(...e);try{if(await m.acquire(r),u.has(r))return u.get(r);{const a=await n(...e);return c(a,r)&&u.set(r,a),a}}finally{m.release(r)}};return h.cache=u,h};export{n as Memoize,a 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 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 = options.resolver ??\n    ((...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) as Return;\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 * @deprecated `Memoize` can be used  for asynchronous functions.\n */\nconst MemoizeAsync = Memoize;\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"],"mappings":"yBAEA,MAYMA,EAAUA,CACdC,EACAC,EAA0C,CAAE,SAC1CC,EAAAC,EAAAC,EACF,MACMC,EAAyB,OAAlBH,EAAGD,EAAQI,SAAOH,EAjBT,IAkBhBI,EAAiCH,OAAtBA,EAAGF,EAAQK,aAAWH,EAAK,KAAM,EAE5CI,SAAQH,EAAGH,EAAQM,UAAQH,EAC9B,IAAII,IAAeC,KAAKC,UAAUF,GAE/BG,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,GAMHM,EAAerB"}
+{"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 = options.resolver ??\n    ((...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) as Return;\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 */\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 = options.resolver ??\n    ((...args: Args) => JSON.stringify(args));\n\n  const cache = new QuickLRU<string, Return>({\n    maxAge,\n    maxSize,\n  });\n\n  const semaphore = new Semaphore();\n\n  const memoizedFunction = async (...args: Args): Promise<Return> => {\n    const key = resolver(...args);\n\n    try {\n      await semaphore.acquire(key);\n\n      if (cache.has(key)) {\n        return cache.get(key) as Return;\n      } else {\n        const returnValue = await cb(...args);\n        if (shouldCache(returnValue, key)) {\n          cache.set(key, returnValue);\n        }\n        return returnValue;\n      }\n    } finally {\n      semaphore.release(key);\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":"iFAGA,MAYMA,EAAUA,CACdC,EACAC,EAA0C,MACxC,IAAAC,EAAAC,EAAAC,EACF,MACMC,SAAOH,EAAGD,EAAQI,SAAOH,EAjBT,IAkBhBI,EAAiC,OAAtBH,EAAGF,EAAQK,aAAWH,EAAK,KAAM,EAE5CI,EAA2BH,OAAnBA,EAAGH,EAAQM,UAAQH,EAC9B,IAAII,IAAeC,KAAKC,UAAUF,GAE/BG,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,GAMHM,EAAeA,CACnBpB,EACAC,EAA0C,CAAE,SAC1CoB,EAAAC,EAAAC,EACF,MACMlB,EAAyB,OAAlBgB,EAAGpB,EAAQI,SAAOgB,EAvDT,IAwDhBf,SAAWgB,EAAGrB,EAAQK,aAAWgB,EAAK,KAAM,EAE5Cf,EAA2B,OAAnBgB,EAAGtB,EAAQM,UAAQgB,EAC9B,IAAIf,IAAeC,KAAKC,UAAUF,GAE/BG,EAAQ,IAAIC,EAAyB,CACzCC,OARiCZ,EAAQY,OASzCR,YAGImB,EAAY,IAAIC,EAEhBX,EAAmBY,SAAUlB,KACjC,MAAMO,EAAMR,KAAYC,GAExB,IAGE,SAFMgB,EAAUG,QAAQZ,GAEpBJ,EAAMK,IAAID,GACZ,OAAOJ,EAAMM,IAAIF,GACZ,CACL,MAAMG,QAAoBlB,KAAMQ,GAIhC,OAHIF,EAAYY,EAAaH,IAC3BJ,EAAMQ,IAAIJ,EAAKG,GAEVA,CACR,CACF,CAAA,QACCM,EAAUI,QAAQb,EACnB,GAKH,OAFAD,EAAiBH,MAAQA,EAElBG"}

package/lib/memoize.module.js

@@ -1,2 +1,2 @@
-import r from"quick-lru";var e=function(e,n){var l,a,i;void 0===n&&(n={});var u=null!=(l=n.maxSize)?l:1e3,t=null!=(a=n.shouldCache)?a:function(){return!0},c=null!=(i=n.resolver)?i:function(){return JSON.stringify([].slice.call(arguments))},o=new r({maxAge:n.maxAge,maxSize:u}),v=function(){var r=[].slice.call(arguments),n=c.apply(void 0,r);if(o.has(n))return o.get(n);var l=e.apply(void 0,r);return t(l,n)&&o.set(n,l),l};return v.cache=o,v},n=e;export{e as Memoize,n as MemoizeAsync};
+import{Semaphore as 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,o=null!=(i=n.shouldCache)?i:function(){return!0},a=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=a.apply(void 0,r);if(c.has(n))return c.get(n);var t=e.apply(void 0,r);return o(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 o=null!=(i=t.maxSize)?i:1e3,a=null!=(l=t.shouldCache)?l:function(){return!0},c=null!=(u=t.resolver)?u:function(){return JSON.stringify([].slice.call(arguments))},s=new r({maxAge:t.maxAge,maxSize:o}),v=new e,f=function(){try{var e=[].slice.call(arguments),r=c.apply(void 0,e);return Promise.resolve(function(t,i){try{var l=Promise.resolve(v.acquire(r)).then(function(){return s.has(r)?s.get(r):Promise.resolve(n.apply(void 0,e)).then(function(e){return a(e,r)&&s.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 f.cache=s,f};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 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 = options.resolver ??\n    ((...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) as Return;\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 * @deprecated `Memoize` can be used  for asynchronous functions.\n */\nconst MemoizeAsync = Memoize;\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"],"mappings":"yBAEA,IAYMA,EAAU,SACdC,EACAC,GACE,IAAAC,EAAAC,EAAAC,OADFH,IAAAA,IAAAA,EAA0C,CAAE,GAE5C,IACMI,EAAyB,OAAlBH,EAAGD,EAAQI,SAAOH,EAjBT,IAkBhBI,EAAiC,OAAtBH,EAAGF,EAAQK,aAAWH,EAAK,WAAA,OAAU,CAAA,EAEhDI,SAAQH,EAAGH,EAAQM,UAAQH,EAC9B,WAAmB,OAAAI,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEpCC,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,EAKMQ,EAAezB"}
+{"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 = options.resolver ??\n    ((...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) as Return;\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 */\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 = options.resolver ??\n    ((...args: Args) => JSON.stringify(args));\n\n  const cache = new QuickLRU<string, Return>({\n    maxAge,\n    maxSize,\n  });\n\n  const semaphore = new Semaphore();\n\n  const memoizedFunction = async (...args: Args): Promise<Return> => {\n    const key = resolver(...args);\n\n    try {\n      await semaphore.acquire(key);\n\n      if (cache.has(key)) {\n        return cache.get(key) as Return;\n      } else {\n        const returnValue = await cb(...args);\n        if (shouldCache(returnValue, key)) {\n          cache.set(key, returnValue);\n        }\n        return returnValue;\n      }\n    } finally {\n      semaphore.release(key);\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","_arguments","Promise","resolve","acquire","then","_finallyRethrows","_wasThrown","_result","release","e","reject"],"mappings":"iFAGA,IAYMA,EAAU,SACdC,EACAC,GACEC,IAAAA,EAAAC,EAAAC,WADFH,IAAAA,EAA0C,CAAE,GAE5C,IACMI,EAAyBH,OAAlBA,EAAGD,EAAQI,SAAOH,EAjBT,IAkBhBI,EAAiC,OAAtBH,EAAGF,EAAQK,aAAWH,EAAK,WAAM,OAAA,CAAI,EAEhDI,SAAQH,EAAGH,EAAQM,UAAQH,EAC9B,WAAmB,OAAAI,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAEpCC,EAAQ,IAAIC,EAAyB,CACzCC,OARiCd,EAAQc,OASzCV,QAAAA,IAGIW,EAAmB,WAAI,IAAAC,EAAU,GAAAP,MAAAC,KAAAC,WAC/BM,EAAMX,EAAQY,WAAIF,EAAAA,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,EAKMQ,EAAe,SACnBxB,EACAC,GACEwB,IAAAA,EAAAC,EAAAC,OADwC,IAA1C1B,IAAAA,EAA0C,CAAA,GAE1C,IACMI,EAAyBoB,OAAlBA,EAAGxB,EAAQI,SAAOoB,EAvDT,IAwDhBnB,EAAiCoB,OAAtBA,EAAGzB,EAAQK,aAAWoB,EAAK,WAAA,OAAU,CAAA,EAEhDnB,EAA2B,OAAnBoB,EAAG1B,EAAQM,UAAQoB,EAC9B,WAAmB,OAAAnB,KAAKC,UAASC,GAAAA,MAAAC,KAAAC,WAAM,EAEpCC,EAAQ,IAAIC,EAAyB,CACzCC,OARiCd,EAAQc,OASzCV,QAAAA,IAGIuB,EAAY,IAAIC,EAEhBb,EAAA,eAA4Dc,IAA/Bb,EAAU,GAAAP,MAAAC,KAAqBC,WAC1DM,EAAMX,EAAQY,WAAIF,EAAAA,GAAM,OAAAc,QAAAC,gCAE1BD,QAAAC,QACIJ,EAAUK,QAAQf,IAAIgB,KAAA,WAAA,OAExBrB,EAAMO,IAAIF,GACLL,EAAMQ,IAAIH,GAAea,QAAAC,QAENhC,EAAEmB,WAAA,EAAIF,IAAKiB,KAAA,SAA/BZ,GAIN,OAHIhB,EAAYgB,EAAaJ,IAC3BL,EAAMU,IAAIL,EAAKI,GAEVA,CAAY,EAEtB,4FAd6Ba,CAAA,EAc7BC,SAAAA,EAAAC,GACwB,GAAvBT,EAAUU,QAAQpB,GAAKkB,EAAA,MAAAC,EAAAA,OAAAA,CAAA,GAE3B,CAAC,MAAAE,GAAAR,OAAAA,QAAAS,OAAAD,EAAA,CAAA,EAID,OAFAvB,EAAiBH,MAAQA,EAElBG,CACT"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chriscdn/memoize",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Memoize a synchronous or asynchronous function.",
   "repository": "https://github.com/chriscdn/memoize",
   "author": "Christopher Meyer <chris@schwiiz.org>",
@@ -22,10 +22,14 @@
     "test": "vitest"
   },
   "dependencies": {
-    "quick-lru": "^7.0.1"
+    "@chriscdn/promise-semaphore": "^3.1.2",
+    "quick-lru": "^7.3.0"
   },
   "devDependencies": {
     "microbundle": "^0.15.1",
-    "vitest": "^3.1.2"
-  }
+    "vitest": "^4.0.6"
+  },
+  "files": [
+    "lib"
+  ]
 }

package/__tests__/memoize.test.ts

@@ -1,201 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Memoize, MemoizeAsync } from "../src/index";
-
-let addSyncCount = 0;
-let addAsyncCount = 0;
-
-const add = (x: number, y: number) => {
-  addSyncCount += 1;
-  return x + y;
-};
-
-const addAsync = async (x: number, y: number) => {
-  addAsyncCount += 1;
-  return x + y;
-};
-
-const _asyncThrowError = MemoizeAsync(async (x: number, y: number) => {
-  addAsyncCount += 1;
-  throw new Error("Boom!");
-  return x + y;
-});
-
-const asyncThrowError = MemoizeAsync(async (x: number, y: number) => {
-  try {
-    await _asyncThrowError(x, y);
-  } catch {
-    return -1;
-  }
-});
-
-describe("Memoization", () => {
-  it("sync", async () => {
-    const addCached = Memoize(add);
-
-    expect(addCached(1, 2)).toBe(3);
-    expect(addCached(1, 2)).toBe(3);
-    expect(addCached(1, 2)).toBe(3);
-    expect(addCached(1, 2)).toBe(3);
-    expect(addCached(1, 2)).toBe(3);
-
-    // different key here
-    expect(addCached(2, 1)).toBe(3);
-    expect(addSyncCount).toBe(2);
-  });
-
-  it("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)),
-      addCachedAsync(1, 2).then((value) => expect(value).toBe(3)),
-      addCachedAsync(1, 2).then((value) => expect(value).toBe(3)),
-
-      // different key here
-      addCachedAsync(2, 1).then((value) => expect(value).toBe(3)),
-    ]);
-
-    expect(addAsyncCount).toBe(2);
-    expect(addCachedAsync.cache.size).toBe(2);
-  });
-
-  it("resolver", () => {
-    // This its 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);
-  });
-
-  it("async error", async () => {
-    expect(await asyncThrowError(4, 3)).toBe(-1);
-  });
-});
-
-describe("Memoization of Class methods", () => {
-  class AddClass {
-    count: number = 0;
-
-    constructor() {
-      this.add = Memoize(this.add.bind(this));
-    }
-
-    add(x: number, y: number) {
-      this.count += 1;
-      return x + y;
-    }
-  }
-
-  it("Test1", () => {
-    const obj = new AddClass();
-
-    expect(obj.count).toBe(0);
-    expect(obj.add(1, 2)).toBe(3);
-    expect(obj.count).toBe(1);
-    expect(obj.add(1, 2)).toBe(3);
-    expect(obj.count).toBe(1);
-    expect(obj.add(5, 2)).toBe(7);
-    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);
-  });
-});
-
-describe("Do we need MemoizeAsync?", async () => {
-  const myFunction = Memoize(async (word: string) => word, {
-    resolver: (value) => value,
-  });
-
-  it("should be cached", async () => {
-    expect(await myFunction("hi")).toBe("hi");
-  });
-
-  it("should be cached", async () => {
-    expect(await myFunction("hi")).toBe("hi");
-  });
-
-  it("should be cached", async () => {
-    expect(await myFunction("hi2")).toBe("hi2");
-  });
-
-  it("size", () => expect(myFunction.cache.size).toBe(2));
-});
-
-describe("Errors", async () => {
-  const errorSync = Memoize(() => {
-    throw new Error("errorsync");
-  });
-
-  const errorASync = Memoize(async () => {
-    throw new Error("errorasync");
-  });
-
-  it("error sync", () => {
-    expect(() => errorSync()).toThrowError("errorsync");
-  });
-
-  it("error async", () => {
-    expect(errorASync()).rejects.toThrowError("errorasync");
-  });
-});

package/src/index.ts

@@ -1,55 +0,0 @@
-import QuickLRU from "quick-lru";
-
-const kDefaultMaxSize = 1000;
-
-type Options<T extends any[], Return> = {
-  maxSize: number;
-  maxAge?: number;
-  shouldCache: (returnValue: Return, key: string) => boolean;
-  resolver: (...args: T) => string;
-};
-
-/**
- * Memoize a synchronous function.
- */
-const Memoize = <Args extends unknown[], Return>(
-  cb: (...args: Args) => Return,
-  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));
-
-  const cache = new QuickLRU<string, Return>({
-    maxAge,
-    maxSize,
-  });
-
-  const memoizedFunction = (...args: Args): Return => {
-    const key = resolver(...args);
-
-    if (cache.has(key)) {
-      return cache.get(key) as Return;
-    } else {
-      const returnValue = cb(...args);
-      if (shouldCache(returnValue, key)) {
-        cache.set(key, returnValue);
-      }
-      return returnValue;
-    }
-  };
-
-  memoizedFunction.cache = cache;
-
-  return memoizedFunction;
-};
-
-/**
- * @deprecated `Memoize` can be used  for asynchronous functions.
- */
-const MemoizeAsync = Memoize;
-
-export { Memoize, MemoizeAsync };