@signaltree/core 6.0.0 → 6.0.1

package/dist/enhancers/memoization/memoization.js

@@ -0,0 +1,420 @@
+import { computed } from '@angular/core';
+import { isNodeAccessor } from '../../lib/utils.js';
+import { deepEqual } from '../../deep-equal.js';
+import { LRUCache } from '../../lru-cache.js';
+
+function isDevMode() {
+  if (typeof __DEV__ !== 'undefined') {
+    return __DEV__;
+  }
+  return false;
+}
+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();
+  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;
+}
+function setCleanupInterval(tree, 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);
+}
+function resetMemoizationCaches() {
+  memoizationCache.forEach((cache, tree) => {
+    cache.clear();
+    clearCleanupInterval(tree);
+  });
+  memoizationCache.clear();
+}
+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;
+  }
+  return false;
+}
+function generateCacheKey(fn, args) {
+  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;
+  }
+}
+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;
+  };
+}
+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
+  }
+};
+function selectorMemoization() {
+  return memoization(MEMOIZATION_PRESETS.selector);
+}
+function computedMemoization() {
+  return memoization(MEMOIZATION_PRESETS.computed);
+}
+function deepStateMemoization() {
+  return memoization(MEMOIZATION_PRESETS.deepState);
+}
+function highFrequencyMemoization() {
+  return memoization(MEMOIZATION_PRESETS.highFrequency);
+}
+Object.assign((config = {}) => memoization(config), {
+  selector: selectorMemoization,
+  computed: computedMemoization,
+  deep: deepStateMemoization,
+  fast: highFrequencyMemoization
+});
+function memoization(config = {}) {
+  const {
+    enabled = true,
+    maxCacheSize = 1000,
+    ttl,
+    equality = 'deep',
+    enableLRU = true
+  } = config;
+  const enhancer = 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.memoize = (fn, _cacheKey) => {
+        return computed(() => fn(originalTreeCall()));
+      };
+      memoTree.memoizedUpdate = updater => {
+        const currentState = originalTreeCall();
+        const result = updater(currentState);
+        applyUpdateResult(result);
+      };
+      memoTree.clearMemoCache = () => {};
+      memoTree.clearCache = 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);
+    };
+    const memoizeResultCache = createMemoCacheStore(MAX_CACHE_SIZE, true);
+    tree.memoize = (fn, cacheKey) => {
+      return computed(() => {
+        const currentState = originalTreeCall();
+        const key = cacheKey || generateCacheKey(fn, [currentState]);
+        const cached = memoizeResultCache.get(key);
+        if (cached && equalityFn(cached.deps, [currentState])) {
+          return cached.value;
+        }
+        if (isDevMode() && tree.__devHooks?.onRecompute) {
+          try {
+            tree.__devHooks.onRecompute(key, 1);
+          } catch {}
+        }
+        const result = fn(currentState);
+        memoizeResultCache.set(key, {
+          value: result,
+          deps: [currentState],
+          timestamp: Date.now(),
+          hitCount: 1
+        });
+        return result;
+      });
+    };
+    tree.clearMemoCache = key => {
+      if (key) {
+        cache.delete(key);
+      } else {
+        cache.clear();
+      }
+    };
+    tree.clearCache = tree.clearMemoCache;
+    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);
+      };
+    }
+    tree.clearCache = tree.clearMemoCache;
+    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;
+  };
+  return enhancer;
+}
+function highPerformanceMemoization() {
+  return memoization({
+    enabled: true,
+    maxCacheSize: 10000,
+    ttl: 300000,
+    equality: 'shallow',
+    enableLRU: true
+  });
+}
+function lightweightMemoization() {
+  return memoization({
+    enabled: true,
+    maxCacheSize: 100,
+    ttl: undefined,
+    equality: 'reference',
+    enableLRU: false
+  });
+}
+function shallowMemoization() {
+  return memoization({
+    enabled: true,
+    maxCacheSize: 1000,
+    ttl: 60000,
+    equality: 'shallow',
+    enableLRU: true
+  });
+}
+function clearAllCaches() {
+  resetMemoizationCaches();
+}
+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
+  };
+}
+
+export { MEMOIZATION_PRESETS, clearAllCaches, computedMemoization, deepStateMemoization, getGlobalCacheStats, highFrequencyMemoization, highPerformanceMemoization, lightweightMemoization, memoization, memoize, memoizeReference, memoizeShallow, selectorMemoization, shallowMemoization };

package/dist/enhancers/presets/lib/presets.js

@@ -0,0 +1,27 @@
+const TREE_PRESETS = {};
+function createPresetConfig(preset, overrides = {}) {
+  return {
+    ...overrides
+  };
+}
+function validatePreset(preset) {
+  return typeof preset === 'string';
+}
+function getAvailablePresets() {
+  return Object.keys(TREE_PRESETS);
+}
+function combinePresets(presets, overrides = {}) {
+  let combined = {};
+  for (const p of presets) {
+    combined = {
+      ...combined,
+      ...TREE_PRESETS[p]
+    };
+  }
+  return {
+    ...combined,
+    ...overrides
+  };
+}
+
+export { TREE_PRESETS, combinePresets, createPresetConfig, getAvailablePresets, validatePreset };

package/dist/enhancers/serialization/constants.js

@@ -0,0 +1,15 @@
+const TYPE_MARKERS = {
+  DATE: '§d',
+  REGEXP: '§r',
+  MAP: '§m',
+  SET: '§s',
+  UNDEFINED: '§u',
+  NAN: '§n',
+  INFINITY: '§i',
+  NEG_INFINITY: '§-i',
+  BIGINT: '§b',
+  SYMBOL: '§y',
+  CIRCULAR: '§c'
+};
+
+export { TYPE_MARKERS };