@signaltree/core 4.0.16 → 4.1.1

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

@@ -0,0 +1,379 @@
+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();
+  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 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;
+  }
+  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 withSelectorMemoization() {
+  return withMemoization(MEMOIZATION_PRESETS.selector);
+}
+function withComputedMemoization() {
+  return withMemoization(MEMOIZATION_PRESETS.computed);
+}
+function withDeepStateMemoization() {
+  return withMemoization(MEMOIZATION_PRESETS.deepState);
+}
+function withHighFrequencyMemoization() {
+  return withMemoization(MEMOIZATION_PRESETS.highFrequency);
+}
+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;
+    }
+    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;
+  };
+}
+function withHighPerformanceMemoization() {
+  return withMemoization({
+    enabled: true,
+    maxCacheSize: 10000,
+    ttl: 300000,
+    equality: 'shallow',
+    enableLRU: true
+  });
+}
+function withLightweightMemoization() {
+  return withMemoization({
+    enabled: true,
+    maxCacheSize: 100,
+    ttl: undefined,
+    equality: 'reference',
+    enableLRU: false
+  });
+}
+function withShallowMemoization() {
+  return withMemoization({
+    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, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, memoize, memoizeReference, memoizeShallow, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withMemoization, withSelectorMemoization, withShallowMemoization };

package/dist/enhancers/middleware/lib/async-helpers.js

@@ -0,0 +1,77 @@
+import { signal } from '@angular/core';
+
+function createAsyncOperation(name, operation) {
+  return async tree => {
+    if (typeof tree.batchUpdate === 'function') {
+      const pendingPatch = {
+        [`${name}_PENDING`]: true
+      };
+      tree.batchUpdate(() => pendingPatch);
+    } else if ('$' in tree) {
+      try {
+        tree['$'][`${name}_PENDING`]?.set?.(true);
+      } catch (e) {
+      }
+    }
+    try {
+      const result = await operation();
+      if (typeof tree.batchUpdate === 'function') {
+        const resultPatch = {
+          [`${name}_RESULT`]: result,
+          [`${name}_PENDING`]: false
+        };
+        tree.batchUpdate(() => resultPatch);
+      } else if ('$' in tree) {
+        try {
+          tree['$'][`${name}_RESULT`]?.set?.(result);
+          tree['$'][`${name}_PENDING`]?.set?.(false);
+        } catch (e) {
+          void e;
+        }
+      }
+      return result;
+    } catch (error) {
+      if (typeof tree.batchUpdate === 'function') {
+        const errorPatch = {
+          [`${name}_ERROR`]: error,
+          [`${name}_PENDING`]: false
+        };
+        tree.batchUpdate(() => errorPatch);
+      } else if ('$' in tree) {
+        try {
+          tree['$'][`${name}_ERROR`]?.set?.(error);
+          tree['$'][`${name}_PENDING`]?.set?.(false);
+        } catch (e) {
+        }
+      }
+      throw error;
+    }
+  };
+}
+function trackAsync(operation) {
+  const pending = signal(false);
+  const error = signal(null);
+  const result = signal(null);
+  return {
+    pending: pending.asReadonly(),
+    error: error.asReadonly(),
+    result: result.asReadonly(),
+    execute: async () => {
+      pending.set(true);
+      error.set(null);
+      try {
+        const res = await operation();
+        result.set(res);
+        return res;
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        error.set(err);
+        throw err;
+      } finally {
+        pending.set(false);
+      }
+    }
+  };
+}
+
+export { createAsyncOperation, trackAsync };

package/dist/enhancers/middleware/lib/middleware.js

@@ -0,0 +1,136 @@
+const middlewareMap = new WeakMap();
+function withMiddleware(middlewares = []) {
+  return tree => {
+    middlewareMap.set(tree, [...middlewares]);
+    const originalTreeCall = tree.bind(tree);
+    const enhancedTree = function (...args) {
+      if (args.length === 0) {
+        return originalTreeCall();
+      } else {
+        const action = 'UPDATE';
+        const currentState = originalTreeCall();
+        const treeMiddlewares = middlewareMap.get(tree) || [];
+        let updateResult;
+        if (args.length === 1) {
+          const arg = args[0];
+          if (typeof arg === 'function') {
+            updateResult = arg(currentState);
+          } else {
+            updateResult = arg;
+          }
+        } else {
+          return;
+        }
+        for (const middleware of treeMiddlewares) {
+          if (middleware.before && !middleware.before(action, updateResult, currentState)) {
+            return;
+          }
+        }
+        const previousState = currentState;
+        if (args.length === 1) {
+          const arg = args[0];
+          if (typeof arg === 'function') {
+            originalTreeCall(arg);
+          } else {
+            originalTreeCall(arg);
+          }
+        }
+        const newState = originalTreeCall();
+        for (const middleware of treeMiddlewares) {
+          if (middleware.after) {
+            middleware.after(action, updateResult, previousState, newState);
+          }
+        }
+      }
+    };
+    Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
+    Object.assign(enhancedTree, tree);
+    if ('state' in tree) {
+      Object.defineProperty(enhancedTree, 'state', {
+        value: tree.state,
+        enumerable: false,
+        configurable: true
+      });
+    }
+    if ('$' in tree) {
+      Object.defineProperty(enhancedTree, '$', {
+        value: tree['$'],
+        enumerable: false,
+        configurable: true
+      });
+    }
+    enhancedTree.addTap = middleware => {
+      const treeMiddlewares = middlewareMap.get(tree) || [];
+      const existingIndex = treeMiddlewares.findIndex(m => m.id === middleware.id);
+      if (existingIndex >= 0) {
+        treeMiddlewares[existingIndex] = middleware;
+      } else {
+        treeMiddlewares.push(middleware);
+      }
+      middlewareMap.set(tree, treeMiddlewares);
+    };
+    enhancedTree.removeTap = id => {
+      const treeMiddlewares = middlewareMap.get(tree) || [];
+      const filtered = treeMiddlewares.filter(m => m.id !== id);
+      middlewareMap.set(tree, filtered);
+    };
+    const originalBatchUpdate = tree.batchUpdate;
+    if (originalBatchUpdate) {
+      enhancedTree.batchUpdate = updater => {
+        const action = 'BATCH_UPDATE';
+        const currentState = originalTreeCall();
+        const updateResult = updater(currentState);
+        const treeMiddlewares = middlewareMap.get(tree) || [];
+        for (const middleware of treeMiddlewares) {
+          if (middleware.before && !middleware.before(action, updateResult, currentState)) {
+            return;
+          }
+        }
+        const previousState = currentState;
+        originalBatchUpdate.call(tree, updater);
+        const newState = originalTreeCall();
+        for (const middleware of treeMiddlewares) {
+          if (middleware.after) {
+            middleware.after(action, updateResult, previousState, newState);
+          }
+        }
+      };
+    }
+    const originalDestroy = tree.destroy;
+    enhancedTree.destroy = () => {
+      middlewareMap.delete(tree);
+      if (originalDestroy) {
+        originalDestroy.call(tree);
+      }
+    };
+    return enhancedTree;
+  };
+}
+function createLoggingMiddleware(treeName) {
+  return {
+    id: 'logging',
+    before: (action, payload, state) => {
+      console.group(`🏪 ${treeName}: ${action}`);
+      console.log('Previous state:', state);
+      console.log('Payload:', typeof payload === 'function' ? 'Function' : payload);
+      return true;
+    },
+    after: (action, payload, state, newState) => {
+      console.log('New state:', newState);
+      console.groupEnd();
+    }
+  };
+}
+function createValidationMiddleware(validator) {
+  return {
+    id: 'validation',
+    after: (action, payload, state, newState) => {
+      const error = validator(newState);
+      if (error) {
+        console.error(`Validation failed after ${action}:`, error);
+      }
+    }
+  };
+}
+
+export { createLoggingMiddleware, createValidationMiddleware, withMiddleware };

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

@@ -0,0 +1,88 @@
+import { composeEnhancers } from '../../../lib/utils.js';
+import { withHighPerformanceBatching, withBatching } from '../../batching/lib/batching.js';
+import { withDevTools } from '../../devtools/lib/devtools.js';
+import { withHighPerformanceMemoization, withMemoization } from '../../memoization/lib/memoization.js';
+import { withMiddleware } from '../../middleware/lib/middleware.js';
+import { withTimeTravel } from '../../time-travel/lib/time-travel.js';
+
+const TREE_PRESETS = {
+  basic: {
+    batchUpdates: false,
+    useMemoization: false,
+    trackPerformance: false,
+    enableTimeTravel: false,
+    enableDevTools: false,
+    debugMode: false
+  },
+  performance: {
+    batchUpdates: true,
+    useMemoization: true,
+    trackPerformance: false,
+    enableTimeTravel: false,
+    enableDevTools: false,
+    debugMode: false,
+    useShallowComparison: true,
+    maxCacheSize: 200
+  },
+  development: {
+    batchUpdates: true,
+    useMemoization: true,
+    trackPerformance: true,
+    enableTimeTravel: true,
+    enableDevTools: true,
+    debugMode: true,
+    maxCacheSize: 100
+  },
+  production: {
+    batchUpdates: true,
+    useMemoization: true,
+    trackPerformance: false,
+    enableTimeTravel: false,
+    enableDevTools: false,
+    debugMode: false,
+    useShallowComparison: true,
+    maxCacheSize: 200
+  }
+};
+function createPresetConfig(preset, overrides = {}) {
+  const baseConfig = TREE_PRESETS[preset];
+  return {
+    ...baseConfig,
+    ...overrides
+  };
+}
+function validatePreset(preset) {
+  if (!TREE_PRESETS[preset]) {
+    throw new Error(`Invalid preset: ${preset}. Valid presets are: ${Object.keys(TREE_PRESETS).join(', ')}`);
+  }
+  return true;
+}
+function getAvailablePresets() {
+  return Object.keys(TREE_PRESETS);
+}
+function combinePresets(presets, overrides = {}) {
+  let combined = {};
+  for (const preset of presets) {
+    validatePreset(preset);
+    combined = {
+      ...combined,
+      ...TREE_PRESETS[preset]
+    };
+  }
+  return {
+    ...combined,
+    ...overrides
+  };
+}
+function createDevTree(overrides = {}) {
+  const config = createPresetConfig('development', overrides);
+  const composed = composeEnhancers(withBatching(), withHighPerformanceBatching(), withMemoization(), withHighPerformanceMemoization(), withMiddleware(), withTimeTravel(), withDevTools({
+    treeName: config.treeName ?? 'SignalTree Dev'
+  }));
+  return {
+    config,
+    enhancer: composed
+  };
+}
+
+export { TREE_PRESETS, combinePresets, createDevTree, 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 };