Expose frozen wrap(...).options on functions returned by wrap (#504)

* Expose frozen `wrapped.options` on functions returned by `wrap`.

* Simplify/lazify usage of `defaultMakeCacheKey`.

Author: benjamn

src/index.ts

@@ -23,24 +23,20 @@ export {
 // of computation. Subscriptions are supported.
 export { dep, OptimisticDependencyFunction } from "./dep.js";
 
-function makeDefaultMakeCacheKeyFunction<
-  TKeyArgs extends any[],
-  TCacheKey = any,
->(): (...args: TKeyArgs) => TCacheKey {
-  const keyTrie = new Trie<TCacheKey>(typeof WeakMap === "function");
-  return function () {
-    return keyTrie.lookupArray(arguments);
-  };
-}
-
 // The defaultMakeCacheKey function is remarkably powerful, because it gives
 // a unique object for any shallow-identical list of arguments. If you need
 // to implement a custom makeCacheKey function, you may find it helpful to
 // delegate the final work to defaultMakeCacheKey, which is why we export it
 // here. However, you may want to avoid defaultMakeCacheKey if your runtime
 // does not support WeakMap, or you have the ability to return a string key.
 // In those cases, just write your own custom makeCacheKey functions.
-export const defaultMakeCacheKey = makeDefaultMakeCacheKeyFunction();
+let defaultKeyTrie: Trie<object> | undefined;
+export function defaultMakeCacheKey(...args: any[]): object {
+  const trie = defaultKeyTrie || (
+    defaultKeyTrie = new Trie(typeof WeakMap === "function")
+  );
+  return trie.lookupArray(args);
+}
 
 // If you're paranoid about memory leaks, or you want to avoid using WeakMap
 // under the hood, but you still need the behavior of defaultMakeCacheKey,
@@ -56,6 +52,9 @@ export type OptimisticWrapperFunction<
   // Get the current number of Entry objects in the LRU cache.
   readonly size: number;
 
+  // Snapshot of wrap options used to create this wrapper function.
+  options: OptimisticWrapOptions<TArgs, TKeyArgs, TCacheKey>;
+
   // "Dirty" any cached Entry stored for the given arguments, marking that Entry
   // and its ancestors as potentially needing to be recomputed. The .dirty(...)
   // method of an optimistic function takes the same parameter types as the
@@ -115,19 +114,17 @@ export function wrap<
   TResult,
   TKeyArgs extends any[] = TArgs,
   TCacheKey = any,
->(
-  originalFunction: (...args: TArgs) => TResult,
-  options: OptimisticWrapOptions<TArgs, TKeyArgs> = Object.create(null),
-) {
+>(originalFunction: (...args: TArgs) => TResult, {
+  max = Math.pow(2, 16),
+  makeCacheKey = defaultMakeCacheKey,
+  keyArgs,
+  subscribe,
+}: OptimisticWrapOptions<TArgs, TKeyArgs> = Object.create(null)) {
   const cache = new Cache<TCacheKey, Entry<TArgs, TResult>>(
-    options.max || Math.pow(2, 16),
+    max,
     entry => entry.dispose(),
   );
 
-  const keyArgs = options.keyArgs;
-  const makeCacheKey = options.makeCacheKey ||
-    makeDefaultMakeCacheKeyFunction<TKeyArgs, TCacheKey>();
-
   const optimistic = function (): TResult {
     const key = makeCacheKey.apply(
       null,
@@ -141,7 +138,7 @@ export function wrap<
     let entry = cache.get(key)!;
     if (!entry) {
       cache.set(key, entry = new Entry(originalFunction));
-      entry.subscribe = options.subscribe;
+      entry.subscribe = subscribe;
       // Give the Entry the ability to trigger cache.delete(key), even though
       // the Entry itself does not know about key or cache.
       entry.forget = () => cache.delete(key);
@@ -176,6 +173,13 @@ export function wrap<
     enumerable: false,
   });
 
+  Object.freeze(optimistic.options = {
+    max,
+    makeCacheKey,
+    keyArgs,
+    subscribe,
+  });
+
   function dirtyKey(key: TCacheKey) {
     const entry = cache.get(key);
     if (entry) {

src/tests/api.ts

@@ -502,6 +502,31 @@ describe("optimism", function () {
     assert.strictEqual(sumNums("a", 1, "b", 2, "c", 3), sumObj2);
   });
 
+  it("supports wrap(fn, {...}).options to reflect input options", function () {
+    const keyArgs: () => [] = () => [];
+    function makeCacheKey() { return "constant"; }
+    function subscribe() {}
+
+    let counter1 = 0;
+    const wrapped = wrap(() => ++counter1, {
+      max: 10,
+      keyArgs,
+      makeCacheKey,
+      subscribe,
+    });
+    assert.strictEqual(wrapped.options.max, 10);
+    assert.strictEqual(wrapped.options.keyArgs, keyArgs);
+    assert.strictEqual(wrapped.options.makeCacheKey, makeCacheKey);
+    assert.strictEqual(wrapped.options.subscribe, subscribe);
+
+    let counter2 = 0;
+    const wrappedWithDefaults = wrap(() => ++counter2);
+    assert.strictEqual(wrappedWithDefaults.options.max, Math.pow(2, 16));
+    assert.strictEqual(wrappedWithDefaults.options.keyArgs, void 0);
+    assert.strictEqual(typeof wrappedWithDefaults.options.makeCacheKey, "function");
+    assert.strictEqual(wrappedWithDefaults.options.subscribe, void 0);
+  });
+
   it("tolerates cycles when propagating dirty/clean signals", function () {
     let counter = 0;
     const dep = wrap(() => ++counter);
@@ -541,6 +566,8 @@ describe("optimism", function () {
         max: 10
       });
 
+    assert.strictEqual(fib.options.max, 10);
+
     assert.strictEqual(fib(78), 8944394323791464);
     assert.strictEqual(fib(68), 72723460248141);
     assert.strictEqual(fib(58), 591286729879);
@@ -633,6 +660,7 @@ describe("optimism", function () {
         }
     });
 
+    assert.strictEqual(sumFirst.options.makeCacheKey!(7), 14);
     assert.strictEqual(sumFirst(10), 55);
 
     /*