@signaltree/core 5.1.6 → 6.0.1

package/dist/enhancers/devtools/{lib/devtools.js → devtools.js}

@@ -86,6 +86,15 @@ function createCompositionLogger() {
     exportLogs: () => [...logs]
   };
 }
+function createNoopLogger() {
+  return {
+    logComposition: () => {},
+    logMethodExecution: () => {},
+    logStateChange: () => {},
+    logPerformanceWarning: () => {},
+    exportLogs: () => []
+  };
+}
 function createModularMetrics() {
   const metricsSignal = signal({
     totalUpdates: 0,
@@ -120,114 +129,78 @@ function createModularMetrics() {
     }
   };
 }
-function withDevTools(config = {}) {
+function devTools(config = {}) {
   const {
     enabled = true,
-    treeName = 'ModularSignalTree',
+    treeName = 'SignalTree',
+    name,
     enableBrowserDevTools = true,
     enableLogging = true,
     performanceThreshold = 16
   } = config;
+  const displayName = name ?? treeName;
   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 noopMethods = {
+        connectDevTools() {},
+        disconnectDevTools() {}
+      };
+      return Object.assign(tree, noopMethods);
     }
     const activityTracker = createActivityTracker();
-    const logger = enableLogging ? createCompositionLogger() : {
-      logComposition: () => undefined,
-      logMethodExecution: () => undefined,
-      logStateChange: () => undefined,
-      logPerformanceWarning: () => undefined,
-      exportLogs: () => []
-    };
+    const logger = enableLogging ? createCompositionLogger() : createNoopLogger();
     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 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();
-      } 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);
+      }
+      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);
         }
-        return result;
       }
+      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);
@@ -240,7 +213,7 @@ function withDevTools(config = {}) {
     }
     if ('$' in tree) {
       Object.defineProperty(enhancedTree, '$', {
-        value: tree['$'],
+        value: tree.$,
         enumerable: false,
         configurable: true
       });
@@ -289,19 +262,26 @@ function withDevTools(config = {}) {
         compositionHistory: [...compositionHistory]
       })
     };
-    return Object.assign(enhancedTree, {
-      __devTools: devToolsInterface
-    });
+    const methods = {
+      connectDevTools() {
+        initBrowserDevTools();
+      },
+      disconnectDevTools() {
+        browserDevTools = null;
+      }
+    };
+    enhancedTree['__devTools'] = devToolsInterface;
+    return Object.assign(enhancedTree, methods);
   };
 }
 function enableDevTools(treeName = 'SignalTree') {
-  return withDevTools({
+  return devTools({
     treeName,
     enabled: true
   });
 }
-function withFullDevTools(treeName = 'SignalTree') {
-  return withDevTools({
+function fullDevTools(treeName = 'SignalTree') {
+  return devTools({
     treeName,
     enabled: true,
     enableBrowserDevTools: true,
@@ -309,13 +289,18 @@ function withFullDevTools(treeName = 'SignalTree') {
     performanceThreshold: 10
   });
 }
-function withProductionDevTools() {
-  return withDevTools({
+function productionDevTools() {
+  return devTools({
     enabled: true,
     enableBrowserDevTools: false,
     enableLogging: false,
     performanceThreshold: 50
   });
 }
+Object.assign(devTools, {
+  production: productionDevTools,
+  full: fullDevTools,
+  enable: enableDevTools
+});
 
-export { enableDevTools, withDevTools, withFullDevTools, withProductionDevTools };
+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/memoization/{lib/memoization.js → memoization.js}

@@ -1,7 +1,7 @@
 import { computed } from '@angular/core';
-import { isNodeAccessor } from '../../../lib/utils.js';
-import { LRUCache } from '../../../lru-cache.js';
-import { deepEqual } from '../../../deep-equal.js';
+import { isNodeAccessor } from '../../lib/utils.js';
+import { deepEqual } from '../../deep-equal.js';
+import { LRUCache } from '../../lru-cache.js';
 
 function isDevMode() {
   if (typeof __DEV__ !== 'undefined') {
@@ -97,9 +97,6 @@ function resetMemoizationCaches() {
   });
   memoizationCache.clear();
 }
-function cleanupMemoizationCache() {
-  resetMemoizationCaches();
-}
 function shallowEqual(a, b) {
   if (a === b) return true;
   if (a == null || b == null) return false;
@@ -218,19 +215,25 @@ const MEMOIZATION_PRESETS = {
     ttl: undefined
   }
 };
-function withSelectorMemoization() {
-  return withMemoization(MEMOIZATION_PRESETS.selector);
+function selectorMemoization() {
+  return memoization(MEMOIZATION_PRESETS.selector);
 }
-function withComputedMemoization() {
-  return withMemoization(MEMOIZATION_PRESETS.computed);
+function computedMemoization() {
+  return memoization(MEMOIZATION_PRESETS.computed);
 }
-function withDeepStateMemoization() {
-  return withMemoization(MEMOIZATION_PRESETS.deepState);
+function deepStateMemoization() {
+  return memoization(MEMOIZATION_PRESETS.deepState);
 }
-function withHighFrequencyMemoization() {
-  return withMemoization(MEMOIZATION_PRESETS.highFrequency);
+function highFrequencyMemoization() {
+  return memoization(MEMOIZATION_PRESETS.highFrequency);
 }
-function withMemoization(config = {}) {
+Object.assign((config = {}) => memoization(config), {
+  selector: selectorMemoization,
+  computed: computedMemoization,
+  deep: deepStateMemoization,
+  fast: highFrequencyMemoization
+});
+function memoization(config = {}) {
   const {
     enabled = true,
     maxCacheSize = 1000,
@@ -238,7 +241,7 @@ function withMemoization(config = {}) {
     equality = 'deep',
     enableLRU = true
   } = config;
-  return tree => {
+  const enhancer = tree => {
     const originalTreeCall = tree.bind(tree);
     const applyUpdateResult = result => {
       Object.entries(result).forEach(([propKey, value]) => {
@@ -252,12 +255,16 @@ function withMemoization(config = {}) {
     };
     if (!enabled) {
       const memoTree = tree;
+      memoTree.memoize = (fn, _cacheKey) => {
+        return computed(() => fn(originalTreeCall()));
+      };
       memoTree.memoizedUpdate = updater => {
         const currentState = originalTreeCall();
         const result = updater(currentState);
         applyUpdateResult(result);
       };
       memoTree.clearMemoCache = () => {};
+      memoTree.clearCache = memoTree.clearMemoCache;
       memoTree.getCacheStats = () => ({
         size: 0,
         hitRate: 0,
@@ -319,6 +326,7 @@ function withMemoization(config = {}) {
         cache.clear();
       }
     };
+    tree.clearCache = tree.clearMemoCache;
     tree.getCacheStats = () => {
       let totalHits = 0;
       let totalMisses = 0;
@@ -343,6 +351,7 @@ function withMemoization(config = {}) {
         clearCleanupInterval(tree);
       };
     }
+    tree.clearCache = tree.clearMemoCache;
     if (ttl) {
       const cleanup = () => {
         const now = Date.now();
@@ -357,9 +366,10 @@ function withMemoization(config = {}) {
     }
     return tree;
   };
+  return enhancer;
 }
-function withHighPerformanceMemoization() {
-  return withMemoization({
+function highPerformanceMemoization() {
+  return memoization({
     enabled: true,
     maxCacheSize: 10000,
     ttl: 300000,
@@ -367,8 +377,8 @@ function withHighPerformanceMemoization() {
     enableLRU: true
   });
 }
-function withLightweightMemoization() {
-  return withMemoization({
+function lightweightMemoization() {
+  return memoization({
     enabled: true,
     maxCacheSize: 100,
     ttl: undefined,
@@ -376,8 +386,8 @@ function withLightweightMemoization() {
     enableLRU: false
   });
 }
-function withShallowMemoization() {
-  return withMemoization({
+function shallowMemoization() {
+  return memoization({
     enabled: true,
     maxCacheSize: 1000,
     ttl: 60000,
@@ -407,4 +417,4 @@ function getGlobalCacheStats() {
   };
 }
 
-export { MEMOIZATION_PRESETS, cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, memoize, memoizeReference, memoizeShallow, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withMemoization, withSelectorMemoization, withShallowMemoization };
+export { MEMOIZATION_PRESETS, clearAllCaches, computedMemoization, deepStateMemoization, getGlobalCacheStats, highFrequencyMemoization, highPerformanceMemoization, lightweightMemoization, memoization, memoize, memoizeReference, memoizeShallow, selectorMemoization, shallowMemoization };

package/dist/enhancers/presets/lib/presets.js

@@ -1,71 +1,21 @@
-import { composeEnhancers } from '../../../lib/utils.js';
-import { withHighPerformanceBatching, withBatching } from '../../batching/lib/batching.js';
-import { withDevTools } from '../../devtools/lib/devtools.js';
-import { withHighPerformanceMemoization, withMemoization } from '../../memoization/lib/memoization.js';
-import { withTimeTravel } from '../../time-travel/lib/time-travel.js';
-
-const TREE_PRESETS = {
-  basic: {
-    batchUpdates: false,
-    useMemoization: false,
-    trackPerformance: false,
-    enableTimeTravel: false,
-    enableDevTools: false,
-    debugMode: false
-  },
-  performance: {
-    batchUpdates: true,
-    useMemoization: true,
-    trackPerformance: false,
-    enableTimeTravel: false,
-    enableDevTools: false,
-    debugMode: false,
-    useShallowComparison: true,
-    maxCacheSize: 200
-  },
-  development: {
-    batchUpdates: true,
-    useMemoization: true,
-    trackPerformance: true,
-    enableTimeTravel: true,
-    enableDevTools: true,
-    debugMode: true,
-    maxCacheSize: 100
-  },
-  production: {
-    batchUpdates: true,
-    useMemoization: true,
-    trackPerformance: false,
-    enableTimeTravel: false,
-    enableDevTools: false,
-    debugMode: false,
-    useShallowComparison: true,
-    maxCacheSize: 200
-  }
-};
+const TREE_PRESETS = {};
 function createPresetConfig(preset, overrides = {}) {
-  const baseConfig = TREE_PRESETS[preset];
   return {
-    ...baseConfig,
     ...overrides
   };
 }
 function validatePreset(preset) {
-  if (!TREE_PRESETS[preset]) {
-    throw new Error(`Invalid preset: ${preset}. Valid presets are: ${Object.keys(TREE_PRESETS).join(', ')}`);
-  }
-  return true;
+  return typeof preset === 'string';
 }
 function getAvailablePresets() {
   return Object.keys(TREE_PRESETS);
 }
 function combinePresets(presets, overrides = {}) {
   let combined = {};
-  for (const preset of presets) {
-    validatePreset(preset);
+  for (const p of presets) {
     combined = {
       ...combined,
-      ...TREE_PRESETS[preset]
+      ...TREE_PRESETS[p]
     };
   }
   return {
@@ -73,15 +23,5 @@ function combinePresets(presets, overrides = {}) {
     ...overrides
   };
 }
-function createDevTree(overrides = {}) {
-  const config = createPresetConfig('development', overrides);
-  const composed = composeEnhancers(withBatching(), withHighPerformanceBatching(), withMemoization(), withHighPerformanceMemoization(), withTimeTravel(), withDevTools({
-    treeName: config.treeName ?? 'SignalTree Dev'
-  }));
-  return {
-    config,
-    enhancer: composed
-  };
-}
 
-export { TREE_PRESETS, combinePresets, createDevTree, createPresetConfig, getAvailablePresets, validatePreset };
+export { TREE_PRESETS, combinePresets, createPresetConfig, getAvailablePresets, validatePreset };

package/dist/enhancers/serialization/{lib/serialization.js → serialization.js}

@@ -1,5 +1,5 @@
 import { isSignal } from '@angular/core';
-import { TYPE_MARKERS } from '../constants.js';
+import { TYPE_MARKERS } from './constants.js';
 
 const DEFAULT_CONFIG = {
   includeMetadata: true,
@@ -180,8 +180,8 @@ function resolveCircularReferences(obj, circularPaths) {
     }
   }
 }
-function withSerialization(defaultConfig = {}) {
-  const enhancer = tree => {
+function serialization(defaultConfig = {}) {
+  return tree => {
     const enhanced = tree;
     enhanced.toJSON = () => {
       return tree();
@@ -455,19 +455,16 @@ function withSerialization(defaultConfig = {}) {
     };
     return enhanced;
   };
-  enhancer.metadata = {
-    name: 'serialization'
-  };
-  return enhancer;
 }
+Object.assign((defaultConfig = {}) => serialization(defaultConfig), {});
 function enableSerialization() {
-  return withSerialization({
+  return serialization({
     includeMetadata: true,
     preserveTypes: true,
     handleCircular: true
   });
 }
-function withPersistence(config) {
+function persistence(config) {
   const {
     key,
     storage = typeof window !== 'undefined' ? window.localStorage : undefined,
@@ -480,8 +477,8 @@ function withPersistence(config) {
     throw new Error('No storage adapter available. Provide a storage adapter in the config.');
   }
   const storageAdapter = storage;
-  function enhancer(tree) {
-    const serializable = withSerialization(serializationConfig)(tree);
+  return tree => {
+    const serializable = serialization(serializationConfig)(tree);
     const enhanced = serializable;
     let lastCacheKey = null;
     enhanced.save = async () => {
@@ -587,12 +584,9 @@ function withPersistence(config) {
       };
     }
     return enhanced;
-  }
-  enhancer.metadata = {
-    name: 'persistence'
   };
-  return enhancer;
 }
+Object.assign(cfg => persistence(cfg), {});
 function createStorageAdapter(getItem, setItem, removeItem) {
   return {
     getItem,
@@ -653,10 +647,10 @@ function createIndexedDBAdapter(dbName = 'SignalTreeDB', storeName = 'states') {
   };
 }
 function applySerialization(tree) {
-  return withSerialization()(tree);
+  return serialization()(tree);
 }
 function applyPersistence(tree, cfg) {
-  return withPersistence(cfg)(tree);
+  return persistence(cfg)(tree);
 }
 
-export { applyPersistence, applySerialization, createIndexedDBAdapter, createStorageAdapter, enableSerialization, withPersistence, withSerialization };
+export { applyPersistence, applySerialization, createIndexedDBAdapter, createStorageAdapter, enableSerialization, persistence, serialization };