@signaltree/core 5.1.1 → 5.1.3

package/dist/enhancers/devtools/lib/devtools.js

@@ -0,0 +1,321 @@
+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 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 withDevTools(config = {}) {
+  const {
+    enabled = true,
+    treeName = 'ModularSignalTree',
+    enableBrowserDevTools = true,
+    enableLogging = true,
+    performanceThreshold = 16
+  } = config;
+  return tree => {
+    if (!enabled) {
+      const createNoopInterface = () => ({
+        activityTracker: {
+          trackMethodCall: () => undefined,
+          trackError: () => undefined,
+          getModuleActivity: () => undefined,
+          getAllModules: () => []
+        },
+        logger: {
+          logComposition: () => undefined,
+          logMethodExecution: () => undefined,
+          logStateChange: () => undefined,
+          logPerformanceWarning: () => undefined,
+          exportLogs: () => []
+        },
+        metrics: signal({
+          totalUpdates: 0,
+          moduleUpdates: {},
+          modulePerformance: {},
+          compositionChain: [],
+          signalGrowth: {},
+          memoryDelta: {},
+          moduleCacheStats: {}
+        }).asReadonly(),
+        trackComposition: () => undefined,
+        startModuleProfiling: () => '',
+        endModuleProfiling: () => undefined,
+        connectDevTools: () => undefined,
+        exportDebugSession: () => ({
+          metrics: {
+            totalUpdates: 0,
+            moduleUpdates: {},
+            modulePerformance: {},
+            compositionChain: [],
+            signalGrowth: {},
+            memoryDelta: {},
+            moduleCacheStats: {}
+          },
+          modules: [],
+          logs: [],
+          compositionHistory: []
+        })
+      });
+      return Object.assign(tree, {
+        __devTools: createNoopInterface()
+      });
+    }
+    const activityTracker = createActivityTracker();
+    const logger = enableLogging ? createCompositionLogger() : {
+      logComposition: () => undefined,
+      logMethodExecution: () => undefined,
+      logStateChange: () => undefined,
+      logPerformanceWarning: () => undefined,
+      exportLogs: () => []
+    };
+    const metrics = createModularMetrics();
+    const compositionHistory = [];
+    const activeProfiles = new Map();
+    let browserDevTools = null;
+    if (enableBrowserDevTools && typeof window !== 'undefined' && '__REDUX_DEVTOOLS_EXTENSION__' in window) {
+      const devToolsExt = window['__REDUX_DEVTOOLS_EXTENSION__'];
+      const connection = devToolsExt.connect({
+        name: treeName,
+        features: {
+          dispatch: true,
+          jump: true,
+          skip: true
+        }
+      });
+      browserDevTools = {
+        send: connection.send
+      };
+    }
+    const originalTreeCall = tree.bind(tree);
+    const enhancedTree = function (...args) {
+      if (args.length === 0) {
+        return originalTreeCall();
+      } else {
+        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]
+      })
+    };
+    return Object.assign(enhancedTree, {
+      __devTools: devToolsInterface
+    });
+  };
+}
+function enableDevTools(treeName = 'SignalTree') {
+  return withDevTools({
+    treeName,
+    enabled: true
+  });
+}
+function withFullDevTools(treeName = 'SignalTree') {
+  return withDevTools({
+    treeName,
+    enabled: true,
+    enableBrowserDevTools: true,
+    enableLogging: true,
+    performanceThreshold: 10
+  });
+}
+function withProductionDevTools() {
+  return withDevTools({
+    enabled: true,
+    enableBrowserDevTools: false,
+    enableLogging: false,
+    performanceThreshold: 50
+  });
+}
+
+export { enableDevTools, withDevTools, withFullDevTools, withProductionDevTools };

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

@@ -0,0 +1,93 @@
+import { EntitySignalImpl } 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' && 'all' in value;
+}
+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 = new EntitySignalImpl(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

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