@chriscdn/memoize 1.0.10 → 1.0.11

package/package.json

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

package/__tests__/memoize.test.ts

@@ -1,201 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Memoize, MemoizeAsync } from "../src/index";
-
-let addSyncCount = 0;
-let addAsyncCount = 0;
-
-const add = (x: number, y: number) => {
-  addSyncCount += 1;
-  return x + y;
-};
-
-const addAsync = async (x: number, y: number) => {
-  addAsyncCount += 1;
-  return x + y;
-};
-
-const _asyncThrowError = MemoizeAsync(async (x: number, y: number) => {
-  addAsyncCount += 1;
-  throw new Error("Boom!");
-  return x + y;
-});
-
-const asyncThrowError = MemoizeAsync(async (x: number, y: number) => {
-  try {
-    await _asyncThrowError(x, y);
-  } catch {
-    return -1;
-  }
-});
-
-describe("Memoization", () => {
-  it("sync", async () => {
-    const addCached = Memoize(add);
-
-    expect(addCached(1, 2)).toBe(3);
-    expect(addCached(1, 2)).toBe(3);
-    expect(addCached(1, 2)).toBe(3);
-    expect(addCached(1, 2)).toBe(3);
-    expect(addCached(1, 2)).toBe(3);
-
-    // different key here
-    expect(addCached(2, 1)).toBe(3);
-    expect(addSyncCount).toBe(2);
-  });
-
-  it("async", async () => {
-    const addCachedAsync = MemoizeAsync(addAsync);
-
-    await Promise.all([
-      addCachedAsync(1, 2).then((value) => expect(value).toBe(3)),
-      addCachedAsync(1, 2).then((value) => expect(value).toBe(3)),
-      addCachedAsync(1, 2).then((value) => expect(value).toBe(3)),
-      addCachedAsync(1, 2).then((value) => expect(value).toBe(3)),
-
-      // different key here
-      addCachedAsync(2, 1).then((value) => expect(value).toBe(3)),
-    ]);
-
-    expect(addAsyncCount).toBe(2);
-    expect(addCachedAsync.cache.size).toBe(2);
-  });
-
-  it("resolver", () => {
-    // This its the resolver function to ensure the same value is returned for
-    // the same key.
-
-    const addCachedSameKey = Memoize(add, { resolver: (x, y) => "key" });
-
-    expect(addCachedSameKey(5, 7)).toBe(12);
-    expect(addCachedSameKey(1, 1)).toBe(12);
-    expect(addCachedSameKey(5, 1)).toBe(12);
-  });
-
-  it("async error", async () => {
-    expect(await asyncThrowError(4, 3)).toBe(-1);
-  });
-});
-
-describe("Memoization of Class methods", () => {
-  class AddClass {
-    count: number = 0;
-
-    constructor() {
-      this.add = Memoize(this.add.bind(this));
-    }
-
-    add(x: number, y: number) {
-      this.count += 1;
-      return x + y;
-    }
-  }
-
-  it("Test1", () => {
-    const obj = new AddClass();
-
-    expect(obj.count).toBe(0);
-    expect(obj.add(1, 2)).toBe(3);
-    expect(obj.count).toBe(1);
-    expect(obj.add(1, 2)).toBe(3);
-    expect(obj.count).toBe(1);
-    expect(obj.add(5, 2)).toBe(7);
-    expect(obj.count).toBe(2);
-  });
-});
-
-describe("Null & Undefined Cases", () => {
-  const UndefinedFunc = Memoize((key: string) => undefined, {
-    resolver: (key) => key,
-  });
-
-  const NullFunc = Memoize((key: string) => undefined, {
-    resolver: (key) => key,
-  });
-
-  it("Undefined", () => {
-    expect(UndefinedFunc.cache.has("hello")).toBe(false);
-    expect(UndefinedFunc("hello")).toBe(undefined);
-    expect(UndefinedFunc.cache.has("hello")).toBe(true);
-    expect(UndefinedFunc("hello")).toBe(undefined);
-  });
-
-  it("Null", () => {
-    expect(NullFunc.cache.has("hello")).toBe(false);
-    expect(NullFunc("hello")).toBe(undefined);
-    expect(NullFunc.cache.has("hello")).toBe(true);
-    expect(NullFunc("hello")).toBe(undefined);
-  });
-});
-
-describe("Object Reference", () => {
-  const a = { hello: "world" };
-
-  const funny = Memoize(() => a);
-
-  it("Null", () => {
-    expect(funny().hello).toBe("world");
-  });
-
-  it("Null", () => {
-    a.hello = "mars";
-    expect(funny().hello).toBe("mars");
-  });
-});
-
-describe("ShouldCache", () => {
-  const doNotCache = "do not cache";
-
-  const myFunction = Memoize((word: string) => word, {
-    shouldCache: (value) => value !== doNotCache,
-    resolver: (value) => value,
-  });
-
-  myFunction("hi");
-  myFunction(doNotCache);
-
-  it("should be cached", () => {
-    expect(myFunction.cache.has("hi")).toBe(true);
-  });
-
-  it("should not be cached", () => {
-    expect(myFunction.cache.has(doNotCache)).toBe(false);
-  });
-});
-
-describe("Do we need 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/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 };