@signaltree/core 4.0.16 → 4.1.0

package/dist/enhancers/entities/lib/entities.js

@@ -0,0 +1,115 @@
+import { computed } from '@angular/core';
+import { isAnySignal, isNodeAccessor } from '../../../lib/utils.js';
+
+function createEntityHelpers(tree, entityKey) {
+  const getEntitySignal = () => {
+    const stateProperty = tree.state[entityKey];
+    if (!stateProperty) {
+      throw new Error(`Entity key '${String(entityKey)}' does not exist in the state`);
+    }
+    if (!isAnySignal(stateProperty)) {
+      throw new Error(`Entity key '${String(entityKey)}' is not a signal. This should not happen with SignalTree.`);
+    }
+    const signal = stateProperty;
+    const value = signal();
+    if (!Array.isArray(value)) {
+      throw new Error(`Entity key '${String(entityKey)}' does not contain an array. Current type: ${typeof value}`);
+    }
+    return signal;
+  };
+  const setSignalValue = (signal, value) => {
+    if (isNodeAccessor(signal)) {
+      signal(value);
+    } else {
+      signal.set(value);
+    }
+  };
+  return {
+    add: entity => {
+      const entitySignal = getEntitySignal();
+      const currentEntities = entitySignal();
+      if (currentEntities.some(e => e.id === entity.id)) {
+        throw new Error(`Entity with id '${entity.id}' already exists`);
+      }
+      setSignalValue(entitySignal, [...currentEntities, entity]);
+    },
+    update: (id, updates) => {
+      const entitySignal = getEntitySignal();
+      const currentEntities = entitySignal();
+      const updatedEntities = currentEntities.map(entity => entity.id === id ? {
+        ...entity,
+        ...updates
+      } : entity);
+      setSignalValue(entitySignal, updatedEntities);
+    },
+    remove: id => {
+      const entitySignal = getEntitySignal();
+      const currentEntities = entitySignal();
+      const filteredEntities = currentEntities.filter(entity => entity.id !== id);
+      setSignalValue(entitySignal, filteredEntities);
+    },
+    upsert: entity => {
+      const entitySignal = getEntitySignal();
+      const currentEntities = entitySignal();
+      const index = currentEntities.findIndex(e => e.id === entity.id);
+      if (index >= 0) {
+        const updatedEntities = [...currentEntities];
+        updatedEntities[index] = entity;
+        setSignalValue(entitySignal, updatedEntities);
+      } else {
+        setSignalValue(entitySignal, [...currentEntities, entity]);
+      }
+    },
+    selectById: id => {
+      const entitySignal = getEntitySignal();
+      return computed(() => entitySignal().find(entity => entity.id === id));
+    },
+    selectBy: predicate => {
+      const entitySignal = getEntitySignal();
+      return computed(() => entitySignal().filter(predicate));
+    },
+    selectIds: () => {
+      const entitySignal = getEntitySignal();
+      return computed(() => entitySignal().map(entity => entity.id));
+    },
+    selectAll: () => {
+      const entitySignal = getEntitySignal();
+      return entitySignal;
+    },
+    selectTotal: () => {
+      const entitySignal = getEntitySignal();
+      return computed(() => entitySignal().length);
+    },
+    clear: () => {
+      const entitySignal = getEntitySignal();
+      setSignalValue(entitySignal, []);
+    }
+  };
+}
+function withEntities(config = {}) {
+  const {
+    enabled = true
+  } = config;
+  return function enhanceWithEntities(tree) {
+    if (!enabled) {
+      return tree;
+    }
+    const enhancedTree = Object.assign(tree, {
+      entities(entityKey) {
+        return createEntityHelpers(tree, entityKey);
+      }
+    });
+    return enhancedTree;
+  };
+}
+function enableEntities() {
+  return withEntities({
+    enabled: true
+  });
+}
+function withHighPerformanceEntities() {
+  return withEntities({
+    enabled: true});
+}
+
+export { enableEntities, withEntities, withHighPerformanceEntities };

package/dist/enhancers/index.js

@@ -0,0 +1,72 @@
+import { SIGNAL_TREE_MESSAGES } from '../lib/constants.js';
+import { ENHANCER_META } from '../lib/types.js';
+
+function createEnhancer(meta, enhancerFn) {
+  const fn = enhancerFn;
+  try {
+    fn.metadata = meta;
+    try {
+      fn[ENHANCER_META] = meta;
+    } catch {}
+  } catch {}
+  return fn;
+}
+function resolveEnhancerOrder(enhancers, availableCapabilities = new Set(), debugMode = false) {
+  const nodes = enhancers.map((e, idx) => ({
+    fn: e,
+    name: e.metadata && e.metadata.name ? String(e.metadata.name) : `enhancer#${idx}`,
+    requires: new Set(e.metadata?.requires ?? []),
+    provides: new Set(e.metadata?.provides ?? [])
+  }));
+  const adj = new Map();
+  const nameToNode = new Map();
+  for (const n of nodes) {
+    nameToNode.set(n.name, n);
+    adj.set(n.name, new Set());
+  }
+  for (const a of nodes) {
+    for (const b of nodes) {
+      if (a === b) continue;
+      for (const req of b.requires) {
+        if (availableCapabilities.has(req)) continue;
+        if (a.provides.has(req)) {
+          const set = adj.get(a.name);
+          if (set) set.add(b.name);
+        }
+      }
+    }
+  }
+  const inDegree = new Map();
+  for (const entry of adj.keys()) inDegree.set(entry, 0);
+  for (const [, outs] of adj) {
+    for (const to of outs) inDegree.set(to, (inDegree.get(to) || 0) + 1);
+  }
+  const queue = [];
+  for (const [name, deg] of inDegree.entries()) {
+    if (deg === 0) queue.push(name);
+  }
+  const ordered = [];
+  while (queue.length > 0) {
+    const n = queue.shift();
+    if (!n) break;
+    ordered.push(n);
+    const outs = adj.get(n);
+    if (!outs) continue;
+    for (const m of outs) {
+      inDegree.set(m, (inDegree.get(m) || 0) - 1);
+      if (inDegree.get(m) === 0) queue.push(m);
+    }
+  }
+  if (ordered.length !== nodes.length) {
+    if (debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_CYCLE_DETECTED);
+    }
+    return enhancers;
+  }
+  return ordered.map(name => {
+    const n = nameToNode.get(name);
+    return n ? n.fn : enhancers[0];
+  });
+}
+
+export { createEnhancer, resolveEnhancerOrder };

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 };