@signaltree/core 7.1.4 → 7.1.6

package/dist/constants.js

@@ -0,0 +1,6 @@
+const SHARED_DEFAULTS = Object.freeze({
+  PATH_CACHE_SIZE: 1000
+});
+const DEFAULT_PATH_CACHE_SIZE = SHARED_DEFAULTS.PATH_CACHE_SIZE;
+
+export { DEFAULT_PATH_CACHE_SIZE, SHARED_DEFAULTS };

package/dist/deep-equal.js

@@ -0,0 +1,41 @@
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  const typeA = typeof a;
+  const typeB = typeof b;
+  if (typeA !== typeB) return false;
+  if (typeA !== 'object') return false;
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [key, value] of a) {
+      if (!b.has(key) || !deepEqual(value, b.get(key))) return false;
+    }
+    return true;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const value of a) {
+      if (!b.has(value)) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  if (Array.isArray(b)) return false;
+  const objA = a;
+  const objB = b;
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  return keysA.every(key => key in objB && deepEqual(objA[key], objB[key]));
+}
+
+export { deepEqual };

package/dist/enhancers/batching/batching.js

@@ -0,0 +1,230 @@
+import { copyTreeProperties } from '../utils/copy-tree-properties.js';
+
+function batching(config = {}) {
+  const enabled = config.enabled ?? true;
+  const notificationDelayMs = config.notificationDelayMs ?? 0;
+  return tree => {
+    if (!enabled) {
+      const passthrough = {
+        batch: fn => fn(),
+        coalesce: fn => fn(),
+        hasPendingNotifications: () => false,
+        flushNotifications: () => {}
+      };
+      const enhanced = tree;
+      Object.assign(enhanced, passthrough);
+      enhanced.batchUpdate = updater => {
+        if (typeof tree.batchUpdate === 'function') {
+          tree.batchUpdate(updater);
+        } else {
+          updater(tree());
+        }
+      };
+      return enhanced;
+    }
+    let notificationPending = false;
+    let notificationTimeoutId;
+    let inBatch = false;
+    let inCoalesce = false;
+    const coalescedUpdates = new Map();
+    const scheduleNotification = () => {
+      if (notificationPending) return;
+      notificationPending = true;
+      if (notificationDelayMs > 0) {
+        notificationTimeoutId = setTimeout(flushNotificationsInternal, notificationDelayMs);
+      } else {
+        queueMicrotask(flushNotificationsInternal);
+      }
+    };
+    const flushNotificationsInternal = () => {
+      if (!notificationPending) return;
+      notificationPending = false;
+      if (notificationTimeoutId !== undefined) {
+        clearTimeout(notificationTimeoutId);
+        notificationTimeoutId = undefined;
+      }
+      if (tree.__notifyChangeDetection) {
+        tree.__notifyChangeDetection();
+      }
+    };
+    const flushCoalescedUpdates = () => {
+      const updates = Array.from(coalescedUpdates.values());
+      coalescedUpdates.clear();
+      updates.forEach(fn => {
+        try {
+          fn();
+        } catch (e) {
+          console.error('[SignalTree] Error in coalesced update:', e);
+        }
+      });
+    };
+    const wrapSignalSetters = (node, path = '') => {
+      if (!node || typeof node !== 'object') return;
+      if (typeof node.set === 'function' && !node.__batchingWrapped) {
+        const originalSet = node.set.bind(node);
+        node.set = value => {
+          if (inCoalesce) {
+            coalescedUpdates.set(path, () => originalSet(value));
+          } else {
+            originalSet(value);
+          }
+          if (!inBatch) {
+            scheduleNotification();
+          }
+        };
+        node.__batchingWrapped = true;
+      }
+      if (typeof node.update === 'function' && !node.__batchingUpdateWrapped) {
+        const originalUpdate = node.update.bind(node);
+        node.update = updater => {
+          if (inCoalesce) {
+            coalescedUpdates.set(`${path}:update:${Date.now()}`, () => originalUpdate(updater));
+          } else {
+            originalUpdate(updater);
+          }
+          if (!inBatch) {
+            scheduleNotification();
+          }
+        };
+        node.__batchingUpdateWrapped = true;
+      }
+      for (const key of Object.keys(node)) {
+        if (key.startsWith('_') || key === 'set' || key === 'update') continue;
+        const child = node[key];
+        if (child && typeof child === 'object') {
+          wrapSignalSetters(child, path ? `${path}.${key}` : key);
+        }
+      }
+    };
+    if (tree.$) {
+      wrapSignalSetters(tree.$);
+    }
+    const batchingMethods = {
+      batch(fn) {
+        const wasBatching = inBatch;
+        inBatch = true;
+        try {
+          fn();
+        } finally {
+          inBatch = wasBatching;
+          if (!inBatch) {
+            scheduleNotification();
+          }
+        }
+      },
+      coalesce(fn) {
+        const wasCoalescing = inCoalesce;
+        const wasBatching = inBatch;
+        inCoalesce = true;
+        inBatch = true;
+        try {
+          fn();
+        } finally {
+          inCoalesce = wasCoalescing;
+          inBatch = wasBatching;
+          if (!wasCoalescing) {
+            flushCoalescedUpdates();
+          }
+          if (!inBatch) {
+            scheduleNotification();
+          }
+        }
+      },
+      hasPendingNotifications() {
+        return notificationPending;
+      },
+      flushNotifications() {
+        flushNotificationsInternal();
+      }
+    };
+    const originalTreeCall = tree.bind(tree);
+    const enhancedTree = function (...args) {
+      if (args.length === 0) {
+        return originalTreeCall();
+      } else {
+        if (args.length === 1) {
+          const arg = args[0];
+          if (typeof arg === 'function') {
+            originalTreeCall(arg);
+          } else {
+            originalTreeCall(arg);
+          }
+        }
+        if (!inBatch) {
+          scheduleNotification();
+        }
+      }
+    };
+    Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
+    Object.assign(enhancedTree, tree);
+    try {
+      copyTreeProperties(tree, enhancedTree);
+    } catch {}
+    Object.defineProperty(enhancedTree, 'with', {
+      value: function (enhancer) {
+        if (typeof enhancer !== 'function') {
+          throw new Error('Enhancer must be a function');
+        }
+        return enhancer(enhancedTree);
+      },
+      writable: false,
+      enumerable: false,
+      configurable: true
+    });
+    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
+      });
+    }
+    Object.assign(enhancedTree, batchingMethods);
+    enhancedTree.batchUpdate = updater => {
+      enhancedTree.batch(() => {
+        const current = originalTreeCall();
+        const updates = updater(current);
+        Object.entries(updates).forEach(([key, value]) => {
+          const property = enhancedTree.state[key];
+          if (property && typeof property.set === 'function') {
+            property.set(value);
+          } else if (typeof property === 'function') {
+            property(value);
+          }
+        });
+      });
+    };
+    return enhancedTree;
+  };
+}
+function highPerformanceBatching() {
+  return batching({
+    enabled: true,
+    notificationDelayMs: 0
+  });
+}
+function batchingWithConfig(config = {}) {
+  return batching(config);
+}
+function flushBatchedUpdates() {
+  console.warn('[SignalTree] flushBatchedUpdates() is deprecated. Use tree.flushNotifications() instead.');
+}
+function hasPendingUpdates() {
+  console.warn('[SignalTree] hasPendingUpdates() is deprecated. Use tree.hasPendingNotifications() instead.');
+  return false;
+}
+function getBatchQueueSize() {
+  console.warn('[SignalTree] getBatchQueueSize() is deprecated. Signal writes are now synchronous.');
+  return 0;
+}
+Object.assign((config = {}) => batching(config), {
+  highPerformance: highPerformanceBatching
+});
+
+export { batching, batchingWithConfig, flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, highPerformanceBatching };

package/dist/enhancers/devtools/devtools.js

@@ -0,0 +1,318 @@
+import { signal } from '@angular/core';
+import { copyTreeProperties } from '../utils/copy-tree-properties.js';
+
+function createActivityTracker() {
+  const modules = new Map();
+  return {
+    trackMethodCall: (module, method, duration) => {
+      const existing = modules.get(module);
+      if (existing) {
+        existing.lastActivity = new Date();
+        existing.operationCount++;
+        existing.averageExecutionTime = (existing.averageExecutionTime * (existing.operationCount - 1) + duration) / existing.operationCount;
+      } else {
+        modules.set(module, {
+          name: module,
+          methods: [method],
+          addedAt: new Date(),
+          lastActivity: new Date(),
+          operationCount: 1,
+          averageExecutionTime: duration,
+          errorCount: 0
+        });
+      }
+    },
+    trackError: (module, error, context) => {
+      const existing = modules.get(module);
+      if (existing) {
+        existing.errorCount++;
+      }
+      console.error(`❌ [${module}] Error${context ? ` in ${context}` : ''}:`, error);
+    },
+    getModuleActivity: module => modules.get(module),
+    getAllModules: () => Array.from(modules.values())
+  };
+}
+function createCompositionLogger() {
+  const logs = [];
+  const addLog = (module, type, data) => {
+    logs.push({
+      timestamp: new Date(),
+      module,
+      type,
+      data
+    });
+    if (logs.length > 1000) {
+      logs.splice(0, logs.length - 1000);
+    }
+  };
+  return {
+    logComposition: (modules, action) => {
+      addLog('core', 'composition', {
+        modules,
+        action
+      });
+      console.log(`🔗 Composition ${action}:`, modules.join(' → '));
+    },
+    logMethodExecution: (module, method, args, result) => {
+      addLog(module, 'method', {
+        method,
+        args,
+        result
+      });
+      console.debug(`🔧 [${module}] ${method}`, {
+        args,
+        result
+      });
+    },
+    logStateChange: (module, path, oldValue, newValue) => {
+      addLog(module, 'state', {
+        path,
+        oldValue,
+        newValue
+      });
+      console.debug(`📝 [${module}] State change at ${path}:`, {
+        from: oldValue,
+        to: newValue
+      });
+    },
+    logPerformanceWarning: (module, operation, duration, threshold) => {
+      addLog(module, 'performance', {
+        operation,
+        duration,
+        threshold
+      });
+      console.warn(`⚠️ [${module}] Slow ${operation}: ${duration.toFixed(2)}ms (threshold: ${threshold}ms)`);
+    },
+    exportLogs: () => [...logs]
+  };
+}
+function createNoopLogger() {
+  return {
+    logComposition: () => {},
+    logMethodExecution: () => {},
+    logStateChange: () => {},
+    logPerformanceWarning: () => {},
+    exportLogs: () => []
+  };
+}
+function createModularMetrics() {
+  const metricsSignal = signal({
+    totalUpdates: 0,
+    moduleUpdates: {},
+    modulePerformance: {},
+    compositionChain: [],
+    signalGrowth: {},
+    memoryDelta: {},
+    moduleCacheStats: {}
+  });
+  return {
+    signal: metricsSignal.asReadonly(),
+    updateMetrics: updates => {
+      metricsSignal.update(current => ({
+        ...current,
+        ...updates
+      }));
+    },
+    trackModuleUpdate: (module, duration) => {
+      metricsSignal.update(current => ({
+        ...current,
+        totalUpdates: current.totalUpdates + 1,
+        moduleUpdates: {
+          ...current.moduleUpdates,
+          [module]: (current.moduleUpdates[module] || 0) + 1
+        },
+        modulePerformance: {
+          ...current.modulePerformance,
+          [module]: duration
+        }
+      }));
+    }
+  };
+}
+function devTools(config = {}) {
+  const {
+    enabled = true,
+    treeName = 'SignalTree',
+    name,
+    enableBrowserDevTools = true,
+    enableLogging = true,
+    performanceThreshold = 16
+  } = config;
+  const displayName = name ?? treeName;
+  return tree => {
+    if (!enabled) {
+      const noopMethods = {
+        connectDevTools() {},
+        disconnectDevTools() {}
+      };
+      return Object.assign(tree, noopMethods);
+    }
+    const activityTracker = createActivityTracker();
+    const logger = enableLogging ? createCompositionLogger() : createNoopLogger();
+    const metrics = createModularMetrics();
+    const compositionHistory = [];
+    const activeProfiles = new Map();
+    let browserDevTools = null;
+    const initBrowserDevTools = () => {
+      if (!enableBrowserDevTools || typeof window === 'undefined' || !('__REDUX_DEVTOOLS_EXTENSION__' in window)) {
+        return;
+      }
+      try {
+        const devToolsExt = window['__REDUX_DEVTOOLS_EXTENSION__'];
+        const connection = devToolsExt.connect({
+          name: displayName,
+          features: {
+            dispatch: true,
+            jump: true,
+            skip: true
+          }
+        });
+        browserDevTools = {
+          send: connection.send
+        };
+        browserDevTools.send('@@INIT', tree());
+        console.log(`🔗 Connected to Redux DevTools as "${displayName}"`);
+      } catch (e) {
+        console.warn('[SignalTree] Failed to connect to Redux DevTools:', e);
+      }
+    };
+    const originalTreeCall = tree.bind(tree);
+    const enhancedTree = function (...args) {
+      if (args.length === 0) {
+        return originalTreeCall();
+      }
+      const startTime = performance.now();
+      let result;
+      if (args.length === 1) {
+        const arg = args[0];
+        if (typeof arg === 'function') {
+          result = originalTreeCall(arg);
+        } else {
+          result = originalTreeCall(arg);
+        }
+      }
+      const duration = performance.now() - startTime;
+      const newState = originalTreeCall();
+      metrics.trackModuleUpdate('core', duration);
+      if (duration > performanceThreshold) {
+        logger.logPerformanceWarning('core', 'update', duration, performanceThreshold);
+      }
+      if (browserDevTools) {
+        browserDevTools.send('UPDATE', newState);
+      }
+      return result;
+    };
+    Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
+    copyTreeProperties(tree, enhancedTree);
+    Object.defineProperty(enhancedTree, 'with', {
+      value: function (enhancer) {
+        if (typeof enhancer !== 'function') {
+          throw new Error('Enhancer must be a function');
+        }
+        return enhancer(enhancedTree);
+      },
+      writable: false,
+      enumerable: false,
+      configurable: true
+    });
+    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
+      });
+    }
+    const devToolsInterface = {
+      activityTracker,
+      logger,
+      metrics: metrics.signal,
+      trackComposition: modules => {
+        compositionHistory.push({
+          timestamp: new Date(),
+          chain: [...modules]
+        });
+        metrics.updateMetrics({
+          compositionChain: modules
+        });
+        logger.logComposition(modules, 'with');
+      },
+      startModuleProfiling: module => {
+        const profileId = `${module}_${Date.now()}`;
+        activeProfiles.set(profileId, {
+          module,
+          operation: 'profile',
+          startTime: performance.now()
+        });
+        return profileId;
+      },
+      endModuleProfiling: profileId => {
+        const profile = activeProfiles.get(profileId);
+        if (profile) {
+          const duration = performance.now() - profile.startTime;
+          activityTracker.trackMethodCall(profile.module, profile.operation, duration);
+          activeProfiles.delete(profileId);
+        }
+      },
+      connectDevTools: name => {
+        if (browserDevTools) {
+          browserDevTools.send('@@INIT', originalTreeCall());
+          console.log(`🔗 Connected to Redux DevTools as "${name}"`);
+        }
+      },
+      exportDebugSession: () => ({
+        metrics: metrics.signal(),
+        modules: activityTracker.getAllModules(),
+        logs: logger.exportLogs(),
+        compositionHistory: [...compositionHistory]
+      })
+    };
+    const methods = {
+      connectDevTools() {
+        initBrowserDevTools();
+      },
+      disconnectDevTools() {
+        browserDevTools = null;
+      }
+    };
+    enhancedTree['__devTools'] = devToolsInterface;
+    return Object.assign(enhancedTree, methods);
+  };
+}
+function enableDevTools(treeName = 'SignalTree') {
+  return devTools({
+    treeName,
+    enabled: true
+  });
+}
+function fullDevTools(treeName = 'SignalTree') {
+  return devTools({
+    treeName,
+    enabled: true,
+    enableBrowserDevTools: true,
+    enableLogging: true,
+    performanceThreshold: 10
+  });
+}
+function productionDevTools() {
+  return devTools({
+    enabled: true,
+    enableBrowserDevTools: false,
+    enableLogging: false,
+    performanceThreshold: 50
+  });
+}
+Object.assign(devTools, {
+  production: productionDevTools,
+  full: fullDevTools,
+  enable: enableDevTools
+});
+
+export { devTools, enableDevTools, fullDevTools, productionDevTools };

package/dist/enhancers/effects/effects.js

@@ -0,0 +1,66 @@
+import { effect, untracked } from '@angular/core';
+
+function effects(config = {}) {
+  const {
+    enabled = true
+  } = config;
+  return tree => {
+    const cleanupFns = [];
+    const methods = {
+      effect(effectFn) {
+        if (!enabled) {
+          return () => {};
+        }
+        let innerCleanup;
+        const effectRef = effect(() => {
+          const state = tree();
+          if (innerCleanup) {
+            untracked(() => innerCleanup());
+          }
+          innerCleanup = untracked(() => effectFn(state));
+        });
+        const cleanup = () => {
+          if (innerCleanup) {
+            innerCleanup();
+          }
+          effectRef.destroy();
+        };
+        cleanupFns.push(cleanup);
+        return cleanup;
+      },
+      subscribe(fn) {
+        if (!enabled) {
+          return () => {};
+        }
+        const effectRef = effect(() => {
+          const state = tree();
+          untracked(() => fn(state));
+        });
+        const cleanup = () => {
+          effectRef.destroy();
+        };
+        cleanupFns.push(cleanup);
+        return cleanup;
+      }
+    };
+    const originalDestroy = tree.destroy?.bind(tree);
+    tree.destroy = () => {
+      cleanupFns.forEach(fn => fn());
+      cleanupFns.length = 0;
+      if (originalDestroy) {
+        originalDestroy();
+      }
+    };
+    return Object.assign(tree, methods);
+  };
+}
+function enableEffects() {
+  return effects({
+    enabled: true
+  });
+}
+Object.assign((config = {}) => effects(config), {
+  enable: enableEffects
+});
+
+export { effects, enableEffects };

package/dist/enhancers/entities/entities.js

@@ -0,0 +1,7 @@
+function entities(config = {}) {
+  throw new Error('entities() has been removed. Remove `.with(entities())` from your code; v7+ auto-processes EntityMap markers.');
+}
+const enableEntities = entities;
+const highPerformanceEntities = entities;
+
+export { enableEntities, entities, highPerformanceEntities };