@chriscdn/memoize 1.0.3 → 1.0.5

package/README.md

@@ -97,6 +97,29 @@ console.log(addCachedAsync.cache.size === 1);
 // true
 ```
 
+## Class Methods
+
+Class methods can also be memoized, though this requires overriding the method within the constructor. When doing so, it's important to bind the method to the instance to ensure it maintains the correct context.
+
+Consider the following example, where the `add` method is memoized by reassigning it within the constructor after binding it to the current instance. This ensures the memoized version retains access to instance properties like `count` and keeps TypeScript happy by preserving the method's type signature.
+
+```ts
+class AddClass {
+  count: number = 0;
+
+  constructor() {
+    this.add = Memoize(this.add.bind(this));
+  }
+
+  add(x: number, y: number) {
+    this.count += 1;
+    return x + y;
+  }
+}
+```
+
+Keep in mind that each instance of a class will maintain its own separate cache.
+
 ## Tests
 
 ```bash

package/__tests__/memoize.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { describe, expect, it } from "vitest";
 import { Memoize, MemoizeAsync } from "../src/index";
 
 let addSyncCount = 0;
@@ -14,44 +14,91 @@ const addAsync = async (x: number, y: number) => {
   return x + y;
 };
 
-test("sync", async () => {
-  const addCached = Memoize(add);
-
-  expect(addCached(1, 2)).toBe(3);
-  expect(addCached(1, 2)).toBe(3);
-  expect(addCached(1, 2)).toBe(3);
-  expect(addCached(1, 2)).toBe(3);
-  expect(addCached(1, 2)).toBe(3);
+const _asyncThrowError = MemoizeAsync(async (x: number, y: number) => {
+  addAsyncCount += 1;
+  throw new Error("Boom!");
+  return x + y;
+});
 
-  // different key here
-  expect(addCached(2, 1)).toBe(3);
-  expect(addSyncCount).toBe(2);
+const asyncThrowError = MemoizeAsync(async (x: number, y: number) => {
+  try {
+    await _asyncThrowError(x, y);
+  } catch {
+    return -1;
+  }
 });
 
-test("async", async () => {
-  const addCachedAsync = MemoizeAsync(addAsync);
+describe("Memoization", () => {
+  it("sync", async () => {
+    const addCached = Memoize(add);
 
-  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)),
+    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
-    addCachedAsync(2, 1).then((value) => expect(value).toBe(3)),
-  ]);
+    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);
+    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);
+  });
 });
 
-test("resolver", () => {
-  // This tests the resolver function to ensure the same value is returned for
-  // the same key.
+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;
+    }
+  }
 
-  const addCachedSameKey = Memoize(add, { resolver: (x, y) => "key" });
+  it("Test1", () => {
+    const obj = new AddClass();
 
-  expect(addCachedSameKey(5, 7)).toBe(12);
-  expect(addCachedSameKey(1, 1)).toBe(12);
-  expect(addCachedSameKey(5, 1)).toBe(12);
+    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);
+  });
 });

package/lib/index.d.ts

@@ -14,7 +14,7 @@ declare const Memoize: <Args extends unknown[], Return>(cb: (...args: Args) => R
 /**
  * Memoize an asynchronous function.
  *
- * This differs from the sychronous case by ensuring multiple calls with the
+ * This differs from the synchronous 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.

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 = 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);\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 sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    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,SACZA,EACAC,GACAC,IAAAA,EAAAC,OADAF,IAAAA,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAAA,QAAyB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGEU,EAAmB,WAAI,IAAAC,EAAUP,GAAAA,MAAAC,KAAAC,WAC7BM,EAAMX,EAAQY,WAAIF,EAAAA,GAExB,GAAIJ,EAAMO,IAAIF,GACV,OAAOL,EAAMQ,IAAIH,GAEjB,IAAMI,EAAcpB,EAAEiB,WAAIF,EAAAA,GAE1B,OADAJ,EAAMU,IAAIL,EAAKI,GACRA,CAEf,EAIA,OAFAN,EAAiBH,MAAQA,EAElBG,CACX,uBAUqB,SACjBd,EACAC,GACAqB,IAAAA,EAAAC,OADAtB,IAAAA,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyBkB,OAAlBA,EAAGrB,EAAQG,SAAOkB,EAxDX,IA0DdjB,EAA2BkB,OAAnBA,EAAGtB,EAAQI,UAAQkB,EAC5B,WAAmB,OAAAjB,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAEtCc,EAAY,IAAIC,EAAW,QAE3Bd,EAAQ,IAAIC,EAAAA,QAAyB,CACvCC,OAAAA,EACAT,QAAAA,IAGEU,EAAA,eAA4DY,IAA/BX,EAAU,GAAAP,MAAAC,KAAqBC,WACxDM,EAAMX,EAAQY,WAAIF,EAAAA,GAAM,OAAAY,QAAAC,QAE1BjB,EAAMO,IAAIF,GACHL,EAAMQ,IAAIH,2BAEbW,QAAAC,QACMJ,EAAUK,QAAQb,IAAIc,KAAA,WAAA,OAExBnB,EAAMO,IAAIF,GACHL,EAAMQ,IAAIH,GAAKW,QAAAC,QAEI5B,EAAEiB,WAAIF,EAAAA,IAAKe,KAAA,SAA/BV,GAEN,OADAT,EAAMU,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBW,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQlB,GAAKgB,EAAA,MAAAC,EAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAA,OAAAR,QAAAS,OAAAD,EAEDrB,CAAAA,EAEA,OAFAA,EAAiBH,MAAQA,EAElBG,CACX"}
+{"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"}

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 = 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);\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 sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    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,CACZC,EACAC,EAAkC,CAAA,KAClC,IAAAC,EAAAC,EACA,MACMC,SAAOF,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,IAAIG,IAAeC,KAAKC,UAAUF,GAEjCG,EAAQ,IAAIC,EAAyB,CACvCC,OAP+BV,EAAQU,OAQvCP,YAGEQ,EAAmBA,IAAIN,KACzB,MAAMO,EAAMR,KAAYC,GAExB,GAAIG,EAAMK,IAAID,GACV,OAAOJ,EAAMM,IAAIF,GACd,CACH,MAAMG,EAAchB,KAAMM,GAE1B,OADAG,EAAMQ,IAAIJ,EAAKG,GACRA,CACV,GAKL,OAFAJ,EAAiBH,MAAQA,EAElBG,GAWLM,EAAeA,CACjBlB,EACAC,EAAkC,CAAA,KAClC,IAAAkB,EAAAC,EACA,MAAMT,EAA6BV,EAAQU,OACrCP,EAAyBe,OAAlBA,EAAGlB,EAAQG,SAAOe,EAxDX,IA0Ddd,SAAQe,EAAGnB,EAAQI,UAAQe,EAC5B,IAAId,IAAeC,KAAKC,UAAUF,GAEjCe,EAAY,IAAIC,EAEhBb,EAAQ,IAAIC,EAAyB,CACvCC,SACAP,YAGEQ,EAAmBW,SAAUjB,KAC/B,MAAMO,EAAMR,KAAYC,GAExB,GAAIG,EAAMK,IAAID,GACV,OAAOJ,EAAMM,IAAIF,GAEjB,IAGI,SAFMQ,EAAUG,QAAQX,GAEpBJ,EAAMK,IAAID,GACV,OAAOJ,EAAMM,IAAIF,GACd,CACH,MAAMG,QAAoBhB,KAAMM,GAEhC,OADAG,EAAMQ,IAAIJ,EAAKG,GACRA,CACV,CACJ,CAAA,QACGK,EAAUI,QAAQZ,EACrB,CACJ,EAKL,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[]> = {\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"}

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 = 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);\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 sychronous case by ensuring multiple calls with the\n * same arguments is only evaluated once. This is controlled by using a\n * semaphore, which forces redundant calls to wait until the first call\n * completes.\n */\nconst MemoizeAsync = <Args extends unknown[], Return>(\n    cb: (...args: Args) => Promise<Return>,\n    options: Partial<Options<Args>> = {},\n) => {\n    const maxAge: number | undefined = options.maxAge;\n    const maxSize = options.maxSize ?? kDefaultMaxSize;\n\n    const resolver = options.resolver ??\n        ((...args: Args) => JSON.stringify(args));\n\n    const semaphore = new Semaphore();\n\n    const cache = new QuickLRU<string, Return>({\n        maxAge,\n        maxSize,\n    });\n\n    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,SACZC,EACAC,GACAC,IAAAA,EAAAC,OADAF,IAAAA,IAAAA,EAAkC,CAAA,GAElC,IACMG,EAAyB,OAAlBF,EAAGD,EAAQG,SAAOF,EAhBX,IAkBdG,EAA2B,OAAnBF,EAAGF,EAAQI,UAAQF,EAC5B,WAAmB,OAAAG,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAEtCC,EAAQ,IAAIC,EAAyB,CACvCC,OAP+BZ,EAAQY,OAQvCT,QAAAA,IAGEU,EAAmB,WAAI,IAAAC,EAAUP,GAAAA,MAAAC,KAAAC,WAC7BM,EAAMX,EAAQY,WAAIF,EAAAA,GAExB,GAAIJ,EAAMO,IAAIF,GACV,OAAOL,EAAMQ,IAAIH,GAEjB,IAAMI,EAAcpB,EAAEiB,WAAIF,EAAAA,GAE1B,OADAJ,EAAMU,IAAIL,EAAKI,GACRA,CAEf,EAIA,OAFAN,EAAiBH,MAAQA,EAElBG,CACX,EAUMQ,EAAe,SACjBtB,EACAC,GACAsB,IAAAA,EAAAC,OADAvB,IAAAA,IAAAA,EAAkC,CAAE,GAEpC,IAAMY,EAA6BZ,EAAQY,OACrCT,EAAyBmB,OAAlBA,EAAGtB,EAAQG,SAAOmB,EAxDX,IA0DdlB,EAA2BmB,OAAnBA,EAAGvB,EAAQI,UAAQmB,EAC5B,WAAmB,OAAAlB,KAAKC,UAAS,GAAAC,MAAAC,KAAAC,WAAM,EAEtCe,EAAY,IAAIC,EAEhBf,EAAQ,IAAIC,EAAyB,CACvCC,OAAAA,EACAT,QAAAA,IAGEU,EAAA,eAA4Da,IAA/BZ,EAAU,GAAAP,MAAAC,KAAqBC,WACxDM,EAAMX,EAAQY,WAAIF,EAAAA,GAAM,OAAAa,QAAAC,QAE1BlB,EAAMO,IAAIF,GACHL,EAAMQ,IAAIH,2BAEbY,QAAAC,QACMJ,EAAUK,QAAQd,IAAIe,KAAA,WAAA,OAExBpB,EAAMO,IAAIF,GACHL,EAAMQ,IAAIH,GAAKY,QAAAC,QAEI7B,EAAEiB,WAAIF,EAAAA,IAAKgB,KAAA,SAA/BX,GAEN,OADAT,EAAMU,IAAIL,EAAKI,GACRA,CAAY,EAE1B,4FAZsBY,CAEnB,EAUHC,SAAAA,EAAAC,GAC0B,GAAvBT,EAAUU,QAAQnB,GAAKiB,EAAA,MAAAC,EAAA,OAAAA,CAAA,GAGnC,CAAC,MAAAE,GAAA,OAAAR,QAAAS,OAAAD,EAEDtB,CAAAA,EAEA,OAFAA,EAAiBH,MAAQA,EAElBG,CACX"}
+{"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chriscdn/memoize",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Memoize a synchronous or asynchronous function.",
   "repository": "https://github.com/chriscdn/memoize",
   "author": "Christopher Meyer <chris@schwiiz.org>",
@@ -22,11 +22,11 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@chriscdn/promise-semaphore": "^2.0.9",
+    "@chriscdn/promise-semaphore": "^2.0.10",
     "quick-lru": "^7.0.0"
   },
   "devDependencies": {
     "microbundle": "^0.15.1",
-    "vitest": "^2.1.8"
+    "vitest": "^3.0.7"
   }
 }

package/src/index.ts

@@ -4,96 +4,96 @@ import QuickLRU from "quick-lru";
 const kDefaultMaxSize = 1000;
 
 type Options<T extends any[]> = {
-    maxSize: number;
-    maxAge?: number;
-    resolver: (...args: T) => string;
+  maxSize: number;
+  maxAge?: number;
+  resolver: (...args: T) => string;
 };
 
 /**
  * Memoize a synchronous function.
  */
 const Memoize = <Args extends unknown[], Return>(
-    cb: (...args: Args) => Return,
-    options: Partial<Options<Args>> = {},
+  cb: (...args: Args) => Return,
+  options: Partial<Options<Args>> = {},
 ) => {
-    const maxAge: number | undefined = options.maxAge;
-    const maxSize = options.maxSize ?? kDefaultMaxSize;
+  const maxAge: number | undefined = options.maxAge;
+  const maxSize = options.maxSize ?? kDefaultMaxSize;
 
-    const resolver = options.resolver ??
-        ((...args: Args) => JSON.stringify(args));
+  const resolver =
+    options.resolver ?? ((...args: Args) => JSON.stringify(args));
 
-    const cache = new QuickLRU<string, Return>({
-        maxAge,
-        maxSize,
-    });
+  const cache = new QuickLRU<string, Return>({
+    maxAge,
+    maxSize,
+  });
 
-    const memoizedFunction = (...args: Args): Return => {
-        const key = resolver(...args);
+  const memoizedFunction = (...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;
-        }
-    };
+    if (cache.has(key)) {
+      return cache.get(key);
+    } else {
+      const returnValue = cb(...args);
+      cache.set(key, returnValue);
+      return returnValue;
+    }
+  };
 
-    memoizedFunction.cache = cache;
+  memoizedFunction.cache = cache;
 
-    return memoizedFunction;
+  return memoizedFunction;
 };
 
 /**
  * Memoize an asynchronous function.
  *
- * This differs from the sychronous case by ensuring multiple calls with the
+ * This differs from the synchronous 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.
  */
 const MemoizeAsync = <Args extends unknown[], Return>(
-    cb: (...args: Args) => Promise<Return>,
-    options: Partial<Options<Args>> = {},
+  cb: (...args: Args) => Promise<Return>,
+  options: Partial<Options<Args>> = {},
 ) => {
-    const maxAge: number | undefined = options.maxAge;
-    const maxSize = options.maxSize ?? kDefaultMaxSize;
+  const maxAge: number | undefined = options.maxAge;
+  const maxSize = options.maxSize ?? kDefaultMaxSize;
+
+  const resolver =
+    options.resolver ?? ((...args: Args) => JSON.stringify(args));
 
-    const resolver = options.resolver ??
-        ((...args: Args) => JSON.stringify(args));
+  const semaphore = new Semaphore();
 
-    const semaphore = new Semaphore();
+  const cache = new QuickLRU<string, Return>({
+    maxAge,
+    maxSize,
+  });
 
-    const cache = new QuickLRU<string, Return>({
-        maxAge,
-        maxSize,
-    });
+  const memoizedFunction = async (...args: Args): Promise<Return> => {
+    const key = resolver(...args);
 
-    const memoizedFunction = 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)!;
+          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);
-            }
+          const returnValue = await cb(...args);
+          cache.set(key, returnValue);
+          return returnValue;
         }
-    };
+      } finally {
+        semaphore.release(key);
+      }
+    }
+  };
 
-    memoizedFunction.cache = cache;
+  memoizedFunction.cache = cache;
 
-    return memoizedFunction;
+  return memoizedFunction;
 };
 
 export { Memoize, MemoizeAsync };