@signaltree/core 5.1.4 → 6.0.0

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

@@ -1,93 +0,0 @@
-import { createEntitySignal } from '../../../lib/entity-signal.js';
-import { getPathNotifier } from '../../../lib/path-notifier.js';
-import { isNodeAccessor } from '../../../lib/utils.js';
-
-function isEntityMapMarker(value) {
-  return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
-}
-function isEntitySignal(value) {
-  return !!value && typeof value === 'object' && typeof value['addOne'] === 'function' && typeof value['all'] !== 'undefined';
-}
-function materializeEntities(tree, notifier = getPathNotifier()) {
-  const registry = new Map();
-  const state = tree.state;
-  const visit = (parent, key, value, path) => {
-    const nextPath = [...path, key];
-    if (isEntityMapMarker(value)) {
-      const basePath = nextPath.join('.');
-      const config = value.__entityMapConfig ?? {};
-      const entitySignal = createEntitySignal(config, notifier, basePath);
-      if (parent) {
-        try {
-          parent[key] = entitySignal;
-        } catch {}
-      }
-      try {
-        tree[key] = entitySignal;
-      } catch {}
-      registry.set(basePath, entitySignal);
-      return;
-    }
-    if (isNodeAccessor(value)) {
-      const nodeAsAny = value;
-      for (const childKey of Object.keys(nodeAsAny)) {
-        visit(nodeAsAny, childKey, nodeAsAny[childKey], nextPath);
-      }
-      return;
-    }
-    if (value && typeof value === 'object') {
-      for (const childKey of Object.keys(value)) {
-        visit(value, childKey, value[childKey], nextPath);
-      }
-    }
-  };
-  for (const key of Object.keys(state)) {
-    visit(state, key, state[key], []);
-  }
-  return registry;
-}
-function resolveEntitySignal(tree, registry, path) {
-  const pathStr = String(path);
-  const existing = registry.get(pathStr);
-  if (existing) return existing;
-  const segments = pathStr.split('.');
-  let current = tree.state;
-  for (const segment of segments) {
-    if (!current) break;
-    current = current[segment];
-  }
-  if (isEntitySignal(current)) {
-    registry.set(pathStr, current);
-    return current;
-  }
-  throw new Error(`Entity path '${pathStr}' is not configured. Define it with entityMap() in your initial state.`);
-}
-function withEntities(config = {}) {
-  const {
-    enabled = true
-  } = config;
-  return function enhanceWithEntities(tree) {
-    if (!enabled) {
-      return tree;
-    }
-    const registry = materializeEntities(tree);
-    const enhancedTree = Object.assign(tree, {
-      entities(path) {
-        return resolveEntitySignal(tree, registry, path);
-      }
-    });
-    return enhancedTree;
-  };
-}
-function enableEntities() {
-  return withEntities({
-    enabled: true
-  });
-}
-function withHighPerformanceEntities() {
-  return withEntities({
-    enabled: true
-  });
-}
-
-export { enableEntities, withEntities, withHighPerformanceEntities };

package/dist/enhancers/index.js

@@ -1,72 +0,0 @@
-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

@@ -1,410 +0,0 @@
-import { computed } from '@angular/core';
-import { isNodeAccessor } from '../../../lib/utils.js';
-import { LRUCache } from '../../../lru-cache.js';
-import { deepEqual } from '../../../deep-equal.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 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);
-    };
-    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.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/presets/lib/presets.js

@@ -1,87 +0,0 @@
-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 { 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(), 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

@@ -1,15 +0,0 @@
-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 };