@signaltree/core 4.0.15 → 4.1.0

package/dist/lib/signal-tree.js

@@ -1,665 +1,631 @@
-import { computed, DestroyRef, effect, inject, isSignal, signal } from '@angular/core';
-import { resolveEnhancerOrder } from '../enhancers';
-import { SIGNAL_TREE_CONSTANTS, SIGNAL_TREE_MESSAGES } from './constants';
-import { SignalMemoryManager } from './memory/memory-manager';
-import { OptimizedUpdateEngine } from './performance/update-engine';
-import { SecurityValidator } from './security/security-validator';
-import { createLazySignalTree, equal, isBuiltInObject, unwrap } from './utils';
+import { signal, isSignal, computed, effect, inject, DestroyRef } from '@angular/core';
+import { resolveEnhancerOrder } from '../enhancers/index.js';
+import { SIGNAL_TREE_MESSAGES, SIGNAL_TREE_CONSTANTS } from './constants.js';
+import { SignalMemoryManager } from './memory/memory-manager.js';
+import { OptimizedUpdateEngine } from './performance/update-engine.js';
+import { SecurityValidator } from './security/security-validator.js';
+import { createLazySignalTree, unwrap } from './utils.js';
+import { deepEqual } from '../deep-equal.js';
+import { isBuiltInObject } from '../is-built-in-object.js';
+
 const NODE_ACCESSOR_SYMBOL = Symbol.for('NodeAccessor');
 function makeNodeAccessor() {
-    const accessor = function (arg) {
-        if (arguments.length === 0) {
-            return unwrap(accessor);
-        }
-        if (typeof arg === 'function') {
-            const updater = arg;
-            const currentValue = unwrap(accessor);
-            const newValue = updater(currentValue);
-            recursiveUpdate(accessor, newValue);
-        }
-        else {
-            recursiveUpdate(accessor, arg);
-        }
-    };
-    accessor[NODE_ACCESSOR_SYMBOL] = true;
-    return accessor;
+  const accessor = function (arg) {
+    if (arguments.length === 0) {
+      return unwrap(accessor);
+    }
+    if (typeof arg === 'function') {
+      const updater = arg;
+      const currentValue = unwrap(accessor);
+      const newValue = updater(currentValue);
+      recursiveUpdate(accessor, newValue);
+    } else {
+      recursiveUpdate(accessor, arg);
+    }
+  };
+  accessor[NODE_ACCESSOR_SYMBOL] = true;
+  return accessor;
 }
 function makeRootNodeAccessor(readSignal, writeSignal) {
-    const accessor = function (arg) {
-        if (arguments.length === 0) {
-            return readSignal();
-        }
-        if (typeof arg === 'function') {
-            const updater = arg;
-            writeSignal.set(updater(readSignal()));
-        }
-        else {
-            writeSignal.set(arg);
-        }
-    };
-    accessor[NODE_ACCESSOR_SYMBOL] = true;
-    return accessor;
-}
-function recursiveUpdate(target, updates) {
-    if (!updates || typeof updates !== 'object') {
-        return;
-    }
-    let targetObj;
-    if (isNodeAccessor(target)) {
-        targetObj = target;
+  const accessor = function (arg) {
+    if (arguments.length === 0) {
+      return readSignal();
     }
-    else if (target && typeof target === 'object') {
-        targetObj = target;
+    if (typeof arg === 'function') {
+      const updater = arg;
+      writeSignal.set(updater(readSignal()));
+    } else {
+      writeSignal.set(arg);
     }
-    else {
-        return;
+  };
+  accessor[NODE_ACCESSOR_SYMBOL] = true;
+  return accessor;
+}
+function recursiveUpdate(target, updates) {
+  if (!updates || typeof updates !== 'object') {
+    return;
+  }
+  let targetObj;
+  if (isNodeAccessor(target)) {
+    targetObj = target;
+  } else if (target && typeof target === 'object') {
+    targetObj = target;
+  } else {
+    return;
+  }
+  const updatesObj = updates;
+  for (const key in updatesObj) {
+    if (!(key in targetObj)) {
+      continue;
     }
-    const updatesObj = updates;
-    for (const key in updatesObj) {
-        if (!(key in targetObj)) {
-            continue;
-        }
-        const targetProp = targetObj[key];
-        const updateValue = updatesObj[key];
-        if (isSignal(targetProp)) {
-            if ('set' in targetProp && typeof targetProp.set === 'function') {
-                targetProp.set(updateValue);
-            }
-        }
-        else if (isNodeAccessor(targetProp)) {
-            if (updateValue && typeof updateValue === 'object') {
-                recursiveUpdate(targetProp, updateValue);
-            }
-            else {
-                targetProp(updateValue);
-            }
-        }
+    const targetProp = targetObj[key];
+    const updateValue = updatesObj[key];
+    if (isSignal(targetProp)) {
+      if ('set' in targetProp && typeof targetProp.set === 'function') {
+        targetProp.set(updateValue);
+      }
+    } else if (isNodeAccessor(targetProp)) {
+      if (updateValue && typeof updateValue === 'object') {
+        recursiveUpdate(targetProp, updateValue);
+      } else {
+        targetProp(updateValue);
+      }
     }
+  }
 }
-export function isNodeAccessor(value) {
-    return (typeof value === 'function' &&
-        value &&
-        value[NODE_ACCESSOR_SYMBOL] === true);
+function isNodeAccessor(value) {
+  return typeof value === 'function' && value && value[NODE_ACCESSOR_SYMBOL] === true;
 }
 function estimateObjectSize(obj, maxDepth = SIGNAL_TREE_CONSTANTS.ESTIMATE_MAX_DEPTH, currentDepth = 0) {
-    if (currentDepth >= maxDepth)
-        return 1;
-    if (obj === null || obj === undefined)
-        return 0;
-    if (typeof obj !== 'object')
-        return 1;
-    let size = 0;
-    try {
-        if (Array.isArray(obj)) {
-            size = obj.length;
-            const sampleSize = Math.min(SIGNAL_TREE_CONSTANTS.ESTIMATE_SAMPLE_SIZE_ARRAY, obj.length);
-            for (let i = 0; i < sampleSize; i++) {
-                size += estimateObjectSize(obj[i], maxDepth, currentDepth + 1) * 0.1;
-            }
-        }
-        else {
-            const keys = Object.keys(obj);
-            size = keys.length;
-            const sampleSize = Math.min(SIGNAL_TREE_CONSTANTS.ESTIMATE_SAMPLE_SIZE_OBJECT, keys.length);
-            for (let i = 0; i < sampleSize; i++) {
-                const value = obj[keys[i]];
-                size += estimateObjectSize(value, maxDepth, currentDepth + 1) * 0.5;
-            }
-        }
-    }
-    catch {
-        return 1;
+  if (currentDepth >= maxDepth) return 1;
+  if (obj === null || obj === undefined) return 0;
+  if (typeof obj !== 'object') return 1;
+  let size = 0;
+  try {
+    if (Array.isArray(obj)) {
+      size = obj.length;
+      const sampleSize = Math.min(SIGNAL_TREE_CONSTANTS.ESTIMATE_SAMPLE_SIZE_ARRAY, obj.length);
+      for (let i = 0; i < sampleSize; i++) {
+        size += estimateObjectSize(obj[i], maxDepth, currentDepth + 1) * 0.1;
+      }
+    } else {
+      const keys = Object.keys(obj);
+      size = keys.length;
+      const sampleSize = Math.min(SIGNAL_TREE_CONSTANTS.ESTIMATE_SAMPLE_SIZE_OBJECT, keys.length);
+      for (let i = 0; i < sampleSize; i++) {
+        const value = obj[keys[i]];
+        size += estimateObjectSize(value, maxDepth, currentDepth + 1) * 0.5;
+      }
     }
-    return Math.floor(size);
+  } catch {
+    return 1;
+  }
+  return Math.floor(size);
 }
 function shouldUseLazy(obj, config, precomputedSize) {
-    if (config.useLazySignals !== undefined)
-        return config.useLazySignals;
-    if (config.debugMode || config.enableDevTools)
-        return false;
-    if (config.batchUpdates && config.useMemoization)
-        return true;
-    const estimatedSize = precomputedSize ?? estimateObjectSize(obj);
-    return estimatedSize > SIGNAL_TREE_CONSTANTS.LAZY_THRESHOLD;
+  if (config.useLazySignals !== undefined) return config.useLazySignals;
+  if (config.debugMode || config.enableDevTools) return false;
+  if (config.batchUpdates && config.useMemoization) return true;
+  const estimatedSize = precomputedSize ?? estimateObjectSize(obj);
+  return estimatedSize > SIGNAL_TREE_CONSTANTS.LAZY_THRESHOLD;
 }
 function validateTree(obj, config, path = []) {
-    if (!config.security) {
-        return;
+  if (!config.security) {
+    return;
+  }
+  const validator = new SecurityValidator(config.security);
+  function validate(value, currentPath) {
+    if (value === null || value === undefined) {
+      return;
     }
-    const validator = new SecurityValidator(config.security);
-    function validate(value, currentPath) {
-        if (value === null || value === undefined) {
-            return;
-        }
-        if (typeof value !== 'object') {
-            validator.validateValue(value);
-            return;
-        }
-        if (isBuiltInObject(value)) {
-            return;
-        }
-        if (Array.isArray(value)) {
-            value.forEach((item, index) => {
-                validate(item, [...currentPath, String(index)]);
-            });
-            return;
-        }
-        const keys = [
-            ...Object.keys(value),
-            ...Object.getOwnPropertyNames(value),
-        ];
-        const uniqueKeys = [...new Set(keys)];
-        for (const key of uniqueKeys) {
-            if (typeof key === 'symbol')
-                continue;
-            try {
-                validator.validateKey(key);
-            }
-            catch (error) {
-                const err = error;
-                throw new Error(`${err.message}\nPath: ${[...currentPath, key].join('.')}`);
-            }
-            const val = value[key];
-            try {
-                validator.validateValue(val);
-            }
-            catch (error) {
-                const err = error;
-                throw new Error(`${err.message}\nPath: ${[...currentPath, key].join('.')}`);
-            }
-            validate(val, [...currentPath, key]);
-        }
+    if (typeof value !== 'object') {
+      validator.validateValue(value);
+      return;
+    }
+    if (isBuiltInObject(value)) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        validate(item, [...currentPath, String(index)]);
+      });
+      return;
     }
-    validate(obj, path);
+    const keys = [...Object.keys(value), ...Object.getOwnPropertyNames(value)];
+    const uniqueKeys = [...new Set(keys)];
+    for (const key of uniqueKeys) {
+      if (typeof key === 'symbol') continue;
+      try {
+        validator.validateKey(key);
+      } catch (error) {
+        const err = error;
+        throw new Error(`${err.message}\nPath: ${[...currentPath, key].join('.')}`);
+      }
+      const val = value[key];
+      try {
+        validator.validateValue(val);
+      } catch (error) {
+        const err = error;
+        throw new Error(`${err.message}\nPath: ${[...currentPath, key].join('.')}`);
+      }
+      validate(val, [...currentPath, key]);
+    }
+  }
+  validate(obj, path);
 }
 function createEqualityFn(useShallowComparison) {
-    return useShallowComparison ? Object.is : equal;
+  return useShallowComparison ? Object.is : deepEqual;
 }
 function createSignalStore(obj, equalityFn) {
-    if (obj === null || obj === undefined || typeof obj !== 'object') {
-        return signal(obj, { equal: equalityFn });
-    }
-    if (Array.isArray(obj)) {
-        return signal(obj, { equal: equalityFn });
-    }
-    if (isBuiltInObject(obj)) {
-        return signal(obj, { equal: equalityFn });
-    }
-    const store = {};
-    const processedObjects = new WeakSet();
-    if (processedObjects.has(obj)) {
-        console.warn(SIGNAL_TREE_MESSAGES.CIRCULAR_REF);
-        return signal(obj, { equal: equalityFn });
-    }
-    processedObjects.add(obj);
-    try {
-        for (const [key, value] of Object.entries(obj)) {
-            try {
-                if (typeof key === 'symbol')
-                    continue;
-                if (isSignal(value)) {
-                    store[key] = value;
-                    continue;
-                }
-                if (value === null || value === undefined) {
-                    store[key] = signal(value, {
-                        equal: equalityFn,
-                    });
-                }
-                else if (typeof value !== 'object') {
-                    store[key] = signal(value, {
-                        equal: equalityFn,
-                    });
-                }
-                else if (Array.isArray(value) || isBuiltInObject(value)) {
-                    store[key] = signal(value, {
-                        equal: equalityFn,
-                    });
-                }
-                else {
-                    const branch = createSignalStore(value, equalityFn);
-                    const callableBranch = makeNodeAccessor();
-                    for (const branchKey in branch) {
-                        if (Object.prototype.hasOwnProperty.call(branch, branchKey)) {
-                            try {
-                                Object.defineProperty(callableBranch, branchKey, {
-                                    value: branch[branchKey],
-                                    enumerable: true,
-                                    configurable: true,
-                                });
-                            }
-                            catch {
-                            }
-                        }
-                    }
-                    store[key] = callableBranch;
-                }
-            }
-            catch (error) {
-                console.warn(`${SIGNAL_TREE_MESSAGES.SIGNAL_CREATION_FAILED} "${key}":`, error);
-                store[key] = signal(value, {
-                    equal: equalityFn,
-                });
-            }
+  if (obj === null || obj === undefined || typeof obj !== 'object') {
+    return signal(obj, {
+      equal: equalityFn
+    });
+  }
+  if (Array.isArray(obj)) {
+    return signal(obj, {
+      equal: equalityFn
+    });
+  }
+  if (isBuiltInObject(obj)) {
+    return signal(obj, {
+      equal: equalityFn
+    });
+  }
+  const store = {};
+  const processedObjects = new WeakSet();
+  if (processedObjects.has(obj)) {
+    console.warn(SIGNAL_TREE_MESSAGES.CIRCULAR_REF);
+    return signal(obj, {
+      equal: equalityFn
+    });
+  }
+  processedObjects.add(obj);
+  try {
+    for (const [key, value] of Object.entries(obj)) {
+      try {
+        if (typeof key === 'symbol') continue;
+        if (isSignal(value)) {
+          store[key] = value;
+          continue;
         }
-        const symbols = Object.getOwnPropertySymbols(obj);
-        for (const sym of symbols) {
-            const value = obj[sym];
-            try {
-                if (isSignal(value)) {
-                    store[sym] = value;
-                }
-                else {
-                    store[sym] = signal(value, {
-                        equal: equalityFn,
-                    });
-                }
-            }
-            catch (error) {
-                console.warn(SIGNAL_TREE_MESSAGES.SIGNAL_CREATION_FAILED, error);
+        if (value === null || value === undefined) {
+          store[key] = signal(value, {
+            equal: equalityFn
+          });
+        } else if (typeof value !== 'object') {
+          store[key] = signal(value, {
+            equal: equalityFn
+          });
+        } else if (Array.isArray(value) || isBuiltInObject(value)) {
+          store[key] = signal(value, {
+            equal: equalityFn
+          });
+        } else {
+          const branch = createSignalStore(value, equalityFn);
+          const callableBranch = makeNodeAccessor();
+          for (const branchKey in branch) {
+            if (Object.prototype.hasOwnProperty.call(branch, branchKey)) {
+              try {
+                Object.defineProperty(callableBranch, branchKey, {
+                  value: branch[branchKey],
+                  enumerable: true,
+                  configurable: true
+                });
+              } catch {}
             }
+          }
+          store[key] = callableBranch;
         }
+      } catch (error) {
+        console.warn(`${SIGNAL_TREE_MESSAGES.SIGNAL_CREATION_FAILED} "${key}":`, error);
+        store[key] = signal(value, {
+          equal: equalityFn
+        });
+      }
     }
-    catch (error) {
-        throw new Error(`Failed to create signal store: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    const symbols = Object.getOwnPropertySymbols(obj);
+    for (const sym of symbols) {
+      const value = obj[sym];
+      try {
+        if (isSignal(value)) {
+          store[sym] = value;
+        } else {
+          store[sym] = signal(value, {
+            equal: equalityFn
+          });
+        }
+      } catch (error) {
+        console.warn(SIGNAL_TREE_MESSAGES.SIGNAL_CREATION_FAILED, error);
+      }
     }
-    return store;
+  } catch (error) {
+    throw new Error(`Failed to create signal store: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+  return store;
 }
 function enhanceTree(tree, config = {}) {
-    const isLazy = config.useLazySignals ?? shouldUseLazy(tree.state, config);
-    tree.with = ((...enhancers) => {
-        if (enhancers.length === 0) {
-            return tree;
-        }
-        const coreCapabilities = new Set();
-        if (config.batchUpdates)
-            coreCapabilities.add('batchUpdate');
-        if (config.useMemoization)
-            coreCapabilities.add('memoize');
-        if (config.enableTimeTravel)
-            coreCapabilities.add('undo');
-        if (config.enableDevTools)
-            coreCapabilities.add('connectDevTools');
-        try {
-            for (const key of Object.keys(tree))
-                coreCapabilities.add(String(key));
-        }
-        catch {
-        }
-        const hasMetadata = enhancers.some((e) => Boolean(e.metadata && (e.metadata.requires || e.metadata.provides)));
-        let orderedEnhancers = enhancers;
-        if (hasMetadata) {
-            try {
-                orderedEnhancers = resolveEnhancerOrder(enhancers, coreCapabilities, config.debugMode);
-            }
-            catch (err) {
-                console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_ORDER_FAILED, err);
-            }
-        }
-        const provided = new Set(coreCapabilities);
-        let currentTree = tree;
-        for (let i = 0; i < orderedEnhancers.length; i++) {
-            const enhancer = orderedEnhancers[i];
-            if (typeof enhancer !== 'function') {
-                throw new Error(SIGNAL_TREE_MESSAGES.ENHANCER_NOT_FUNCTION.replace('%d', String(i)));
-            }
-            const reqs = enhancer.metadata?.requires ?? [];
-            for (const r of reqs) {
-                if (!(r in currentTree) && !provided.has(r)) {
-                    const name = enhancer.metadata?.name ?? `enhancer#${i}`;
-                    const msg = SIGNAL_TREE_MESSAGES.ENHANCER_REQUIREMENT_MISSING.replace('%s', name).replace('%s', r);
-                    if (config.debugMode) {
-                        throw new Error(msg);
-                    }
-                    else {
-                        console.warn(msg);
-                    }
-                }
-            }
-            try {
-                const result = enhancer(currentTree);
-                if (result !== currentTree)
-                    currentTree = result;
-                const provs = enhancer.metadata?.provides ?? [];
-                for (const p of provs)
-                    provided.add(p);
-                if (config.debugMode && provs.length > 0) {
-                    for (const p of provs) {
-                        if (!(p in currentTree)) {
-                            console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_PROVIDES_MISSING.replace('%s', enhancer.metadata?.name ?? String(i)).replace('%s', p));
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                const name = enhancer.metadata?.name || `enhancer at index ${i}`;
-                console.error(SIGNAL_TREE_MESSAGES.ENHANCER_FAILED.replace('%s', name), error);
-                if (config.debugMode) {
-                    console.error('[SignalTree] Enhancer stack trace:', enhancer);
-                    console.error('[SignalTree] Tree state at failure:', currentTree);
-                }
-                throw error;
-            }
-        }
-        return currentTree;
-    });
-    tree.destroy = () => {
-        try {
-            if (isLazy) {
-                const state = tree.state;
-                if (state && typeof state === 'object' && '__cleanup__' in state) {
-                    const cleanup = state.__cleanup__;
-                    if (typeof cleanup === 'function') {
-                        cleanup();
-                    }
-                }
-            }
-            if (config.debugMode) {
-                console.log(SIGNAL_TREE_MESSAGES.TREE_DESTROYED);
+  const isLazy = config.useLazySignals ?? shouldUseLazy(tree.state, config);
+  tree.with = (...enhancers) => {
+    if (enhancers.length === 0) {
+      return tree;
+    }
+    const coreCapabilities = new Set();
+    if (config.batchUpdates) coreCapabilities.add('batchUpdate');
+    if (config.useMemoization) coreCapabilities.add('memoize');
+    if (config.enableTimeTravel) coreCapabilities.add('undo');
+    if (config.enableDevTools) coreCapabilities.add('connectDevTools');
+    try {
+      for (const key of Object.keys(tree)) coreCapabilities.add(String(key));
+    } catch {}
+    const hasMetadata = enhancers.some(e => Boolean(e.metadata && (e.metadata.requires || e.metadata.provides)));
+    let orderedEnhancers = enhancers;
+    if (hasMetadata) {
+      try {
+        orderedEnhancers = resolveEnhancerOrder(enhancers, coreCapabilities, config.debugMode);
+      } catch (err) {
+        console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_ORDER_FAILED, err);
+      }
+    }
+    const provided = new Set(coreCapabilities);
+    let currentTree = tree;
+    for (let i = 0; i < orderedEnhancers.length; i++) {
+      const enhancer = orderedEnhancers[i];
+      if (typeof enhancer !== 'function') {
+        throw new Error(SIGNAL_TREE_MESSAGES.ENHANCER_NOT_FUNCTION.replace('%d', String(i)));
+      }
+      const reqs = enhancer.metadata?.requires ?? [];
+      for (const r of reqs) {
+        if (!(r in currentTree) && !provided.has(r)) {
+          const name = enhancer.metadata?.name ?? `enhancer#${i}`;
+          const msg = SIGNAL_TREE_MESSAGES.ENHANCER_REQUIREMENT_MISSING.replace('%s', name).replace('%s', r);
+          if (config.debugMode) {
+            throw new Error(msg);
+          } else {
+            console.warn(msg);
+          }
+        }
+      }
+      try {
+        const result = enhancer(currentTree);
+        if (result !== currentTree) currentTree = result;
+        const provs = enhancer.metadata?.provides ?? [];
+        for (const p of provs) provided.add(p);
+        if (config.debugMode && provs.length > 0) {
+          for (const p of provs) {
+            if (!(p in currentTree)) {
+              console.warn(SIGNAL_TREE_MESSAGES.ENHANCER_PROVIDES_MISSING.replace('%s', enhancer.metadata?.name ?? String(i)).replace('%s', p));
             }
+          }
         }
-        catch (error) {
-            console.error(SIGNAL_TREE_MESSAGES.CLEANUP_ERROR, error);
+      } catch (error) {
+        const name = enhancer.metadata?.name || `enhancer at index ${i}`;
+        console.error(SIGNAL_TREE_MESSAGES.ENHANCER_FAILED.replace('%s', name), error);
+        if (config.debugMode) {
+          console.error('[SignalTree] Enhancer stack trace:', enhancer);
+          console.error('[SignalTree] Tree state at failure:', currentTree);
         }
-    };
-    addStubMethods(tree, config);
-    return tree;
+        throw error;
+      }
+    }
+    return currentTree;
+  };
+  tree.destroy = () => {
+    try {
+      if (isLazy) {
+        const state = tree.state;
+        if (state && typeof state === 'object' && '__cleanup__' in state) {
+          const cleanup = state.__cleanup__;
+          if (typeof cleanup === 'function') {
+            cleanup();
+          }
+        }
+      }
+      if (config.debugMode) {
+        console.log(SIGNAL_TREE_MESSAGES.TREE_DESTROYED);
+      }
+    } catch (error) {
+      console.error(SIGNAL_TREE_MESSAGES.CLEANUP_ERROR, error);
+    }
+  };
+  addStubMethods(tree, config);
+  return tree;
 }
 function addStubMethods(tree, config) {
-    tree.batchUpdate = (updater) => {
-        console.warn(SIGNAL_TREE_MESSAGES.BATCH_NOT_ENABLED);
-        tree((current) => {
-            const partial = updater(current);
-            return { ...current, ...partial };
-        });
-    };
-    tree.memoize = (fn, cacheKey) => {
-        console.warn(SIGNAL_TREE_MESSAGES.MEMOIZE_NOT_ENABLED);
-        void cacheKey;
-        return computed(() => fn(tree()));
-    };
-    tree.memoizedUpdate = (updater) => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.MEMOIZE_NOT_ENABLED);
-        }
-        tree((current) => ({ ...current, ...updater(current) }));
-    };
-    tree.clearMemoCache = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.MEMOIZE_NOT_ENABLED);
-        }
-    };
-    tree.getCacheStats = () => ({
-        size: 0,
-        hitRate: 0,
-        totalHits: 0,
-        totalMisses: 0,
-        keys: [],
+  tree.batchUpdate = updater => {
+    console.warn(SIGNAL_TREE_MESSAGES.BATCH_NOT_ENABLED);
+    tree(current => {
+      const partial = updater(current);
+      return {
+        ...current,
+        ...partial
+      };
     });
-    tree.effect = (fn) => {
-        try {
-            effect(() => fn(tree()));
-        }
-        catch (error) {
-            if (config.debugMode) {
-                console.warn(SIGNAL_TREE_MESSAGES.EFFECT_NO_CONTEXT, error);
-            }
-        }
-    };
-    tree.subscribe = (fn) => {
-        try {
-            const destroyRef = inject(DestroyRef);
-            let isDestroyed = false;
-            const effectRef = effect(() => {
-                if (!isDestroyed) {
-                    fn(tree());
-                }
-            });
-            const unsubscribe = () => {
-                isDestroyed = true;
-                effectRef.destroy();
-            };
-            destroyRef.onDestroy(unsubscribe);
-            return unsubscribe;
-        }
-        catch (error) {
-            if (config.debugMode) {
-                console.warn(SIGNAL_TREE_MESSAGES.SUBSCRIBE_NO_CONTEXT, error);
-            }
-            fn(tree());
-            return () => {
-            };
-        }
-    };
-    tree.optimize = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.OPTIMIZE_NOT_AVAILABLE);
-        }
-    };
-    tree.clearCache = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.CACHE_NOT_AVAILABLE);
-        }
-    };
-    tree.invalidatePattern = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.PERFORMANCE_NOT_ENABLED);
-        }
-        return 0;
-    };
+  };
+  tree.memoize = (fn, cacheKey) => {
+    console.warn(SIGNAL_TREE_MESSAGES.MEMOIZE_NOT_ENABLED);
+    return computed(() => fn(tree()));
+  };
+  tree.memoizedUpdate = updater => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.MEMOIZE_NOT_ENABLED);
+    }
+    tree(current => ({
+      ...current,
+      ...updater(current)
+    }));
+  };
+  tree.clearMemoCache = () => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.MEMOIZE_NOT_ENABLED);
+    }
+  };
+  tree.getCacheStats = () => ({
+    size: 0,
+    hitRate: 0,
+    totalHits: 0,
+    totalMisses: 0,
+    keys: []
+  });
+  tree.effect = fn => {
+    try {
+      effect(() => fn(tree()));
+    } catch (error) {
+      if (config.debugMode) {
+        console.warn(SIGNAL_TREE_MESSAGES.EFFECT_NO_CONTEXT, error);
+      }
+    }
+  };
+  tree.subscribe = fn => {
+    try {
+      const destroyRef = inject(DestroyRef);
+      let isDestroyed = false;
+      const effectRef = effect(() => {
+        if (!isDestroyed) {
+          fn(tree());
+        }
+      });
+      const unsubscribe = () => {
+        isDestroyed = true;
+        effectRef.destroy();
+      };
+      destroyRef.onDestroy(unsubscribe);
+      return unsubscribe;
+    } catch (error) {
+      if (config.debugMode) {
+        console.warn(SIGNAL_TREE_MESSAGES.SUBSCRIBE_NO_CONTEXT, error);
+      }
+      fn(tree());
+      return () => {};
+    }
+  };
+  tree.optimize = () => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.OPTIMIZE_NOT_AVAILABLE);
+    }
+  };
+  tree.clearCache = () => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.CACHE_NOT_AVAILABLE);
+    }
+  };
+  tree.invalidatePattern = () => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.PERFORMANCE_NOT_ENABLED);
+    }
+    return 0;
+  };
+  const treeWithEngine = tree;
+  if (!treeWithEngine.updateEngine) {
+    treeWithEngine.updateEngine = new OptimizedUpdateEngine(tree);
+  }
+  tree.updateOptimized = (updates, options = {}) => {
     const treeWithEngine = tree;
-    if (!treeWithEngine.updateEngine) {
-        treeWithEngine.updateEngine = new OptimizedUpdateEngine(tree);
-    }
-    tree.updateOptimized = (updates, options = {}) => {
-        const treeWithEngine = tree;
-        const engine = treeWithEngine.updateEngine;
-        if (!engine) {
-            if (config.debugMode) {
-                console.warn(SIGNAL_TREE_MESSAGES.UPDATE_OPTIMIZED_NOT_AVAILABLE);
-            }
-            tree((current) => ({ ...current, ...updates }));
-            return {
-                changed: true,
-                duration: 0,
-                changedPaths: Object.keys(updates),
-                stats: undefined,
-            };
-        }
-        return engine.update(tree(), updates, options);
-    };
-    tree.getMetrics = () => {
-        return {
-            updates: 0,
-            computations: 0,
-            cacheHits: 0,
-            cacheMisses: 0,
-            averageUpdateTime: 0,
-        };
-    };
-    tree.addTap = (middleware) => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.MIDDLEWARE_NOT_AVAILABLE);
-        }
-        void middleware;
-    };
-    tree.removeTap = (id) => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.MIDDLEWARE_NOT_AVAILABLE);
-        }
-        void id;
-    };
-    tree.entities = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.ENTITY_HELPERS_NOT_AVAILABLE);
-        }
-        return {};
-    };
-    tree.asyncAction = (operation, asyncConfig = {}) => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.ASYNC_ACTIONS_NOT_AVAILABLE);
-        }
-        void operation;
-        void asyncConfig;
-        return {};
-    };
-    tree.undo = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
-        }
-    };
-    tree.redo = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
-        }
-    };
-    tree.getHistory = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
-        }
-        return [];
-    };
-    tree.resetHistory = () => {
-        if (config.debugMode) {
-            console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
-        }
+    const engine = treeWithEngine.updateEngine;
+    if (!engine) {
+      if (config.debugMode) {
+        console.warn(SIGNAL_TREE_MESSAGES.UPDATE_OPTIMIZED_NOT_AVAILABLE);
+      }
+      tree(current => ({
+        ...current,
+        ...updates
+      }));
+      return {
+        changed: true,
+        duration: 0,
+        changedPaths: Object.keys(updates),
+        stats: undefined
+      };
+    }
+    return engine.update(tree(), updates, options);
+  };
+  tree.getMetrics = () => {
+    return {
+      updates: 0,
+      computations: 0,
+      cacheHits: 0,
+      cacheMisses: 0,
+      averageUpdateTime: 0
     };
-}
-function create(obj, config = {}) {
-    if (obj === null || obj === undefined) {
-        throw new Error(SIGNAL_TREE_MESSAGES.NULL_OR_UNDEFINED);
+  };
+  tree.addTap = middleware => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.MIDDLEWARE_NOT_AVAILABLE);
     }
-    validateTree(obj, config);
-    const estimatedSize = estimateObjectSize(obj);
-    const equalityFn = createEqualityFn(config.useShallowComparison ?? false);
-    if (Array.isArray(obj)) {
-        const signalState = signal(obj, {
-            equal: equalityFn,
-        });
-        const tree = makeRootNodeAccessor(signalState, signalState);
-        Object.defineProperty(tree, 'state', {
-            value: signalState,
-            enumerable: false,
-        });
-        Object.defineProperty(tree, '$', { value: signalState, enumerable: false });
-        enhanceTree(tree, config);
-        return tree;
+  };
+  tree.removeTap = id => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.MIDDLEWARE_NOT_AVAILABLE);
     }
-    const useLazy = shouldUseLazy(obj, config, estimatedSize);
+  };
+  tree.entities = () => {
     if (config.debugMode) {
-        console.log(SIGNAL_TREE_MESSAGES.STRATEGY_SELECTION.replace('%s', useLazy ? 'lazy' : 'eager').replace('%d', String(estimatedSize)));
+      console.warn(SIGNAL_TREE_MESSAGES.ENTITY_HELPERS_NOT_AVAILABLE);
     }
-    let signalState;
-    let memoryManager;
-    try {
-        if (useLazy && typeof obj === 'object') {
-            memoryManager = new SignalMemoryManager();
-            signalState = createLazySignalTree(obj, equalityFn, '', memoryManager);
-        }
-        else {
-            signalState = createSignalStore(obj, equalityFn);
-        }
+    return {};
+  };
+  tree.asyncAction = (operation, asyncConfig = {}) => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.ASYNC_ACTIONS_NOT_AVAILABLE);
     }
-    catch (error) {
-        if (useLazy) {
-            console.warn(SIGNAL_TREE_MESSAGES.LAZY_FALLBACK, error);
-            signalState = createSignalStore(obj, equalityFn);
-            memoryManager = undefined;
-        }
-        else {
-            throw error;
-        }
+    return {};
+  };
+  tree.undo = () => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
     }
-    const tree = function (arg) {
-        if (arguments.length === 0) {
-            return unwrap(signalState);
-        }
-        if (typeof arg === 'function') {
-            const updater = arg;
-            const currentValue = unwrap(signalState);
-            const newValue = updater(currentValue);
-            recursiveUpdate(signalState, newValue);
-        }
-        else {
-            recursiveUpdate(signalState, arg);
-        }
-    };
-    Object.defineProperty(tree, NODE_ACCESSOR_SYMBOL, {
-        value: true,
-        enumerable: false,
+  };
+  tree.redo = () => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
+    }
+  };
+  tree.getHistory = () => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
+    }
+    return [];
+  };
+  tree.resetHistory = () => {
+    if (config.debugMode) {
+      console.warn(SIGNAL_TREE_MESSAGES.TIME_TRAVEL_NOT_AVAILABLE);
+    }
+  };
+}
+function create(obj, config = {}) {
+  if (obj === null || obj === undefined) {
+    throw new Error(SIGNAL_TREE_MESSAGES.NULL_OR_UNDEFINED);
+  }
+  validateTree(obj, config);
+  const estimatedSize = estimateObjectSize(obj);
+  const equalityFn = createEqualityFn(config.useShallowComparison ?? false);
+  if (Array.isArray(obj)) {
+    const signalState = signal(obj, {
+      equal: equalityFn
     });
+    const tree = makeRootNodeAccessor(signalState, signalState);
     Object.defineProperty(tree, 'state', {
-        value: signalState,
-        enumerable: false,
+      value: signalState,
+      enumerable: false
+    });
+    Object.defineProperty(tree, '$', {
+      value: signalState,
+      enumerable: false
     });
-    Object.defineProperty(tree, '$', { value: signalState, enumerable: false });
-    if (memoryManager) {
-        Object.defineProperty(tree, 'dispose', {
-            value: () => {
-                memoryManager?.dispose();
-                const cleanup = signalState.__cleanup__;
-                if (typeof cleanup === 'function') {
-                    cleanup();
-                }
-            },
-            enumerable: false,
-            writable: false,
-        });
-    }
     enhanceTree(tree, config);
-    for (const key in signalState) {
-        if (Object.prototype.hasOwnProperty.call(signalState, key)) {
-            if (!(key in tree)) {
-                try {
-                    Object.defineProperty(tree, key, {
-                        value: signalState[key],
-                        enumerable: true,
-                        configurable: true,
-                    });
-                }
-                catch {
-                }
-            }
-        }
-    }
     return tree;
+  }
+  const useLazy = shouldUseLazy(obj, config, estimatedSize);
+  if (config.debugMode) {
+    console.log(SIGNAL_TREE_MESSAGES.STRATEGY_SELECTION.replace('%s', useLazy ? 'lazy' : 'eager').replace('%d', String(estimatedSize)));
+  }
+  let signalState;
+  let memoryManager;
+  try {
+    if (useLazy && typeof obj === 'object') {
+      memoryManager = new SignalMemoryManager();
+      signalState = createLazySignalTree(obj, equalityFn, '', memoryManager);
+    } else {
+      signalState = createSignalStore(obj, equalityFn);
+    }
+  } catch (error) {
+    if (useLazy) {
+      console.warn(SIGNAL_TREE_MESSAGES.LAZY_FALLBACK, error);
+      signalState = createSignalStore(obj, equalityFn);
+      memoryManager = undefined;
+    } else {
+      throw error;
+    }
+  }
+  const tree = function (arg) {
+    if (arguments.length === 0) {
+      return unwrap(signalState);
+    }
+    if (typeof arg === 'function') {
+      const updater = arg;
+      const currentValue = unwrap(signalState);
+      const newValue = updater(currentValue);
+      recursiveUpdate(signalState, newValue);
+    } else {
+      recursiveUpdate(signalState, arg);
+    }
+  };
+  Object.defineProperty(tree, NODE_ACCESSOR_SYMBOL, {
+    value: true,
+    enumerable: false
+  });
+  Object.defineProperty(tree, 'state', {
+    value: signalState,
+    enumerable: false
+  });
+  Object.defineProperty(tree, '$', {
+    value: signalState,
+    enumerable: false
+  });
+  if (memoryManager) {
+    Object.defineProperty(tree, 'dispose', {
+      value: () => {
+        memoryManager?.dispose();
+        const cleanup = signalState.__cleanup__;
+        if (typeof cleanup === 'function') {
+          cleanup();
+        }
+      },
+      enumerable: false,
+      writable: false
+    });
+  }
+  enhanceTree(tree, config);
+  for (const key in signalState) {
+    if (Object.prototype.hasOwnProperty.call(signalState, key)) {
+      if (!(key in tree)) {
+        try {
+          Object.defineProperty(tree, key, {
+            value: signalState[key],
+            enumerable: true,
+            configurable: true
+          });
+        } catch {}
+      }
+    }
+  }
+  return tree;
 }
 const presetConfigs = {
-    basic: {
-        useLazySignals: false,
-        debugMode: false,
-    },
-    performance: {
-        useLazySignals: true,
-        batchUpdates: true,
-        useMemoization: true,
-        useShallowComparison: true,
-    },
-    development: {
-        useLazySignals: false,
-        debugMode: true,
-        enableDevTools: true,
-        trackPerformance: true,
-    },
-    production: {
-        useLazySignals: true,
-        batchUpdates: true,
-        useMemoization: true,
-        debugMode: false,
-    },
+  basic: {
+    useLazySignals: false,
+    debugMode: false
+  },
+  performance: {
+    useLazySignals: true,
+    batchUpdates: true,
+    useMemoization: true,
+    useShallowComparison: true
+  },
+  development: {
+    useLazySignals: false,
+    debugMode: true,
+    enableDevTools: true,
+    trackPerformance: true
+  },
+  production: {
+    useLazySignals: true,
+    batchUpdates: true,
+    useMemoization: true,
+    debugMode: false
+  }
 };
-export function signalTree(obj, configOrPreset) {
-    if (typeof configOrPreset === 'string') {
-        const config = presetConfigs[configOrPreset];
-        if (!config) {
-            console.warn(SIGNAL_TREE_MESSAGES.PRESET_UNKNOWN.replace('%s', configOrPreset));
-            return create(obj, {});
-        }
-        return create(obj, config);
+function signalTree(obj, configOrPreset) {
+  if (typeof configOrPreset === 'string') {
+    const config = presetConfigs[configOrPreset];
+    if (!config) {
+      console.warn(SIGNAL_TREE_MESSAGES.PRESET_UNKNOWN.replace('%s', configOrPreset));
+      return create(obj, {});
     }
-    const config = configOrPreset || {};
     return create(obj, config);
+  }
+  const config = configOrPreset || {};
+  return create(obj, config);
 }
-export function applyEnhancer(tree, enhancer) {
-    return enhancer(tree);
-}
+
+export { isNodeAccessor, signalTree };