@signaltree/core 6.0.14 → 6.2.0

package/dist/enhancers/batching/batching.js

@@ -1,126 +1,165 @@
-import { applyState, isNodeAccessor } from '../../lib/utils.js';
+import { copyTreeProperties } from '../utils/copy-tree-properties.js';
 
-let updateQueue = [];
-let isUpdating = false;
-let flushTimeoutId;
-let currentBatchingConfig = {};
-function addToQueue(update, config = currentBatchingConfig) {
-  const maxSize = config.maxBatchSize ?? 100;
-  if (update.path) {
-    updateQueue = updateQueue.filter(existing => existing.path !== update.path);
-  }
-  updateQueue.push(update);
-  if (updateQueue.length > maxSize) {
-    flushUpdates();
-    return true;
-  }
-  scheduleFlush(config);
-  return false;
-}
-function scheduleFlush(config) {
-  if (flushTimeoutId !== undefined) {
-    clearTimeout(flushTimeoutId);
-  }
-  const delay = config.autoFlushDelay ?? config.debounceMs ?? 16;
-  flushTimeoutId = setTimeout(() => {
-    flushUpdates();
-  }, delay);
-}
-function flushUpdates() {
-  if (isUpdating) return;
-  let queue;
-  do {
-    if (updateQueue.length === 0) return;
-    isUpdating = true;
-    queue = updateQueue;
-    updateQueue = [];
-    if (flushTimeoutId !== undefined) {
-      clearTimeout(flushTimeoutId);
-      flushTimeoutId = undefined;
-    }
-    queue.sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
-    try {
-      queue.forEach(({
-        fn
-      }) => fn());
-    } finally {
-      isUpdating = false;
-    }
-  } while (updateQueue.length > 0);
-}
-function batchUpdates(fn, path) {
-  const startTime = performance.now();
-  const depth = 0;
-  const update = {
-    fn,
-    startTime,
-    depth,
-    path
-  };
-  const wasFlushed = addToQueue(update, currentBatchingConfig);
-  if (!wasFlushed) {
-    const isTimedOut = currentBatchingConfig.batchTimeoutMs && updateQueue.length > 0 && startTime - updateQueue[0].startTime >= currentBatchingConfig.batchTimeoutMs;
-    if (isTimedOut) {
-      flushUpdates();
-    } else if (!isUpdating && updateQueue.length > 0) {
-      queueMicrotask(() => {
-        flushUpdates();
-      });
-    }
-  }
-}
-function batchingWithConfig(config = {}) {
+function batching(config = {}) {
   const enabled = config.enabled ?? true;
-  if (enabled) {
-    currentBatchingConfig = {
-      ...currentBatchingConfig,
-      ...config
-    };
-  }
-  const enhancer = tree => {
+  const notificationDelayMs = config.notificationDelayMs ?? 0;
+  return tree => {
     if (!enabled) {
+      const passthrough = {
+        batch: fn => fn(),
+        coalesce: fn => fn(),
+        hasPendingNotifications: () => false,
+        flushNotifications: () => {}
+      };
       const enhanced = tree;
-      enhanced.batch = updater => {
-        try {
+      Object.assign(enhanced, passthrough);
+      enhanced.batchUpdate = updater => {
+        if (typeof tree.batchUpdate === 'function') {
           tree.batchUpdate(updater);
-        } catch {
-          try {
-            updater(enhanced.state);
-          } catch {}
+        } else {
+          updater(tree());
         }
       };
-      enhanced.batchUpdate = updater => {
+      return enhanced;
+    }
+    let notificationPending = false;
+    let notificationTimeoutId;
+    let inBatch = false;
+    let inCoalesce = false;
+    const coalescedUpdates = new Map();
+    const scheduleNotification = () => {
+      if (notificationPending) return;
+      notificationPending = true;
+      if (notificationDelayMs > 0) {
+        notificationTimeoutId = setTimeout(flushNotificationsInternal, notificationDelayMs);
+      } else {
+        queueMicrotask(flushNotificationsInternal);
+      }
+    };
+    const flushNotificationsInternal = () => {
+      if (!notificationPending) return;
+      notificationPending = false;
+      if (notificationTimeoutId !== undefined) {
+        clearTimeout(notificationTimeoutId);
+        notificationTimeoutId = undefined;
+      }
+      if (tree.__notifyChangeDetection) {
+        tree.__notifyChangeDetection();
+      }
+    };
+    const flushCoalescedUpdates = () => {
+      const updates = Array.from(coalescedUpdates.values());
+      coalescedUpdates.clear();
+      updates.forEach(fn => {
         try {
-          const current = tree();
-          const updates = updater(current);
-          applyState(enhanced.state, updates);
-        } catch (err) {
-          try {
-            tree.batchUpdate(updater);
-          } catch {}
+          fn();
+        } catch (e) {
+          console.error('[SignalTree] Error in coalesced update:', e);
         }
-      };
-      return enhanced;
+      });
+    };
+    const wrapSignalSetters = (node, path = '') => {
+      if (!node || typeof node !== 'object') return;
+      if (typeof node.set === 'function' && !node.__batchingWrapped) {
+        const originalSet = node.set.bind(node);
+        node.set = value => {
+          if (inCoalesce) {
+            coalescedUpdates.set(path, () => originalSet(value));
+          } else {
+            originalSet(value);
+          }
+          if (!inBatch) {
+            scheduleNotification();
+          }
+        };
+        node.__batchingWrapped = true;
+      }
+      if (typeof node.update === 'function' && !node.__batchingUpdateWrapped) {
+        const originalUpdate = node.update.bind(node);
+        node.update = updater => {
+          if (inCoalesce) {
+            coalescedUpdates.set(`${path}:update:${Date.now()}`, () => originalUpdate(updater));
+          } else {
+            originalUpdate(updater);
+          }
+          if (!inBatch) {
+            scheduleNotification();
+          }
+        };
+        node.__batchingUpdateWrapped = true;
+      }
+      for (const key of Object.keys(node)) {
+        if (key.startsWith('_') || key === 'set' || key === 'update') continue;
+        const child = node[key];
+        if (child && typeof child === 'object') {
+          wrapSignalSetters(child, path ? `${path}.${key}` : key);
+        }
+      }
+    };
+    if (tree.$) {
+      wrapSignalSetters(tree.$);
     }
+    const batchingMethods = {
+      batch(fn) {
+        const wasBatching = inBatch;
+        inBatch = true;
+        try {
+          fn();
+        } finally {
+          inBatch = wasBatching;
+          if (!inBatch) {
+            scheduleNotification();
+          }
+        }
+      },
+      coalesce(fn) {
+        const wasCoalescing = inCoalesce;
+        const wasBatching = inBatch;
+        inCoalesce = true;
+        inBatch = true;
+        try {
+          fn();
+        } finally {
+          inCoalesce = wasCoalescing;
+          inBatch = wasBatching;
+          if (!wasCoalescing) {
+            flushCoalescedUpdates();
+          }
+          if (!inBatch) {
+            scheduleNotification();
+          }
+        }
+      },
+      hasPendingNotifications() {
+        return notificationPending;
+      },
+      flushNotifications() {
+        flushNotificationsInternal();
+      }
+    };
     const originalTreeCall = tree.bind(tree);
     const enhancedTree = function (...args) {
       if (args.length === 0) {
         return originalTreeCall();
       } else {
-        batchUpdates(() => {
-          if (args.length === 1) {
-            const arg = args[0];
-            if (typeof arg === 'function') {
-              originalTreeCall(arg);
-            } else {
-              originalTreeCall(arg);
-            }
+        if (args.length === 1) {
+          const arg = args[0];
+          if (typeof arg === 'function') {
+            originalTreeCall(arg);
+          } else {
+            originalTreeCall(arg);
           }
-        });
+        }
+        if (!inBatch) {
+          scheduleNotification();
+        }
       }
     };
     Object.setPrototypeOf(enhancedTree, Object.getPrototypeOf(tree));
     Object.assign(enhancedTree, tree);
+    try {
+      copyTreeProperties(tree, enhancedTree);
+    } catch {}
     if ('state' in tree) {
       Object.defineProperty(enhancedTree, 'state', {
         value: tree.state,
@@ -135,15 +174,16 @@ function batchingWithConfig(config = {}) {
         configurable: true
       });
     }
+    Object.assign(enhancedTree, batchingMethods);
     enhancedTree.batchUpdate = updater => {
-      batchUpdates(() => {
+      enhancedTree.batch(() => {
         const current = originalTreeCall();
         const updates = updater(current);
         Object.entries(updates).forEach(([key, value]) => {
           const property = enhancedTree.state[key];
-          if (property && 'set' in property) {
+          if (property && typeof property.set === 'function') {
             property.set(value);
-          } else if (isNodeAccessor(property)) {
+          } else if (typeof property === 'function') {
             property(value);
           }
         });
@@ -151,38 +191,28 @@ function batchingWithConfig(config = {}) {
     };
     return enhancedTree;
   };
-  return enhancer;
-}
-function batching(config = {}) {
-  return batchingWithConfig(config);
 }
 function highPerformanceBatching() {
-  return batchingWithConfig({
+  return batching({
     enabled: true,
-    maxBatchSize: 200,
-    debounceMs: 0
+    notificationDelayMs: 0
   });
 }
+function batchingWithConfig(config = {}) {
+  return batching(config);
+}
 function flushBatchedUpdates() {
-  if (updateQueue.length > 0) {
-    const queue = updateQueue.slice();
-    updateQueue = [];
-    isUpdating = false;
-    queue.sort((a, b) => (b.depth ?? 0) - (a.depth ?? 0));
-    queue.forEach(({
-      fn
-    }) => {
-      fn();
-    });
-  }
+  console.warn('[SignalTree] flushBatchedUpdates() is deprecated. Use tree.flushNotifications() instead.');
 }
 function hasPendingUpdates() {
-  return updateQueue.length > 0;
+  console.warn('[SignalTree] hasPendingUpdates() is deprecated. Use tree.hasPendingNotifications() instead.');
+  return false;
 }
 function getBatchQueueSize() {
-  return updateQueue.length;
+  console.warn('[SignalTree] getBatchQueueSize() is deprecated. Signal writes are now synchronous.');
+  return 0;
 }
-Object.assign((config = {}) => batchingWithConfig(config), {
+Object.assign((config = {}) => batching(config), {
   highPerformance: highPerformanceBatching
 });
 

package/dist/enhancers/utils/copy-tree-properties.js

@@ -0,0 +1,20 @@
+function copyTreeProperties(source, target) {
+  const skipKeys = new Set(['state', '$']);
+  for (const key of Object.getOwnPropertyNames(source)) {
+    if (skipKeys.has(key)) continue;
+    if (Object.prototype.hasOwnProperty.call(target, key)) continue;
+    const descriptor = Object.getOwnPropertyDescriptor(source, key);
+    if (!descriptor) continue;
+    if (descriptor.configurable === false) continue;
+    Object.defineProperty(target, key, descriptor);
+  }
+  for (const sym of Object.getOwnPropertySymbols(source)) {
+    if (Object.prototype.hasOwnProperty.call(target, sym)) continue;
+    const descriptor = Object.getOwnPropertyDescriptor(source, sym);
+    if (!descriptor) continue;
+    if (descriptor.configurable === false) continue;
+    Object.defineProperty(target, sym, descriptor);
+  }
+}
+
+export { copyTreeProperties };

package/dist/index.js

@@ -5,7 +5,7 @@ export { createEditSession } from './lib/edit-session.js';
 export { getPathNotifier } from './lib/path-notifier.js';
 export { SecurityPresets, SecurityValidator } from './lib/security/security-validator.js';
 export { createEnhancer, resolveEnhancerOrder } from './enhancers/index.js';
-export { batching, flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, highPerformanceBatching } from './enhancers/batching/batching.js';
+export { batching, batchingWithConfig, flushBatchedUpdates, getBatchQueueSize, hasPendingUpdates, highPerformanceBatching } from './enhancers/batching/batching.js';
 export { clearAllCaches, computedMemoization, deepStateMemoization, getGlobalCacheStats, highFrequencyMemoization, highPerformanceMemoization, lightweightMemoization, memoization, memoize, memoizeReference, memoizeShallow, selectorMemoization, shallowMemoization } from './enhancers/memoization/memoization.js';
 export { enableTimeTravel, timeTravel } from './enhancers/time-travel/time-travel.js';
 export { enableEntities, entities, highPerformanceEntities } from './enhancers/entities/entities.js';

package/dist/lib/utils.js

@@ -260,40 +260,5 @@ function unwrap(node) {
 function snapshotState(state) {
   return unwrap(state);
 }
-function applyState(stateNode, snapshot) {
-  if (snapshot === null || snapshot === undefined) return;
-  if (typeof snapshot !== 'object') return;
-  for (const key of Object.keys(snapshot)) {
-    const val = snapshot[key];
-    const target = stateNode[key];
-    if (isNodeAccessor(target)) {
-      if (val && typeof val === 'object') {
-        try {
-          applyState(target, val);
-        } catch {
-          try {
-            target(val);
-          } catch {}
-        }
-      } else {
-        try {
-          target(val);
-        } catch {}
-      }
-    } else if (isSignal(target)) {
-      try {
-        target.set?.(val);
-      } catch {
-        try {
-          target(val);
-        } catch {}
-      }
-    } else {
-      try {
-        stateNode[key] = val;
-      } catch {}
-    }
-  }
-}
 
-export { applyState, composeEnhancers, createLazySignalTree, isAnySignal, isBuiltInObject, isEntityMapMarker, isNodeAccessor, snapshotState, toWritableSignal, unwrap };
+export { composeEnhancers, createLazySignalTree, isAnySignal, isBuiltInObject, isEntityMapMarker, isNodeAccessor, snapshotState, toWritableSignal, unwrap };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/core",
-  "version": "6.0.14",
+  "version": "6.2.0",
   "description": "Lightweight, type-safe signal-based state management for Angular. Core package providing hierarchical signal trees, basic entity management, and async actions.",
   "type": "module",
   "sideEffects": false,

package/src/enhancers/batching/batching.d.ts

@@ -1,8 +1,7 @@
-import type { ISignalTree, BatchingConfig } from '../../lib/types';
-export type BatchingMethods<T> = import('../../lib/types').BatchingMethods<T>;
-export declare function batchingWithConfig(config?: BatchingConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & BatchingMethods<T>;
+import type { ISignalTree, BatchingConfig, BatchingMethods } from '../../lib/types';
 export declare function batching(config?: BatchingConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & BatchingMethods<T>;
 export declare function highPerformanceBatching(): <T>(tree: ISignalTree<T>) => ISignalTree<T> & BatchingMethods<T>;
+export declare function batchingWithConfig(config?: BatchingConfig): <T>(tree: ISignalTree<T>) => ISignalTree<T> & BatchingMethods<T>;
 export declare function flushBatchedUpdates(): void;
 export declare function hasPendingUpdates(): boolean;
 export declare function getBatchQueueSize(): number;

package/src/enhancers/utils/copy-tree-properties.d.ts

@@ -0,0 +1 @@
+export declare function copyTreeProperties<T extends object>(source: T, target: T): void;

package/src/index.d.ts

@@ -7,7 +7,8 @@ export { getPathNotifier } from './lib/path-notifier';
 export { SecurityValidator, SecurityPresets, type SecurityEvent, type SecurityEventType, type SecurityValidatorConfig, } from './lib/security/security-validator';
 export { createEnhancer, resolveEnhancerOrder } from './enhancers/index';
 export { ENHANCER_META } from './lib/types';
-export { batching, highPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/batching';
+export { batching, batchingWithConfig, highPerformanceBatching, flushBatchedUpdates, hasPendingUpdates, getBatchQueueSize, } from './enhancers/batching/batching';
+export type { BatchingConfig, BatchingMethods } from './lib/types';
 export { memoization, selectorMemoization, computedMemoization, deepStateMemoization, highFrequencyMemoization, highPerformanceMemoization, lightweightMemoization, shallowMemoization, memoize, memoizeShallow, memoizeReference, clearAllCaches, getGlobalCacheStats, } from './enhancers/memoization/memoization';
 export { timeTravel, enableTimeTravel, } from './enhancers/time-travel/time-travel';
 export { entities, enableEntities, highPerformanceEntities, } from './enhancers/entities/entities';

package/src/lib/types.d.ts

@@ -47,13 +47,13 @@ export interface EffectsMethods<T> {
 }
 export interface BatchingConfig {
     enabled?: boolean;
-    debounceMs?: number;
-    batchTimeoutMs?: number;
-    autoFlushDelay?: number;
-    maxBatchSize?: number;
+    notificationDelayMs?: number;
 }
 export interface BatchingMethods<T = unknown> {
     batch(fn: () => void): void;
+    coalesce(fn: () => void): void;
+    hasPendingNotifications(): boolean;
+    flushNotifications(): void;
 }
 export interface MemoizationMethods<T> {
     memoize<R>(fn: (state: T) => R, cacheKey?: string): Signal<R>;