@signaltree/core 4.2.1 → 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,111 +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;
+    }
+    if (isNodeAccessor(value)) {
+      const nodeAsAny = value;
+      for (const childKey of Object.keys(nodeAsAny)) {
+        visit(nodeAsAny, childKey, nodeAsAny[childKey], nextPath);
+      }
+      return;
     }
-    return signal;
+    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];
+  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 {
@@ -115,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;
@@ -130,7 +86,8 @@ function enableEntities() {
 }
 function withHighPerformanceEntities() {
   return withEntities({
-    enabled: true});
+    enabled: true
+  });
 }
 
 export { enableEntities, withEntities, withHighPerformanceEntities };

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';

package/dist/lib/entity-signal.js

@@ -0,0 +1,280 @@
+import { signal, computed } from '@angular/core';
+
+class EntitySignalImpl {
+  pathNotifier;
+  basePath;
+  storage = new Map();
+  allSignal;
+  countSignal;
+  idsSignal;
+  mapSignal;
+  nodeCache = new Map();
+  selectId;
+  tapHandlers = [];
+  interceptHandlers = [];
+  constructor(config, pathNotifier, basePath) {
+    this.pathNotifier = pathNotifier;
+    this.basePath = basePath;
+    this.selectId = config.selectId ?? (entity => entity['id']);
+    this.allSignal = signal([]);
+    this.countSignal = signal(0);
+    this.idsSignal = signal([]);
+    this.mapSignal = signal(new Map());
+    return new Proxy(this, {
+      get: (target, prop) => {
+        if (typeof prop === 'string' && !isNaN(Number(prop))) {
+          return target.byId(Number(prop));
+        }
+        return target[prop];
+      }
+    });
+  }
+  byId(id) {
+    const entity = this.storage.get(id);
+    if (!entity) return undefined;
+    return this.getOrCreateNode(id, entity);
+  }
+  byIdOrFail(id) {
+    const node = this.byId(id);
+    if (!node) {
+      throw new Error(`Entity with id ${String(id)} not found`);
+    }
+    return node;
+  }
+  all() {
+    return this.allSignal;
+  }
+  count() {
+    return this.countSignal;
+  }
+  ids() {
+    return this.idsSignal;
+  }
+  map() {
+    return this.mapSignal;
+  }
+  has(id) {
+    return computed(() => this.storage.has(id));
+  }
+  isEmpty() {
+    return computed(() => this.storage.size === 0);
+  }
+  where(predicate) {
+    return computed(() => {
+      const result = [];
+      for (const entity of this.storage.values()) {
+        if (predicate(entity)) {
+          result.push(entity);
+        }
+      }
+      return result;
+    });
+  }
+  find(predicate) {
+    return computed(() => {
+      for (const entity of this.storage.values()) {
+        if (predicate(entity)) {
+          return entity;
+        }
+      }
+      return undefined;
+    });
+  }
+  addOne(entity, opts) {
+    const id = opts?.selectId?.(entity) ?? this.selectId(entity);
+    if (this.storage.has(id)) {
+      throw new Error(`Entity with id ${String(id)} already exists`);
+    }
+    let transformedEntity = entity;
+    for (const handler of this.interceptHandlers) {
+      const ctx = {
+        block: reason => {
+          throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
+        },
+        transform: value => {
+          transformedEntity = value;
+        },
+        blocked: false,
+        blockReason: undefined
+      };
+      handler.onAdd?.(entity, ctx);
+    }
+    this.storage.set(id, transformedEntity);
+    this.nodeCache.delete(id);
+    this.updateSignals();
+    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, transformedEntity, undefined);
+    for (const handler of this.tapHandlers) {
+      handler.onAdd?.(transformedEntity, id);
+    }
+    return id;
+  }
+  addMany(entities, opts) {
+    const ids = [];
+    for (const entity of entities) {
+      ids.push(this.addOne(entity, opts));
+    }
+    return ids;
+  }
+  updateOne(id, changes) {
+    const entity = this.storage.get(id);
+    if (!entity) {
+      throw new Error(`Entity with id ${String(id)} not found`);
+    }
+    const prev = entity;
+    let transformedChanges = changes;
+    for (const handler of this.interceptHandlers) {
+      const ctx = {
+        block: reason => {
+          throw new Error(`Cannot update entity: ${reason || 'blocked by interceptor'}`);
+        },
+        transform: value => {
+          transformedChanges = value;
+        },
+        blocked: false,
+        blockReason: undefined
+      };
+      handler.onUpdate?.(id, changes, ctx);
+    }
+    const finalUpdated = {
+      ...entity,
+      ...transformedChanges
+    };
+    this.storage.set(id, finalUpdated);
+    this.nodeCache.delete(id);
+    this.updateSignals();
+    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, finalUpdated, prev);
+    for (const handler of this.tapHandlers) {
+      handler.onUpdate?.(id, transformedChanges, finalUpdated);
+    }
+  }
+  updateMany(ids, changes) {
+    for (const id of ids) {
+      this.updateOne(id, changes);
+    }
+  }
+  updateWhere(predicate, changes) {
+    let count = 0;
+    for (const [id, entity] of this.storage) {
+      if (predicate(entity)) {
+        this.updateOne(id, changes);
+        count++;
+      }
+    }
+    return count;
+  }
+  removeOne(id) {
+    const entity = this.storage.get(id);
+    if (!entity) {
+      throw new Error(`Entity with id ${String(id)} not found`);
+    }
+    for (const handler of this.interceptHandlers) {
+      const ctx = {
+        block: reason => {
+          throw new Error(`Cannot remove entity: ${reason || 'blocked by interceptor'}`);
+        },
+        transform: () => {},
+        blocked: false,
+        blockReason: undefined
+      };
+      handler.onRemove?.(id, entity, ctx);
+    }
+    this.storage.delete(id);
+    this.nodeCache.delete(id);
+    this.updateSignals();
+    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, undefined, entity);
+    for (const handler of this.tapHandlers) {
+      handler.onRemove?.(id, entity);
+    }
+  }
+  removeMany(ids) {
+    for (const id of ids) {
+      this.removeOne(id);
+    }
+  }
+  removeWhere(predicate) {
+    const idsToRemove = [];
+    for (const [id, entity] of this.storage) {
+      if (predicate(entity)) {
+        idsToRemove.push(id);
+      }
+    }
+    let count = 0;
+    for (const id of idsToRemove) {
+      this.removeOne(id);
+      count++;
+    }
+    return count;
+  }
+  upsertOne(entity, opts) {
+    const id = opts?.selectId?.(entity) ?? this.selectId(entity);
+    if (this.storage.has(id)) {
+      this.updateOne(id, entity);
+    } else {
+      this.addOne(entity, opts);
+    }
+    return id;
+  }
+  upsertMany(entities, opts) {
+    return entities.map(e => this.upsertOne(e, opts));
+  }
+  clear() {
+    this.storage.clear();
+    this.nodeCache.clear();
+    this.updateSignals();
+  }
+  removeAll() {
+    this.clear();
+  }
+  setAll(entities, opts) {
+    this.clear();
+    this.addMany(entities, opts);
+  }
+  tap(handlers) {
+    this.tapHandlers.push(handlers);
+    return () => {
+      const idx = this.tapHandlers.indexOf(handlers);
+      if (idx > -1) this.tapHandlers.splice(idx, 1);
+    };
+  }
+  intercept(handlers) {
+    this.interceptHandlers.push(handlers);
+    return () => {
+      const idx = this.interceptHandlers.indexOf(handlers);
+      if (idx > -1) this.interceptHandlers.splice(idx, 1);
+    };
+  }
+  updateSignals() {
+    const entities = Array.from(this.storage.values());
+    const ids = Array.from(this.storage.keys());
+    const map = new Map(this.storage);
+    this.allSignal.set(entities);
+    this.countSignal.set(entities.length);
+    this.idsSignal.set(ids);
+    this.mapSignal.set(map);
+  }
+  getOrCreateNode(id, entity) {
+    let node = this.nodeCache.get(id);
+    if (!node) {
+      node = this.createEntityNode(id, entity);
+      this.nodeCache.set(id, node);
+    }
+    return node;
+  }
+  createEntityNode(id, entity) {
+    const node = () => this.storage.get(id);
+    for (const key of Object.keys(entity)) {
+      Object.defineProperty(node, key, {
+        get: () => {
+          const current = this.storage.get(id);
+          const value = current?.[key];
+          return () => value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return node;
+  }
+}
+
+export { EntitySignalImpl };