@signaltree/core 4.0.15 → 4.1.0

package/dist/enhancers/memoization/lib/memoization.js

@@ -1,391 +1,379 @@
-import { deepEqual, LRUCache } from '@signaltree/shared';
-import { isNodeAccessor } from '../../../lib/utils';
+import { isNodeAccessor } from '../../../lib/utils.js';
+import { LRUCache } from '../../../lru-cache.js';
+import { deepEqual } from '../../../deep-equal.js';
+
 const MAX_CACHE_SIZE = 1000;
 const DEFAULT_TTL = 5 * 60 * 1000;
 const memoizationCache = new Map();
 function createMemoCacheStore(maxSize, enableLRU) {
-    if (enableLRU) {
-        const cache = new LRUCache(maxSize);
-        const shadow = new Map();
-        const pruneShadow = () => {
-            while (shadow.size > cache.size()) {
-                const oldestKey = shadow.keys().next().value;
-                if (oldestKey === undefined) {
-                    break;
-                }
-                shadow.delete(oldestKey);
-            }
-        };
-        return {
-            get: (key) => {
-                const value = cache.get(key);
-                if (value !== undefined) {
-                    shadow.set(key, value);
-                }
-                else if (shadow.has(key)) {
-                    shadow.delete(key);
-                }
-                return value;
-            },
-            set: (key, value) => {
-                cache.set(key, value);
-                shadow.set(key, value);
-                pruneShadow();
-            },
-            delete: (key) => {
-                cache.delete(key);
-                shadow.delete(key);
-            },
-            clear: () => {
-                cache.clear();
-                shadow.clear();
-            },
-            size: () => shadow.size,
-            forEach: (callback) => {
-                shadow.forEach((value, key) => callback(value, key));
-            },
-            keys: () => shadow.keys(),
-        };
-    }
-    const store = new Map();
+  if (enableLRU) {
+    const cache = new LRUCache(maxSize);
+    const shadow = new Map();
+    const pruneShadow = () => {
+      while (shadow.size > cache.size()) {
+        const oldestKey = shadow.keys().next().value;
+        if (oldestKey === undefined) {
+          break;
+        }
+        shadow.delete(oldestKey);
+      }
+    };
     return {
-        get: (key) => store.get(key),
-        set: (key, value) => {
-            store.set(key, value);
-        },
-        delete: (key) => store.delete(key),
-        clear: () => store.clear(),
-        size: () => store.size,
-        forEach: (callback) => {
-            store.forEach((value, key) => callback(value, key));
-        },
-        keys: () => store.keys(),
+      get: key => {
+        const value = cache.get(key);
+        if (value !== undefined) {
+          shadow.set(key, value);
+        } else if (shadow.has(key)) {
+          shadow.delete(key);
+        }
+        return value;
+      },
+      set: (key, value) => {
+        cache.set(key, value);
+        shadow.set(key, value);
+        pruneShadow();
+      },
+      delete: key => {
+        cache.delete(key);
+        shadow.delete(key);
+      },
+      clear: () => {
+        cache.clear();
+        shadow.clear();
+      },
+      size: () => shadow.size,
+      forEach: callback => {
+        shadow.forEach((value, key) => callback(value, key));
+      },
+      keys: () => shadow.keys()
     };
+  }
+  const store = new Map();
+  return {
+    get: key => store.get(key),
+    set: (key, value) => {
+      store.set(key, value);
+    },
+    delete: key => store.delete(key),
+    clear: () => store.clear(),
+    size: () => store.size,
+    forEach: callback => {
+      store.forEach((value, key) => callback(value, key));
+    },
+    keys: () => store.keys()
+  };
 }
 function getCleanupInterval(tree) {
-    return tree._memoCleanupInterval;
+  return tree._memoCleanupInterval;
 }
 function setCleanupInterval(tree, interval) {
-    if (interval === undefined) {
-        delete tree._memoCleanupInterval;
-        return;
-    }
-    tree._memoCleanupInterval = interval;
+  if (interval === undefined) {
+    delete tree._memoCleanupInterval;
+    return;
+  }
+  tree._memoCleanupInterval = interval;
 }
 function clearCleanupInterval(tree) {
-    const interval = getCleanupInterval(tree);
-    if (!interval) {
-        return;
-    }
-    try {
-        clearInterval(interval);
-    }
-    catch {
-    }
-    setCleanupInterval(tree);
+  const interval = getCleanupInterval(tree);
+  if (!interval) {
+    return;
+  }
+  try {
+    clearInterval(interval);
+  } catch {}
+  setCleanupInterval(tree);
 }
 function resetMemoizationCaches() {
-    memoizationCache.forEach((cache, tree) => {
-        cache.clear();
-        clearCleanupInterval(tree);
-    });
-    memoizationCache.clear();
+  memoizationCache.forEach((cache, tree) => {
+    cache.clear();
+    clearCleanupInterval(tree);
+  });
+  memoizationCache.clear();
 }
-export function cleanupMemoizationCache() {
-    resetMemoizationCaches();
+function cleanupMemoizationCache() {
+  resetMemoizationCaches();
 }
 function shallowEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a == null || b == null)
-        return false;
-    if (typeof a !== typeof b)
-        return false;
-    if (typeof a === 'object' && typeof b === 'object') {
-        const objA = a;
-        const objB = b;
-        let countA = 0;
-        for (const key in objA) {
-            if (!Object.prototype.hasOwnProperty.call(objA, key))
-                continue;
-            countA++;
-            if (!(key in objB) || objA[key] !== objB[key])
-                return false;
-        }
-        let countB = 0;
-        for (const key in objB) {
-            if (Object.prototype.hasOwnProperty.call(objB, key))
-                countB++;
-        }
-        return countA === countB;
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a === 'object' && typeof b === 'object') {
+    const objA = a;
+    const objB = b;
+    let countA = 0;
+    for (const key in objA) {
+      if (!Object.prototype.hasOwnProperty.call(objA, key)) continue;
+      countA++;
+      if (!(key in objB) || objA[key] !== objB[key]) return false;
     }
-    return false;
+    let countB = 0;
+    for (const key in objB) {
+      if (Object.prototype.hasOwnProperty.call(objB, key)) countB++;
+    }
+    return countA === countB;
+  }
+  return false;
 }
 function generateCacheKey(fn, args) {
-    try {
-        return `${fn.name || 'anonymous'}_${JSON.stringify(args)}`;
-    }
-    catch {
-        return `${fn.name || 'anonymous'}_${args.length}`;
-    }
+  try {
+    return `${fn.name || 'anonymous'}_${JSON.stringify(args)}`;
+  } catch {
+    return `${fn.name || 'anonymous'}_${args.length}`;
+  }
 }
 function getEqualityFn(strategy) {
-    switch (strategy) {
-        case 'shallow':
-            return shallowEqual;
-        case 'reference':
-            return (a, b) => a === b;
-        case 'deep':
-        default:
-            return deepEqual;
-    }
-}
-export function memoize(fn, keyFn, config = {}) {
-    const maxSize = config.maxCacheSize ?? MAX_CACHE_SIZE;
-    const ttl = config.ttl ?? DEFAULT_TTL;
-    const equality = getEqualityFn(config.equality ?? 'shallow');
-    const enableLRU = config.enableLRU ?? false;
-    const cache = createMemoCacheStore(maxSize, enableLRU);
-    const cleanExpiredEntries = () => {
-        if (!ttl)
-            return;
-        const now = Date.now();
-        cache.forEach((entry, key) => {
-            if (entry.timestamp && now - entry.timestamp > ttl) {
-                cache.delete(key);
-            }
-        });
-    };
-    return (...args) => {
-        if (ttl && Math.random() < 0.01) {
-            cleanExpiredEntries();
-        }
-        const key = keyFn
-            ? keyFn(...args)
-            : generateCacheKey(fn, args);
-        const cached = cache.get(key);
-        if (cached && (keyFn || equality(cached.deps, args))) {
-            if (enableLRU) {
-                cached.hitCount += 1;
-            }
-            return cached.value;
-        }
-        const result = fn(...args);
-        cache.set(key, {
-            value: result,
-            deps: args,
-            timestamp: Date.now(),
-            hitCount: 1,
-        });
-        return result;
-    };
+  switch (strategy) {
+    case 'shallow':
+      return shallowEqual;
+    case 'reference':
+      return (a, b) => a === b;
+    case 'deep':
+    default:
+      return deepEqual;
+  }
 }
-export function memoizeShallow(fn, keyFn) {
-    return memoize(fn, keyFn, {
-        equality: 'shallow',
-        enableLRU: false,
-        ttl: undefined,
-        maxCacheSize: 100,
+function memoize(fn, keyFn, config = {}) {
+  const maxSize = config.maxCacheSize ?? MAX_CACHE_SIZE;
+  const ttl = config.ttl ?? DEFAULT_TTL;
+  const equality = getEqualityFn(config.equality ?? 'shallow');
+  const enableLRU = config.enableLRU ?? false;
+  const cache = createMemoCacheStore(maxSize, enableLRU);
+  const cleanExpiredEntries = () => {
+    if (!ttl) return;
+    const now = Date.now();
+    cache.forEach((entry, key) => {
+      if (entry.timestamp && now - entry.timestamp > ttl) {
+        cache.delete(key);
+      }
     });
-}
-export function memoizeReference(fn, keyFn) {
-    return memoize(fn, keyFn, {
-        equality: 'reference',
-        enableLRU: false,
-        ttl: undefined,
-        maxCacheSize: 50,
+  };
+  return (...args) => {
+    if (ttl && Math.random() < 0.01) {
+      cleanExpiredEntries();
+    }
+    const key = keyFn ? keyFn(...args) : generateCacheKey(fn, args);
+    const cached = cache.get(key);
+    if (cached && (keyFn || equality(cached.deps, args))) {
+      if (enableLRU) {
+        cached.hitCount += 1;
+      }
+      return cached.value;
+    }
+    const result = fn(...args);
+    cache.set(key, {
+      value: result,
+      deps: args,
+      timestamp: Date.now(),
+      hitCount: 1
     });
+    return result;
+  };
 }
-export const MEMOIZATION_PRESETS = {
-    selector: {
-        equality: 'reference',
-        maxCacheSize: 10,
-        enableLRU: false,
-        ttl: undefined,
-    },
-    computed: {
-        equality: 'shallow',
-        maxCacheSize: 100,
-        enableLRU: false,
-        ttl: undefined,
-    },
-    deepState: {
-        equality: 'deep',
-        maxCacheSize: 1000,
-        enableLRU: true,
-        ttl: 5 * 60 * 1000,
-    },
-    highFrequency: {
-        equality: 'reference',
-        maxCacheSize: 5,
-        enableLRU: false,
-        ttl: undefined,
-    },
+function memoizeShallow(fn, keyFn) {
+  return memoize(fn, keyFn, {
+    equality: 'shallow',
+    enableLRU: false,
+    ttl: undefined,
+    maxCacheSize: 100
+  });
+}
+function memoizeReference(fn, keyFn) {
+  return memoize(fn, keyFn, {
+    equality: 'reference',
+    enableLRU: false,
+    ttl: undefined,
+    maxCacheSize: 50
+  });
+}
+const MEMOIZATION_PRESETS = {
+  selector: {
+    equality: 'reference',
+    maxCacheSize: 10,
+    enableLRU: false,
+    ttl: undefined
+  },
+  computed: {
+    equality: 'shallow',
+    maxCacheSize: 100,
+    enableLRU: false,
+    ttl: undefined
+  },
+  deepState: {
+    equality: 'deep',
+    maxCacheSize: 1000,
+    enableLRU: true,
+    ttl: 5 * 60 * 1000
+  },
+  highFrequency: {
+    equality: 'reference',
+    maxCacheSize: 5,
+    enableLRU: false,
+    ttl: undefined
+  }
 };
-export function withSelectorMemoization() {
-    return withMemoization(MEMOIZATION_PRESETS.selector);
+function withSelectorMemoization() {
+  return withMemoization(MEMOIZATION_PRESETS.selector);
 }
-export function withComputedMemoization() {
-    return withMemoization(MEMOIZATION_PRESETS.computed);
+function withComputedMemoization() {
+  return withMemoization(MEMOIZATION_PRESETS.computed);
 }
-export function withDeepStateMemoization() {
-    return withMemoization(MEMOIZATION_PRESETS.deepState);
+function withDeepStateMemoization() {
+  return withMemoization(MEMOIZATION_PRESETS.deepState);
 }
-export function withHighFrequencyMemoization() {
-    return withMemoization(MEMOIZATION_PRESETS.highFrequency);
+function withHighFrequencyMemoization() {
+  return withMemoization(MEMOIZATION_PRESETS.highFrequency);
 }
-export function withMemoization(config = {}) {
-    const { enabled = true, maxCacheSize = 1000, ttl, equality = 'deep', enableLRU = true, } = config;
-    return (tree) => {
-        const originalTreeCall = tree.bind(tree);
-        const applyUpdateResult = (result) => {
-            Object.entries(result).forEach(([propKey, value]) => {
-                const property = tree.state[propKey];
-                if (property && 'set' in property) {
-                    property.set(value);
-                }
-                else if (isNodeAccessor(property)) {
-                    property(value);
-                }
-            });
-        };
-        if (!enabled) {
-            const memoTree = tree;
-            memoTree.memoizedUpdate = (updater) => {
-                const currentState = originalTreeCall();
-                const result = updater(currentState);
-                applyUpdateResult(result);
-            };
-            memoTree.clearMemoCache = () => {
-            };
-            memoTree.getCacheStats = () => ({
-                size: 0,
-                hitRate: 0,
-                totalHits: 0,
-                totalMisses: 0,
-                keys: [],
-            });
-            return memoTree;
+function withMemoization(config = {}) {
+  const {
+    enabled = true,
+    maxCacheSize = 1000,
+    ttl,
+    equality = 'deep',
+    enableLRU = true
+  } = config;
+  return tree => {
+    const originalTreeCall = tree.bind(tree);
+    const applyUpdateResult = result => {
+      Object.entries(result).forEach(([propKey, value]) => {
+        const property = tree.state[propKey];
+        if (property && 'set' in property) {
+          property.set(value);
+        } else if (isNodeAccessor(property)) {
+          property(value);
         }
-        const cache = createMemoCacheStore(maxCacheSize, enableLRU);
-        memoizationCache.set(tree, cache);
-        const equalityFn = getEqualityFn(equality);
-        tree.memoizedUpdate = (updater, cacheKey) => {
-            const currentState = originalTreeCall();
-            const key = cacheKey ||
-                generateCacheKey(updater, [
-                    currentState,
-                ]);
-            const cached = cache.get(key);
-            if (cached && equalityFn(cached.deps, [currentState])) {
-                const cachedUpdate = cached.value;
-                applyUpdateResult(cachedUpdate);
-                return;
-            }
-            const result = updater(currentState);
-            cache.set(key, {
-                value: result,
-                deps: [currentState],
-                timestamp: Date.now(),
-                hitCount: 1,
-            });
-            applyUpdateResult(result);
-        };
-        tree.clearMemoCache = (key) => {
-            if (key) {
-                cache.delete(key);
-            }
-            else {
-                cache.clear();
-            }
-        };
-        tree.getCacheStats = () => {
-            let totalHits = 0;
-            let totalMisses = 0;
-            cache.forEach((entry) => {
-                totalHits += entry.hitCount || 0;
-                totalMisses += Math.floor((entry.hitCount || 0) / 2);
-            });
-            const hitRate = totalHits + totalMisses > 0 ? totalHits / (totalHits + totalMisses) : 0;
-            return {
-                size: cache.size(),
-                hitRate,
-                totalHits,
-                totalMisses,
-                keys: Array.from(cache.keys()),
-            };
-        };
-        const maybeInterval = getCleanupInterval(tree);
-        if (maybeInterval) {
-            const origClear = tree.clearMemoCache.bind(tree);
-            tree.clearMemoCache = (key) => {
-                origClear(key);
-                clearCleanupInterval(tree);
-            };
-        }
-        if (ttl) {
-            const cleanup = () => {
-                const now = Date.now();
-                cache.forEach((entry, key) => {
-                    if (entry.timestamp && now - entry.timestamp > ttl) {
-                        cache.delete(key);
-                    }
-                });
-            };
-            const intervalId = setInterval(cleanup, ttl);
-            setCleanupInterval(tree, intervalId);
-        }
-        return tree;
+      });
     };
+    if (!enabled) {
+      const memoTree = tree;
+      memoTree.memoizedUpdate = updater => {
+        const currentState = originalTreeCall();
+        const result = updater(currentState);
+        applyUpdateResult(result);
+      };
+      memoTree.clearMemoCache = () => {};
+      memoTree.getCacheStats = () => ({
+        size: 0,
+        hitRate: 0,
+        totalHits: 0,
+        totalMisses: 0,
+        keys: []
+      });
+      return memoTree;
+    }
+    const cache = createMemoCacheStore(maxCacheSize, enableLRU);
+    memoizationCache.set(tree, cache);
+    const equalityFn = getEqualityFn(equality);
+    tree.memoizedUpdate = (updater, cacheKey) => {
+      const currentState = originalTreeCall();
+      const key = cacheKey || generateCacheKey(updater, [currentState]);
+      const cached = cache.get(key);
+      if (cached && equalityFn(cached.deps, [currentState])) {
+        const cachedUpdate = cached.value;
+        applyUpdateResult(cachedUpdate);
+        return;
+      }
+      const result = updater(currentState);
+      cache.set(key, {
+        value: result,
+        deps: [currentState],
+        timestamp: Date.now(),
+        hitCount: 1
+      });
+      applyUpdateResult(result);
+    };
+    tree.clearMemoCache = key => {
+      if (key) {
+        cache.delete(key);
+      } else {
+        cache.clear();
+      }
+    };
+    tree.getCacheStats = () => {
+      let totalHits = 0;
+      let totalMisses = 0;
+      cache.forEach(entry => {
+        totalHits += entry.hitCount || 0;
+        totalMisses += Math.floor((entry.hitCount || 0) / 2);
+      });
+      const hitRate = totalHits + totalMisses > 0 ? totalHits / (totalHits + totalMisses) : 0;
+      return {
+        size: cache.size(),
+        hitRate,
+        totalHits,
+        totalMisses,
+        keys: Array.from(cache.keys())
+      };
+    };
+    const maybeInterval = getCleanupInterval(tree);
+    if (maybeInterval) {
+      const origClear = tree.clearMemoCache.bind(tree);
+      tree.clearMemoCache = key => {
+        origClear(key);
+        clearCleanupInterval(tree);
+      };
+    }
+    if (ttl) {
+      const cleanup = () => {
+        const now = Date.now();
+        cache.forEach((entry, key) => {
+          if (entry.timestamp && now - entry.timestamp > ttl) {
+            cache.delete(key);
+          }
+        });
+      };
+      const intervalId = setInterval(cleanup, ttl);
+      setCleanupInterval(tree, intervalId);
+    }
+    return tree;
+  };
 }
-export function enableMemoization() {
-    return withMemoization({ enabled: true });
-}
-export function withHighPerformanceMemoization() {
-    return withMemoization({
-        enabled: true,
-        maxCacheSize: 10000,
-        ttl: 300000,
-        equality: 'shallow',
-        enableLRU: true,
-    });
+function withHighPerformanceMemoization() {
+  return withMemoization({
+    enabled: true,
+    maxCacheSize: 10000,
+    ttl: 300000,
+    equality: 'shallow',
+    enableLRU: true
+  });
 }
-export function withLightweightMemoization() {
-    return withMemoization({
-        enabled: true,
-        maxCacheSize: 100,
-        ttl: undefined,
-        equality: 'reference',
-        enableLRU: false,
-    });
+function withLightweightMemoization() {
+  return withMemoization({
+    enabled: true,
+    maxCacheSize: 100,
+    ttl: undefined,
+    equality: 'reference',
+    enableLRU: false
+  });
 }
-export function withShallowMemoization() {
-    return withMemoization({
-        enabled: true,
-        maxCacheSize: 1000,
-        ttl: 60000,
-        equality: 'shallow',
-        enableLRU: true,
-    });
+function withShallowMemoization() {
+  return withMemoization({
+    enabled: true,
+    maxCacheSize: 1000,
+    ttl: 60000,
+    equality: 'shallow',
+    enableLRU: true
+  });
 }
-export function clearAllCaches() {
-    resetMemoizationCaches();
+function clearAllCaches() {
+  resetMemoizationCaches();
 }
-export function getGlobalCacheStats() {
-    let totalSize = 0;
-    let totalHits = 0;
-    let treeCount = 0;
-    memoizationCache.forEach((cache) => {
-        treeCount++;
-        totalSize += cache.size();
-        cache.forEach((entry) => {
-            totalHits += entry.hitCount || 0;
-        });
+function getGlobalCacheStats() {
+  let totalSize = 0;
+  let totalHits = 0;
+  let treeCount = 0;
+  memoizationCache.forEach(cache => {
+    treeCount++;
+    totalSize += cache.size();
+    cache.forEach(entry => {
+      totalHits += entry.hitCount || 0;
     });
-    return {
-        treeCount,
-        totalSize,
-        totalHits,
-        averageCacheSize: treeCount > 0 ? totalSize / treeCount : 0,
-    };
+  });
+  return {
+    treeCount,
+    totalSize,
+    totalHits,
+    averageCacheSize: treeCount > 0 ? totalSize / treeCount : 0
+  };
 }
+
+export { MEMOIZATION_PRESETS, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, memoize, memoizeReference, memoizeShallow, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withMemoization, withSelectorMemoization, withShallowMemoization };