@chriscdn/memoize 1.0.10 → 1.0.12

package/lib/index.cjs

@@ -0,0 +1,99 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Memoize: () => Memoize,
+  MemoizeAsync: () => MemoizeAsync
+});
+module.exports = __toCommonJS(index_exports);
+var import_promise_semaphore = require("@chriscdn/promise-semaphore");
+var import_quick_lru = __toESM(require("quick-lru"), 1);
+var kDefaultMaxSize = 1e3;
+var Memoize = (cb, options = {}) => {
+  const maxAge = options.maxAge;
+  const maxSize = options.maxSize ?? kDefaultMaxSize;
+  const shouldCache = options.shouldCache ?? (() => true);
+  const resolver = options.resolver ?? ((...args) => JSON.stringify(args));
+  const cache = new import_quick_lru.default({
+    maxAge,
+    maxSize
+  });
+  const memoizedFunction = (...args) => {
+    const key = resolver(...args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    } else {
+      const returnValue = cb(...args);
+      if (shouldCache(returnValue, key)) {
+        cache.set(key, returnValue);
+      }
+      return returnValue;
+    }
+  };
+  memoizedFunction.cache = cache;
+  return memoizedFunction;
+};
+var MemoizeAsync = (cb, options = {}) => {
+  const maxAge = options.maxAge;
+  const maxSize = options.maxSize ?? kDefaultMaxSize;
+  const shouldCache = options.shouldCache ?? (() => true);
+  const resolver = options.resolver ?? ((...args) => JSON.stringify(args));
+  const cache = new import_quick_lru.default({
+    maxAge,
+    maxSize
+  });
+  const semaphore = new import_promise_semaphore.Semaphore();
+  const memoizedFunction = async (...args) => {
+    const key = resolver(...args);
+    try {
+      await semaphore.acquire(key);
+      if (cache.has(key)) {
+        return cache.get(key);
+      } else {
+        const returnValue = await cb(...args);
+        if (shouldCache(returnValue, key)) {
+          cache.set(key, returnValue);
+        }
+        return returnValue;
+      }
+    } finally {
+      semaphore.release(key);
+    }
+  };
+  memoizedFunction.cache = cache;
+  return memoizedFunction;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Memoize,
+  MemoizeAsync
+});
+//# sourceMappingURL=index.cjs.map

package/lib/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+BAA0B;AAC1B,uBAAqB;AAErB,IAAM,kBAAkB;AAYxB,IAAM,UAAU,CACd,IACA,UAA0C,CAAC,MACxC;AACH,QAAM,SAA6B,QAAQ;AAC3C,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,cAAc,QAAQ,gBAAgB,MAAM;AAElD,QAAM,WAAW,QAAQ,aACtB,IAAI,SAAe,KAAK,UAAU,IAAI;AAEzC,QAAM,QAAQ,IAAI,iBAAAA,QAAyB;AAAA,IACzC;AAAA,IACA;AAAA,EACF,CAAC;AAED,QAAM,mBAAmB,IAAI,SAAuB;AAClD,UAAM,MAAM,SAAS,GAAG,IAAI;AAE5B,QAAI,MAAM,IAAI,GAAG,GAAG;AAClB,aAAO,MAAM,IAAI,GAAG;AAAA,IACtB,OAAO;AACL,YAAM,cAAc,GAAG,GAAG,IAAI;AAC9B,UAAI,YAAY,aAAa,GAAG,GAAG;AACjC,cAAM,IAAI,KAAK,WAAW;AAAA,MAC5B;AACA,aAAO;AAAA,IACT;AAAA,EACF;AAEA,mBAAiB,QAAQ;AAEzB,SAAO;AACT;AAKA,IAAM,eAAe,CACnB,IACA,UAA0C,CAAC,MACxC;AACH,QAAM,SAA6B,QAAQ;AAC3C,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,cAAc,QAAQ,gBAAgB,MAAM;AAElD,QAAM,WAAW,QAAQ,aACtB,IAAI,SAAe,KAAK,UAAU,IAAI;AAEzC,QAAM,QAAQ,IAAI,iBAAAA,QAAyB;AAAA,IACzC;AAAA,IACA;AAAA,EACF,CAAC;AAED,QAAM,YAAY,IAAI,mCAAU;AAEhC,QAAM,mBAAmB,UAAU,SAAgC;AACjE,UAAM,MAAM,SAAS,GAAG,IAAI;AAE5B,QAAI;AACF,YAAM,UAAU,QAAQ,GAAG;AAE3B,UAAI,MAAM,IAAI,GAAG,GAAG;AAClB,eAAO,MAAM,IAAI,GAAG;AAAA,MACtB,OAAO;AACL,cAAM,cAAc,MAAM,GAAG,GAAG,IAAI;AACpC,YAAI,YAAY,aAAa,GAAG,GAAG;AACjC,gBAAM,IAAI,KAAK,WAAW;AAAA,QAC5B;AACA,eAAO;AAAA,MACT;AAAA,IACF,UAAE;AACA,gBAAU,QAAQ,GAAG;AAAA,IACvB;AAAA,EACF;AAEA,mBAAiB,QAAQ;AAEzB,SAAO;AACT;","names":["QuickLRU"]}

package/lib/index.d.cts

@@ -0,0 +1,24 @@
+import QuickLRU from 'quick-lru';
+
+type Options<T extends any[], Return> = {
+    maxSize: number;
+    maxAge?: number;
+    shouldCache: (returnValue: Return, key: string) => boolean;
+    resolver: (...args: T) => string;
+};
+/**
+ * Memoize a synchronous function.
+ */
+declare const Memoize: <Args extends unknown[], Return>(cb: (...args: Args) => Return, options?: Partial<Options<Args, Return>>) => {
+    (...args: Args): Return;
+    cache: QuickLRU<string, Return>;
+};
+/**
+ * Memoize an asynchronous function.
+ */
+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/index.d.ts

@@ -1,22 +1,24 @@
-import QuickLRU from "quick-lru";
-type Options<T extends any[], Return> = {
-    maxSize: number;
-    maxAge?: number;
-    shouldCache: (returnValue: Return, key: string) => boolean;
-    resolver: (...args: T) => string;
-};
-/**
- * Memoize a synchronous function.
- */
-declare const Memoize: <Args extends unknown[], Return>(cb: (...args: Args) => Return, options?: Partial<Options<Args, Return>>) => {
-    (...args: Args): Return;
-    cache: QuickLRU<string, Return>;
-};
-/**
- * Memoize an asynchronous function.
- */
-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 };
+import QuickLRU from 'quick-lru';
+
+type Options<T extends any[], Return> = {
+    maxSize: number;
+    maxAge?: number;
+    shouldCache: (returnValue: Return, key: string) => boolean;
+    resolver: (...args: T) => string;
+};
+/**
+ * Memoize a synchronous function.
+ */
+declare const Memoize: <Args extends unknown[], Return>(cb: (...args: Args) => Return, options?: Partial<Options<Args, Return>>) => {
+    (...args: Args): Return;
+    cache: QuickLRU<string, Return>;
+};
+/**
+ * Memoize an asynchronous function.
+ */
+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/index.js

@@ -0,0 +1,63 @@
+// src/index.ts
+import { Semaphore } from "@chriscdn/promise-semaphore";
+import QuickLRU from "quick-lru";
+var kDefaultMaxSize = 1e3;
+var Memoize = (cb, options = {}) => {
+  const maxAge = options.maxAge;
+  const maxSize = options.maxSize ?? kDefaultMaxSize;
+  const shouldCache = options.shouldCache ?? (() => true);
+  const resolver = options.resolver ?? ((...args) => JSON.stringify(args));
+  const cache = new QuickLRU({
+    maxAge,
+    maxSize
+  });
+  const memoizedFunction = (...args) => {
+    const key = resolver(...args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    } else {
+      const returnValue = cb(...args);
+      if (shouldCache(returnValue, key)) {
+        cache.set(key, returnValue);
+      }
+      return returnValue;
+    }
+  };
+  memoizedFunction.cache = cache;
+  return memoizedFunction;
+};
+var MemoizeAsync = (cb, options = {}) => {
+  const maxAge = options.maxAge;
+  const maxSize = options.maxSize ?? kDefaultMaxSize;
+  const shouldCache = options.shouldCache ?? (() => true);
+  const resolver = options.resolver ?? ((...args) => JSON.stringify(args));
+  const cache = new QuickLRU({
+    maxAge,
+    maxSize
+  });
+  const semaphore = new Semaphore();
+  const memoizedFunction = async (...args) => {
+    const key = resolver(...args);
+    try {
+      await semaphore.acquire(key);
+      if (cache.has(key)) {
+        return cache.get(key);
+      } else {
+        const returnValue = await cb(...args);
+        if (shouldCache(returnValue, key)) {
+          cache.set(key, returnValue);
+        }
+        return returnValue;
+      }
+    } finally {
+      semaphore.release(key);
+    }
+  };
+  memoizedFunction.cache = cache;
+  return memoizedFunction;
+};
+export {
+  Memoize,
+  MemoizeAsync
+};
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"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"],"mappings":";AAAA,SAAS,iBAAiB;AAC1B,OAAO,cAAc;AAErB,IAAM,kBAAkB;AAYxB,IAAM,UAAU,CACd,IACA,UAA0C,CAAC,MACxC;AACH,QAAM,SAA6B,QAAQ;AAC3C,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,cAAc,QAAQ,gBAAgB,MAAM;AAElD,QAAM,WAAW,QAAQ,aACtB,IAAI,SAAe,KAAK,UAAU,IAAI;AAEzC,QAAM,QAAQ,IAAI,SAAyB;AAAA,IACzC;AAAA,IACA;AAAA,EACF,CAAC;AAED,QAAM,mBAAmB,IAAI,SAAuB;AAClD,UAAM,MAAM,SAAS,GAAG,IAAI;AAE5B,QAAI,MAAM,IAAI,GAAG,GAAG;AAClB,aAAO,MAAM,IAAI,GAAG;AAAA,IACtB,OAAO;AACL,YAAM,cAAc,GAAG,GAAG,IAAI;AAC9B,UAAI,YAAY,aAAa,GAAG,GAAG;AACjC,cAAM,IAAI,KAAK,WAAW;AAAA,MAC5B;AACA,aAAO;AAAA,IACT;AAAA,EACF;AAEA,mBAAiB,QAAQ;AAEzB,SAAO;AACT;AAKA,IAAM,eAAe,CACnB,IACA,UAA0C,CAAC,MACxC;AACH,QAAM,SAA6B,QAAQ;AAC3C,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,cAAc,QAAQ,gBAAgB,MAAM;AAElD,QAAM,WAAW,QAAQ,aACtB,IAAI,SAAe,KAAK,UAAU,IAAI;AAEzC,QAAM,QAAQ,IAAI,SAAyB;AAAA,IACzC;AAAA,IACA;AAAA,EACF,CAAC;AAED,QAAM,YAAY,IAAI,UAAU;AAEhC,QAAM,mBAAmB,UAAU,SAAgC;AACjE,UAAM,MAAM,SAAS,GAAG,IAAI;AAE5B,QAAI;AACF,YAAM,UAAU,QAAQ,GAAG;AAE3B,UAAI,MAAM,IAAI,GAAG,GAAG;AAClB,eAAO,MAAM,IAAI,GAAG;AAAA,MACtB,OAAO;AACL,cAAM,cAAc,MAAM,GAAG,GAAG,IAAI;AACpC,YAAI,YAAY,aAAa,GAAG,GAAG;AACjC,gBAAM,IAAI,KAAK,WAAW;AAAA,QAC5B;AACA,eAAO;AAAA,MACT;AAAA,IACF,UAAE;AACA,gBAAU,QAAQ,GAAG;AAAA,IACvB;AAAA,EACF;AAEA,mBAAiB,QAAQ;AAEzB,SAAO;AACT;","names":[]}

package/package.json

@@ -1,32 +1,42 @@
 {
   "name": "@chriscdn/memoize",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "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",
+  "main": "./lib/index.cjs",
+  "module": "./lib/index.js",
+  "types": "./lib/index.d.ts",
   "exports": {
-    "types": "./lib/index.d.ts",
-    "require": "./lib/memoize.cjs",
-    "default": "./lib/memoize.modern.js"
+    ".": {
+      "import": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "require": {
+        "types": "./lib/index.d.cts",
+        "default": "./lib/index.cjs"
+      }
+    }
   },
-  "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 --format modern,esm,cjs",
-    "dev": "microbundle watch",
+    "build": "tsup",
+    "watch": "yarn build --watch",
     "test": "vitest"
   },
   "dependencies": {
-    "@chriscdn/promise-semaphore": "^3.0.1",
-    "quick-lru": "^7.0.1"
+    "@chriscdn/promise-semaphore": "^3.1.3",
+    "quick-lru": "^7.3.0"
   },
   "devDependencies": {
-    "microbundle": "^0.15.1",
-    "vitest": "^3.2.4"
-  }
+    "@tsconfig/strictest": "^2.0.8",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.8"
+  },
+  "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 Memoize?", 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/lib/memoize.cjs

@@ -1,2 +0,0 @@
-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 +0,0 @@
-{"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 +0,0 @@
-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 +0,0 @@
-{"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 +0,0 @@
-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 +0,0 @@
-{"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/src/index.ts

@@ -1,97 +0,0 @@
-import { Semaphore } from "@chriscdn/promise-semaphore";
-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;
-};
-
-/**
- * Memoize an asynchronous function.
- */
-const MemoizeAsync = <Args extends unknown[], Return>(
-  cb: (...args: Args) => Promise<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 semaphore = new Semaphore();
-
-  const memoizedFunction = async (...args: Args): Promise<Return> => {
-    const key = resolver(...args);
-
-    try {
-      await semaphore.acquire(key);
-
-      if (cache.has(key)) {
-        return cache.get(key) as Return;
-      } else {
-        const returnValue = await cb(...args);
-        if (shouldCache(returnValue, key)) {
-          cache.set(key, returnValue);
-        }
-        return returnValue;
-      }
-    } finally {
-      semaphore.release(key);
-    }
-  };
-
-  memoizedFunction.cache = cache;
-
-  return memoizedFunction;
-};
-
-export { Memoize, MemoizeAsync };