@signaltree/core 4.0.15 → 4.1.0

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

@@ -1,278 +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()),
-    };
+  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],
-    };
+  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 }));
+  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: () => []
         },
-        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,
-                },
-            }));
+        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: () => []
     };
-}
-export 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 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
         }
-        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 };
+      });
+      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 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,
-            });
+        const duration = performance.now() - startTime;
+        const newState = originalTreeCall();
+        metrics.trackModuleUpdate('core', duration);
+        if (duration > performanceThreshold) {
+          logger.logPerformanceWarning('core', 'update', duration, performanceThreshold);
         }
-        if ('$' in tree) {
-            Object.defineProperty(enhancedTree, '$', {
-                value: tree['$'],
-                enumerable: false,
-                configurable: true,
-            });
+        if (browserDevTools) {
+          browserDevTools.send('UPDATE', newState);
         }
-        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 });
+        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
+    });
+  };
 }
-export function enableDevTools(treeName = 'SignalTree') {
-    return withDevTools({ treeName, enabled: true });
+function enableDevTools(treeName = 'SignalTree') {
+  return withDevTools({
+    treeName,
+    enabled: true
+  });
 }
-export function withFullDevTools(treeName = 'SignalTree') {
-    return withDevTools({
-        treeName,
-        enabled: true,
-        enableBrowserDevTools: true,
-        enableLogging: true,
-        performanceThreshold: 10,
-    });
+function withFullDevTools(treeName = 'SignalTree') {
+  return withDevTools({
+    treeName,
+    enabled: true,
+    enableBrowserDevTools: true,
+    enableLogging: true,
+    performanceThreshold: 10
+  });
 }
-export function withProductionDevTools() {
-    return withDevTools({
-        enabled: true,
-        enableBrowserDevTools: false,
-        enableLogging: false,
-        performanceThreshold: 50,
-    });
+function withProductionDevTools() {
+  return withDevTools({
+    enabled: true,
+    enableBrowserDevTools: false,
+    enableLogging: false,
+    performanceThreshold: 50
+  });
 }
+
+export { enableDevTools, withDevTools, withFullDevTools, withProductionDevTools };