@signaltree/core 7.1.2 → 7.1.4

package/dist/enhancers/devtools/devtools.js

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

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

@@ -1,24 +0,0 @@
-function entities(config = {}) {
-  if (typeof ngDevMode === 'undefined' || ngDevMode) {
-    console.warn('SignalTree: entities() enhancer is deprecated in v7. ' + 'EntityMap markers are now automatically processed. ' + 'Remove .with(entities()) from your code. ' + 'This enhancer will be removed in v8.');
-  }
-  const {
-    enabled = true
-  } = config;
-  return 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

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