@signaltree/core 4.2.0 → 5.0.0

package/README.md

@@ -446,7 +446,7 @@ const activeUsers = computed(() => tree.$.users().filter((user) => user.active))
 
 ### 4) Manual async state management
 
-Core provides basic state updates. For advanced async helpers, use the built-in middleware functions (`createAsyncOperation`, `trackAsync`):
+Core provides basic state updates. For advanced async helpers, use the built-in async helpers (`createAsyncOperation`, `trackAsync`):
 
 ```typescript
 const tree = signalTree({
@@ -519,12 +519,6 @@ All enhancers are exported directly from `@signaltree/core`:
 - `withDevTools()` - Redux DevTools integration
 - `withTimeTravel()` - Undo/redo functionality
 
-**Integration:**
-
-- `withMiddleware()` - State interceptors and logging
-- `createLoggingMiddleware()` - Built-in logging middleware
-- `createValidationMiddleware()` - Built-in validation middleware
-
 **Presets:**
 
 - `createDevTree()` - Pre-configured development setup
@@ -585,7 +579,7 @@ const tree = signalTree({
   user: null as User | null,
   preferences: { theme: 'light' },
 }).with(
-  // withAsync removed — API integration patterns are now covered by middleware helpers
+  // withAsync removed — API integration patterns are now covered by async helpers
   withSerialization({
     // Auto-save to localStorage
     autoSave: true,
@@ -594,7 +588,7 @@ const tree = signalTree({
   withTimeTravel() // Undo/redo support
 );
 
-// For async operations, use manual async or middleware helpers
+// For async operations, use manual async or async helpers
 async function fetchUser(id: string) {
   tree.$.loading.set(true);
   try {
@@ -895,7 +889,7 @@ appProducts.selectTotal(); // Count signal
 adminLogs.selectAll(); // All items signal
 adminReports.selectIds(); // ID array signal
 
-// For async operations, use manual async or middleware helpers
+// For async operations, use manual async or async helpers
 async function fetchUsers() {
   tree.$.ui.loading.set(true);
   try {
@@ -924,7 +918,7 @@ const tree = signalTree({
 }).with(
   withBatching(), // Performance
   withEntities(), // Data management
-  // withAsync removed — use middleware helpers for API integration
+  // withAsync removed — use async helpers for API integration
   withSerialization({
     // State persistence
     autoSave: true,
@@ -959,7 +953,7 @@ import { signalTree, withBatching, withEntities, withSerialization } from '@sign
 const tree = signalTree(initialState).with(
   withBatching(), // Performance optimization
   withEntities(), // Data management
-  // withAsync removed — use middleware helpers for API integration
+  // withAsync removed — use async helpers for API integration
   withSerialization({
     // User preferences
     autoSave: true,
@@ -1029,7 +1023,7 @@ const tree2 = tree.with(withBatching());
 const tree3 = tree2.with(withEntities());
 
 // Phase 4: Add async for API integration
-// withAsync removed — no explicit async enhancer; use middleware helpers instead
+// withAsync removed — no explicit async enhancer; use async helpers instead
 
 // Each phase is fully functional and production-ready
 ```
@@ -1316,7 +1310,7 @@ tree.destroy(); // Cleanup resources
 
 // Extended features (built into @signaltree/core)
 tree.entities<T>(key); // Entity helpers (use withEntities enhancer)
-// For async operations, use manual async or middleware helpers like createAsyncOperation or trackAsync
+// For async operations, use manual async or async helpers like createAsyncOperation or trackAsync
 ```
 
 ## Extending with enhancers
@@ -1336,7 +1330,6 @@ All enhancers are included in `@signaltree/core`:
 
 - **withBatching()** - Batch multiple updates for better performance
 - **withMemoization()** - Intelligent caching & performance optimization
-- **withMiddleware()** - Middleware system & state interceptors
 - **withEntities()** - Advanced entity management & CRUD operations
 - **withDevTools()** - Redux DevTools integration for debugging
 - **withTimeTravel()** - Undo/redo functionality & state history
@@ -1358,8 +1351,7 @@ Consider enhancers when you need:
 
 - ⚡ Performance optimization (withBatching, withMemoization)
 - 🐛 Advanced debugging (withDevTools, withTimeTravel)
-- � Entity management (withEntities)
-- 🔌 Middleware patterns (withMiddleware)
+- 📦 Entity management (withEntities)
 
 Consider separate packages when you need:
 
@@ -1494,7 +1486,6 @@ All enhancers are now consolidated in the core package. The following features a
 
 ### Advanced Features
 
-- **withMiddleware()** (+1.89KB gzipped) - Middleware system & state interceptors
 - **withEntities()** (+0.97KB gzipped) - Enhanced CRUD operations & entity management
 
 ### Development Tools

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

@@ -1,114 +1,66 @@
-import { computed } from '@angular/core';
-import { isAnySignal, isNodeAccessor } from '../../../lib/utils.js';
+import { EntitySignalImpl } from '../../../lib/entity-signal.js';
+import { getPathNotifier } from '../../../lib/path-notifier.js';
+import { isNodeAccessor } from '../../../lib/utils.js';
 
-function resolveNestedSignal(tree, path) {
-  const pathStr = String(path);
-  if (!pathStr.includes('.')) {
-    const signal = tree.state[pathStr];
-    if (!signal) {
-      throw new Error(`Entity key '${pathStr}' does not exist in the state. Available top-level keys: ${Object.keys(tree.state).join(', ')}`);
+function isEntityMapMarker(value) {
+  return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
+}
+function isEntitySignal(value) {
+  return !!value && typeof value === 'object' && typeof value['addOne'] === 'function' && typeof value['all'] === 'function';
+}
+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;
     }
-    return signal;
+    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 (let i = 0; i < segments.length; i++) {
-    const segment = segments[i];
-    if (isAnySignal(current)) {
-      current = current();
-    }
+  for (const segment of segments) {
+    if (!current) break;
     current = current[segment];
-    if (current === undefined) {
-      const attemptedPath = segments.slice(0, i + 1).join('.');
-      throw new Error(`Entity path '${pathStr}' is invalid: '${attemptedPath}' does not exist in the state`);
-    }
   }
-  if (isAnySignal(current)) {
+  if (isEntitySignal(current)) {
+    registry.set(pathStr, current);
     return current;
   }
-  throw new Error(`Entity path '${pathStr}' does not resolve to a signal. Ensure all parent levels in the path are valid nested objects.`);
-}
-function createEntityHelpers(tree, entityKey) {
-  const getEntitySignal = () => {
-    const signal = resolveNestedSignal(tree, entityKey);
-    if (!isAnySignal(signal)) {
-      throw new Error(`Entity key '${String(entityKey)}' is not a signal. This should not happen with SignalTree.`);
-    }
-    const castSignal = signal;
-    const value = castSignal();
-    if (!Array.isArray(value)) {
-      throw new Error(`Entity key '${String(entityKey)}' does not contain an array. Current type: ${typeof value}`);
-    }
-    return castSignal;
-  };
-  const setSignalValue = (signal, value) => {
-    if (isNodeAccessor(signal)) {
-      signal(value);
-    } else {
-      signal.set(value);
-    }
-  };
-  return {
-    add: entity => {
-      const entitySignal = getEntitySignal();
-      const currentEntities = entitySignal();
-      if (currentEntities.some(e => e.id === entity.id)) {
-        throw new Error(`Entity with id '${entity.id}' already exists`);
-      }
-      setSignalValue(entitySignal, [...currentEntities, entity]);
-    },
-    update: (id, updates) => {
-      const entitySignal = getEntitySignal();
-      const currentEntities = entitySignal();
-      const updatedEntities = currentEntities.map(entity => entity.id === id ? {
-        ...entity,
-        ...updates
-      } : entity);
-      setSignalValue(entitySignal, updatedEntities);
-    },
-    remove: id => {
-      const entitySignal = getEntitySignal();
-      const currentEntities = entitySignal();
-      const filteredEntities = currentEntities.filter(entity => entity.id !== id);
-      setSignalValue(entitySignal, filteredEntities);
-    },
-    upsert: entity => {
-      const entitySignal = getEntitySignal();
-      const currentEntities = entitySignal();
-      const index = currentEntities.findIndex(e => e.id === entity.id);
-      if (index >= 0) {
-        const updatedEntities = [...currentEntities];
-        updatedEntities[index] = entity;
-        setSignalValue(entitySignal, updatedEntities);
-      } else {
-        setSignalValue(entitySignal, [...currentEntities, entity]);
-      }
-    },
-    selectById: id => {
-      const entitySignal = getEntitySignal();
-      return computed(() => entitySignal().find(entity => entity.id === id));
-    },
-    selectBy: predicate => {
-      const entitySignal = getEntitySignal();
-      return computed(() => entitySignal().filter(predicate));
-    },
-    selectIds: () => {
-      const entitySignal = getEntitySignal();
-      return computed(() => entitySignal().map(entity => entity.id));
-    },
-    selectAll: () => {
-      const entitySignal = getEntitySignal();
-      return entitySignal;
-    },
-    selectTotal: () => {
-      const entitySignal = getEntitySignal();
-      return computed(() => entitySignal().length);
-    },
-    clear: () => {
-      const entitySignal = getEntitySignal();
-      setSignalValue(entitySignal, []);
-    }
-  };
+  throw new Error(`Entity path '${pathStr}' is not configured. Define it with entityMap() in your initial state.`);
 }
 function withEntities(config = {}) {
   const {
@@ -118,9 +70,10 @@ function withEntities(config = {}) {
     if (!enabled) {
       return tree;
     }
+    const registry = materializeEntities(tree);
     const enhancedTree = Object.assign(tree, {
-      entities(entityKey) {
-        return createEntityHelpers(tree, entityKey);
+      entities(path) {
+        return resolveEntitySignal(tree, registry, path);
       }
     });
     return enhancedTree;
@@ -133,7 +86,8 @@ function enableEntities() {
 }
 function withHighPerformanceEntities() {
   return withEntities({
-    enabled: true});
+    enabled: true
+  });
 }
 
 export { enableEntities, withEntities, withHighPerformanceEntities };

package/dist/enhancers/memoization/lib/memoization.js

@@ -1,3 +1,4 @@
+import { computed } from '@angular/core';
 import { isNodeAccessor } from '../../../lib/utils.js';
 import { LRUCache } from '../../../lru-cache.js';
 import { deepEqual } from '../../../deep-equal.js';
@@ -281,6 +282,25 @@ function withMemoization(config = {}) {
       });
       applyUpdateResult(result);
     };
+    const memoizeResultCache = createMemoCacheStore(MAX_CACHE_SIZE, true);
+    tree.memoize = (fn, cacheKey) => {
+      return computed(() => {
+        const currentState = originalTreeCall();
+        const key = cacheKey || generateCacheKey(fn, [currentState]);
+        const cached = memoizeResultCache.get(key);
+        if (cached && equalityFn(cached.deps, [currentState])) {
+          return cached.value;
+        }
+        const result = fn(currentState);
+        memoizeResultCache.set(key, {
+          value: result,
+          deps: [currentState],
+          timestamp: Date.now(),
+          hitCount: 1
+        });
+        return result;
+      });
+    };
     tree.clearMemoCache = key => {
       if (key) {
         cache.delete(key);

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

@@ -2,7 +2,6 @@ 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 { withMiddleware } from '../../middleware/lib/middleware.js';
 import { withTimeTravel } from '../../time-travel/lib/time-travel.js';
 
 const TREE_PRESETS = {
@@ -76,7 +75,7 @@ function combinePresets(presets, overrides = {}) {
 }
 function createDevTree(overrides = {}) {
   const config = createPresetConfig('development', overrides);
-  const composed = composeEnhancers(withBatching(), withHighPerformanceBatching(), withMemoization(), withHighPerformanceMemoization(), withMiddleware(), withTimeTravel(), withDevTools({
+  const composed = composeEnhancers(withBatching(), withHighPerformanceBatching(), withMemoization(), withHighPerformanceMemoization(), withTimeTravel(), withDevTools({
     treeName: config.treeName ?? 'SignalTree Dev'
   }));
   return {

package/dist/enhancers/serialization/lib/serialization.js

@@ -544,6 +544,8 @@ function withPersistence(config) {
     }
     if (autoSave) {
       let saveTimeout;
+      let previousState = JSON.stringify(tree());
+      let pollingActive = true;
       const triggerAutoSave = () => {
         if (saveTimeout) {
           clearTimeout(saveTimeout);
@@ -554,28 +556,30 @@ function withPersistence(config) {
           });
         }, debounceMs);
       };
-      const watchSignals = (obj, path = '') => {
-        if (!obj || typeof obj !== 'object') return;
-        for (const [key, value] of Object.entries(obj)) {
-          if (isSignal(value)) {
-            const signal = value;
-            let previousValue = signal();
-            const checkForChanges = () => {
-              const currentValue = signal();
-              if (currentValue !== previousValue) {
-                previousValue = currentValue;
-                triggerAutoSave();
-              }
-              setTimeout(checkForChanges, 50);
-            };
-            setTimeout(checkForChanges, 0);
-          } else if (value && typeof value === 'object') {
-            watchSignals(value, path ? `${path}.${key}` : key);
+      let usingReactiveSubscription = false;
+      try {
+        tree.subscribe(() => {
+          const currentState = JSON.stringify(tree());
+          if (currentState !== previousState) {
+            previousState = currentState;
+            triggerAutoSave();
           }
-        }
-      };
-      watchSignals(tree.state);
+        });
+        usingReactiveSubscription = true;
+      } catch {
+        const checkForChanges = () => {
+          if (!pollingActive) return;
+          const currentState = JSON.stringify(tree());
+          if (currentState !== previousState) {
+            previousState = currentState;
+            triggerAutoSave();
+          }
+          setTimeout(checkForChanges, 100);
+        };
+        setTimeout(checkForChanges, 0);
+      }
       enhanced.__flushAutoSave = () => {
+        pollingActive = false;
         if (saveTimeout) {
           clearTimeout(saveTimeout);
           saveTimeout = undefined;

package/dist/index.js

@@ -1,16 +1,15 @@
 export { signalTree } from './lib/signal-tree.js';
+export { ENHANCER_META, entityMap } from './lib/types.js';
 export { composeEnhancers, createLazySignalTree, isAnySignal, isNodeAccessor, toWritableSignal } from './lib/utils.js';
 export { SecurityPresets, SecurityValidator } from './lib/security/security-validator.js';
 export { createEnhancer, resolveEnhancerOrder } from './enhancers/index.js';
-export { ENHANCER_META } from './lib/types.js';
 export { flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, withBatching, withHighPerformanceBatching } from './enhancers/batching/lib/batching.js';
 export { cleanupMemoizationCache, clearAllCaches, getGlobalCacheStats, memoize, memoizeReference, memoizeShallow, withComputedMemoization, withDeepStateMemoization, withHighFrequencyMemoization, withHighPerformanceMemoization, withLightweightMemoization, withMemoization, withSelectorMemoization, withShallowMemoization } from './enhancers/memoization/lib/memoization.js';
 export { enableTimeTravel, getTimeTravel, withTimeTravel } from './enhancers/time-travel/lib/time-travel.js';
 export { enableEntities, withEntities, withHighPerformanceEntities } from './enhancers/entities/lib/entities.js';
 export { applyPersistence, applySerialization, createIndexedDBAdapter, createStorageAdapter, enableSerialization, withPersistence, withSerialization } from './enhancers/serialization/lib/serialization.js';
 export { enableDevTools, withDevTools, withFullDevTools, withProductionDevTools } from './enhancers/devtools/lib/devtools.js';
-export { createLoggingMiddleware, createValidationMiddleware, withMiddleware } from './enhancers/middleware/lib/middleware.js';
-export { createAsyncOperation, trackAsync } from './enhancers/middleware/lib/async-helpers.js';
+export { createAsyncOperation, trackAsync } from './lib/async-helpers.js';
 export { TREE_PRESETS, combinePresets, createDevTree, createPresetConfig, getAvailablePresets, validatePreset } from './enhancers/presets/lib/presets.js';
 export { computedEnhancer, createComputed } from './enhancers/computed/lib/computed.js';
 export { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './lib/constants.js';