@signaltree/core 6.0.0 → 6.0.1

package/dist/enhancers/devtools/devtools.js

@@ -0,0 +1,306 @@
+import { signal } from '@angular/core';
+
+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));
+    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
+      });
+    }
+    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,51 @@
+import { createEntitySignal } from '../../lib/entity-signal.js';
+import { getPathNotifier } from '../../lib/path-notifier.js';
+
+function isEntityMapMarker(value) {
+  return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
+}
+function entities(config = {}) {
+  const {
+    enabled = true
+  } = config;
+  return tree => {
+    if (!enabled) {
+      tree.__entitiesEnabled = true;
+      return tree;
+    }
+    const notifier = getPathNotifier();
+    function materialize(node, path = []) {
+      if (!node || typeof node !== 'object') return;
+      for (const [k, v] of Object.entries(node)) {
+        if (isEntityMapMarker(v)) {
+          const cfg = v.__entityMapConfig ?? {};
+          const sig = createEntitySignal(cfg, notifier, path.concat(k).join('.'));
+          try {
+            node[k] = sig;
+          } catch {}
+          try {
+            tree[k] = sig;
+          } catch {}
+        } else if (typeof v === 'object' && v !== null && !Array.isArray(v)) {
+          materialize(v, path.concat(k));
+        }
+      }
+    }
+    materialize(tree.state);
+    materialize(tree.$);
+    tree.__entitiesEnabled = true;
+    return tree;
+  };
+}
+function enableEntities() {
+  return entities();
+}
+function highPerformanceEntities() {
+  return entities();
+}
+Object.assign(entities, {
+  highPerformance: highPerformanceEntities,
+  enable: enableEntities
+});
+
+export { enableEntities, entities, highPerformanceEntities };

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