@chriscdn/memoize 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# @chriscdn/memoize
+
+Memoize a synchronous or asynchronous function.
+
+## Installing
+
+Using npm:
+
+```bash
+npm install @chriscdn/memoize
+```
+
+Using yarn:
+
+```bash
+yarn add @chriscdn/memoize
+```
+
+## Usage
+
+The package comes with 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 `MemoizeAsync` function prevents duplicate evaluations by ensuring that multiple calls with identical parameters are only processed once.
+
+**Example (synchronous)**
+
+To memoize a function:
+
+```ts
+const _add = (x: number, y: number) => x + y;
+const add = Memoize(_add);
+```
+
+The `add` function has the same interface as `_add`:
+
+```ts
+const result = add(5, 7);
+// 12
+```
+
+**Example (asynchronous)**
+
+The asynchronous case is similar:
+
+```ts
+const _add = async (x: number, y: number) => x + y;
+const add = MemoizeAsync(_add);
+
+const result = await add(5, 7);
+// 12
+```
+
+## Options
+
+The `Memoize` and `MemoizeAsync` functions accept an `Options` parameter to control the behaviour of the cache. Each option is optional. See the section below for the defaults:
+
+```ts
+const options = {
+  // maximum number of items in the cache
+  maxSize: 1000,
+
+  // maximum number of milliseconds an item is to remain in the cache, undefined implies Infinity
+  maxAge: undefined,
+
+  // a function for generating the cache key (must return a String)
+  resolver: (...args) => JSON.stringify(args),
+};
+```
+
+## Tests
+
+```bash
+yarn test
+```
+
+## License
+
+[MIT](LICENSE)

package/__tests__/memoize.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } 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 addCached = Memoize(add);
+
+const addAsync = async (x: number, y: number) => {
+  addAsyncCount += 1;
+  return x + y;
+};
+const addCachedAsync = MemoizeAsync(addAsync);
+
+test("sync", async () => {
+  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);
+});
+
+test("async", async () => {
+  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);
+});

package/lib/index.d.ts

@@ -0,0 +1,29 @@
+type Options<T extends any[]> = {
+    maxSize: number;
+    maxAge?: number;
+    resolver: (...args: T) => string;
+};
+/**
+ * Memoize a synchronous function.
+ *
+ * @template {any[]} Args
+ * @template {{}} Return
+ * @param {(...args: Args) => Return} cb
+ * @param {Partial<Options<Args>>} [options={}]
+ * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}
+ */
+declare const Memoize: <Args extends any[], Return extends {}>(cb: (...args: Args) => Return, options?: Partial<Options<Args>>) => (...args: Args) => Return;
+/**
+ * Memoize an asynchronous function.
+ *
+ * This differs from the sychronous case by ensuring multiple calls with the
+ * same arguments is only evaluated once. This is controlled by using a
+ * semaphore, which forces redundant calls to wait until the first call
+ * completes.
+ *
+ * @param cb
+ * @param options
+ * @returns
+ */
+declare const MemoizeAsync: <Args extends any[], Return extends {}>(cb: (...args: Args) => Promise<Return>, options?: Partial<Options<Args>>) => (...args: Args) => Promise<Return>;
+export { Memoize, MemoizeAsync };

package/lib/memoize.cjs

@@ -0,0 +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 u=null!=(n=r.maxSize)?n:1e3,l=null!=(t=r.resolver)?t:function(){return JSON.stringify([].slice.call(arguments))},a=new i.default({maxAge:r.maxAge,maxSize:u});return function(){var r=[].slice.call(arguments),n=l.apply(void 0,r);if(a.has(n))return a.get(n);var t=e.apply(void 0,r);return a.set(n,t),t}},exports.MemoizeAsync=function(e,r){var n,u;void 0===r&&(r={});var l=r.maxAge,a=null!=(n=r.maxSize)?n:1e3,o=null!=(u=r.resolver)?u:function(){return JSON.stringify([].slice.call(arguments))},c=new t.default,s=new i.default({maxAge:l,maxSize:a});return 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 u=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 u&&u.then?u.then(i.bind(null,!1),i.bind(null,!0)):i(!1,u)}(0,function(e,r){if(c.release(n),e)throw r;return r}))}catch(e){return Promise.reject(e)}}};
+//# sourceMappingURL=memoize.cjs.map

package/lib/memoize.cjs.map

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

package/lib/memoize.modern.js

@@ -0,0 +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),o=new r({maxAge:t.maxAge,maxSize:s});return(...r)=>{const t=i(...r);if(o.has(t))return o.get(t);{const n=e(...r);return o.set(t,n),n}}},n=(t,n={})=>{var a,s;const i=n.maxAge,o=null!=(a=n.maxSize)?a:1e3,l=null!=(s=n.resolver)?s:(...e)=>JSON.stringify(e),m=new e,u=new r({maxAge:i,maxSize:o});return async(...e)=>{const r=l(...e);if(u.has(r))return u.get(r);try{if(await m.acquire(r),u.has(r))return u.get(r);{const n=await t(...e);return u.set(r,n),n}}finally{m.release(r)}}};export{t as Memoize,n as MemoizeAsync};
+//# sourceMappingURL=memoize.modern.js.map

package/lib/memoize.modern.js.map

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

package/lib/memoize.module.js

@@ -0,0 +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 l=null!=(t=n.maxSize)?t:1e3,a=null!=(i=n.resolver)?i:function(){return JSON.stringify([].slice.call(arguments))},o=new r({maxAge:n.maxAge,maxSize:l});return function(){var r=[].slice.call(arguments),n=a.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}},t=function(n,t){var i,l;void 0===t&&(t={});var a=t.maxAge,o=null!=(i=t.maxSize)?i:1e3,u=null!=(l=t.resolver)?l:function(){return JSON.stringify([].slice.call(arguments))},c=new e,s=new r({maxAge:a,maxSize:o});return 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 l=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 l&&l.then?l.then(i.bind(null,!1),i.bind(null,!0)):i(!1,l)}(0,function(e,n){if(c.release(r),e)throw n;return n}))}catch(e){return Promise.reject(e)}}};export{n as Memoize,t as MemoizeAsync};
+//# sourceMappingURL=memoize.module.js.map

package/lib/memoize.module.js.map

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

package/lib/memoize.umd.js

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

package/lib/memoize.umd.js.map

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

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@chriscdn/memoize",
+  "version": "1.0.0",
+  "description": "Memoize a synchronous or asynchronous function.",
+  "repository": "https://github.com/chriscdn/memoize",
+  "author": "Christopher Meyer <chris@schwiiz.org>",
+  "license": "MIT",
+  "type": "module",
+  "source": "src/index.ts",
+  "exports": {
+    "types": "./lib/index.d.ts",
+    "require": "./lib/memoize.cjs",
+    "default": "./lib/memoize.modern.js"
+  },
+  "main": "./lib/memoize.cjs",
+  "module": "./lib/memoize.module.js",
+  "unpkg": "./lib/memoize.umd.js",
+  "types": "./lib/index.d.ts",
+  "scripts": {
+    "build": "rm -rf ./lib/ && microbundle",
+    "dev": "microbundle watch",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@chriscdn/promise-semaphore": "^2.0.9",
+    "quick-lru": "^7.0.0"
+  },
+  "devDependencies": {
+    "microbundle": "^0.15.1",
+    "vitest": "^2.1.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,101 @@
+import Semaphore from "@chriscdn/promise-semaphore";
+import QuickLRU from "quick-lru";
+
+const kDefaultMaxSize = 1000;
+
+type Options<T extends any[]> = {
+    maxSize: number;
+    maxAge?: number;
+    resolver: (...args: T) => string;
+};
+
+/**
+ * Memoize a synchronous function.
+ *
+ * @template {any[]} Args
+ * @template {{}} Return
+ * @param {(...args: Args) => Return} cb
+ * @param {Partial<Options<Args>>} [options={}]
+ * @returns {Return, options?: Partial<Options<Args>>) => (...args: Args) => Return}
+ */
+const Memoize = <Args extends any[], Return extends {}>(
+    cb: (...args: Args) => Return,
+    options: Partial<Options<Args>> = {},
+) => {
+    const maxAge: number | undefined = options.maxAge;
+    const maxSize = options.maxSize ?? kDefaultMaxSize;
+
+    const resolver = options.resolver ??
+        ((...args: Args) => JSON.stringify(args));
+
+    const cache = new QuickLRU<string, Return>({
+        maxAge,
+        maxSize,
+    });
+
+    return (...args: Args): Return => {
+        const key = resolver(...args);
+
+        if (cache.has(key)) {
+            return cache.get(key)!;
+        } else {
+            const returnValue = cb(...args);
+            cache.set(key, returnValue);
+            return returnValue;
+        }
+    };
+};
+
+/**
+ * Memoize an asynchronous function.
+ *
+ * This differs from the sychronous case by ensuring multiple calls with the
+ * same arguments is only evaluated once. This is controlled by using a
+ * semaphore, which forces redundant calls to wait until the first call
+ * completes.
+ *
+ * @param cb
+ * @param options
+ * @returns
+ */
+const MemoizeAsync = <Args extends any[], Return extends {}>(
+    cb: (...args: Args) => Promise<Return>,
+    options: Partial<Options<Args>> = {},
+) => {
+    const maxAge: number | undefined = options.maxAge;
+    const maxSize = options.maxSize ?? kDefaultMaxSize;
+
+    const resolver = options.resolver ??
+        ((...args: Args) => JSON.stringify(args));
+
+    const semaphore = new Semaphore();
+
+    const cache = new QuickLRU<string, Return>({
+        maxAge,
+        maxSize,
+    });
+
+    return async (...args: Args): Promise<Return> => {
+        const key = resolver(...args);
+
+        if (cache.has(key)) {
+            return cache.get(key)!;
+        } else {
+            try {
+                await semaphore.acquire(key);
+
+                if (cache.has(key)) {
+                    return cache.get(key)!;
+                } else {
+                    const returnValue = await cb(...args);
+                    cache.set(key, returnValue);
+                    return returnValue;
+                }
+            } finally {
+                semaphore.release(key);
+            }
+        }
+    };
+};
+
+export { Memoize, MemoizeAsync };

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "compilerOptions": {
+    "types": ["vitest/importMeta"]
+  }
+}