@signaltree/core 5.1.6 → 6.0.1

package/dist/lib/signal-tree.js

@@ -1,80 +1,20 @@
-import { signal, isSignal, computed, effect, inject, DestroyRef } from '@angular/core';
-import { resolveEnhancerOrder } from '../enhancers/index.js';
+import { signal, isSignal } from '@angular/core';
 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;
-}
-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;
+const NODE_ACCESSOR_SYMBOL = Symbol.for('SignalTree:NodeAccessor');
+function isNodeAccessor(value) {
+  return typeof value === 'function' && value[NODE_ACCESSOR_SYMBOL] === true;
 }
-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 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);
-      }
-    }
-  }
+function isEntityMapMarker(value) {
+  return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
 }
-function isNodeAccessor(value) {
-  return typeof value === 'function' && value && value[NODE_ACCESSOR_SYMBOL] === true;
+function createEqualityFn(useShallowComparison) {
+  return useShallowComparison ? Object.is : deepEqual;
 }
 function estimateObjectSize(obj, maxDepth = SIGNAL_TREE_CONSTANTS.ESTIMATE_MAX_DEPTH, currentDepth = 0) {
   if (currentDepth >= maxDepth) return 1;
@@ -105,56 +45,79 @@ function estimateObjectSize(obj, maxDepth = SIGNAL_TREE_CONSTANTS.ESTIMATE_MAX_D
 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;
 }
-function validateTree(obj, config, path = []) {
-  if (!config.security) {
-    return;
-  }
+function validateTree(obj, config) {
+  if (!config.security) return;
   const validator = new SecurityValidator(config.security);
-  function validate(value, currentPath) {
-    if (value === null || value === undefined) {
-      return;
-    }
+  function validate(value, path) {
+    if (value === null || value === undefined) return;
     if (typeof value !== 'object') {
       validator.validateValue(value);
       return;
     }
-    if (isBuiltInObject(value)) {
-      return;
-    }
+    if (isBuiltInObject(value)) return;
     if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        validate(item, [...currentPath, String(index)]);
-      });
+      value.forEach((item, i) => validate(item, [...path, String(i)]));
       return;
     }
-    const keys = [...Object.keys(value), ...Object.getOwnPropertyNames(value)];
-    const uniqueKeys = [...new Set(keys)];
-    for (const key of uniqueKeys) {
-      if (typeof key === 'symbol') continue;
+    for (const key of Object.keys(value)) {
       try {
         validator.validateKey(key);
       } catch (error) {
-        const err = error;
-        throw new Error(`${err.message}\nPath: ${[...currentPath, key].join('.')}`);
+        throw new Error(`${error.message}\nPath: ${[...path, key].join('.')}`);
       }
       const val = value[key];
       try {
         validator.validateValue(val);
       } catch (error) {
-        const err = error;
-        throw new Error(`${err.message}\nPath: ${[...currentPath, key].join('.')}`);
+        throw new Error(`${error.message}\nPath: ${[...path, key].join('.')}`);
       }
-      validate(val, [...currentPath, key]);
+      validate(val, [...path, key]);
     }
   }
-  validate(obj, path);
+  validate(obj, []);
 }
-function createEqualityFn(useShallowComparison) {
-  return useShallowComparison ? Object.is : deepEqual;
+function makeNodeAccessor(store) {
+  const accessor = function (arg) {
+    if (arguments.length === 0) {
+      return unwrap(store);
+    }
+    if (typeof arg === 'function') {
+      const updater = arg;
+      const current = unwrap(store);
+      recursiveUpdate(store, updater(current));
+    } else {
+      recursiveUpdate(store, arg);
+    }
+  };
+  accessor[NODE_ACCESSOR_SYMBOL] = true;
+  for (const key of Object.keys(store)) {
+    Object.defineProperty(accessor, key, {
+      value: store[key],
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return accessor;
+}
+function recursiveUpdate(target, updates) {
+  if (!updates || typeof updates !== 'object') return;
+  const targetObj = isNodeAccessor(target) ? target : target;
+  for (const [key, value] of Object.entries(updates)) {
+    const prop = targetObj[key];
+    if (prop === undefined) continue;
+    if (isSignal(prop) && 'set' in prop) {
+      prop.set(value);
+    } else if (isNodeAccessor(prop)) {
+      if (value && typeof value === 'object') {
+        recursiveUpdate(prop, value);
+      } else {
+        prop(value);
+      }
+    }
+  }
 }
 function createSignalStore(obj, equalityFn) {
   if (obj === null || obj === undefined || typeof obj !== 'object') {
@@ -173,355 +136,53 @@ function createSignalStore(obj, 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 (isEntityMapMarker(value)) {
-          store[key] = value;
-          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
-        });
-      }
-    }
-    const symbols = Object.getOwnPropertySymbols(obj);
-    for (const sym of symbols) {
-      const value = obj[sym];
-      try {
-        if (isEntityMapMarker(value)) {
-          store[sym] = value;
-          continue;
-        }
-        if (isSignal(value)) {
-          store[sym] = value;
-        } else {
-          store[sym] = signal(value, {
-            equal: equalityFn
-          });
-        }
-      } catch (error) {
-        console.warn(SIGNAL_TREE_MESSAGES.SIGNAL_CREATION_FAILED, error);
-      }
-    }
-  } catch (error) {
-    throw new Error(`Failed to create signal store: ${error instanceof Error ? error.message : 'Unknown error'}`);
-  }
-  return store;
-}
-function isEntityMapMarker(value) {
-  return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === true);
-}
-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);
-      }
-    } 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);
-    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);
+  for (const [key, value] of Object.entries(obj)) {
+    if (isEntityMapMarker(value)) {
+      store[key] = value;
+      continue;
     }
-  };
-  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);
-      }
+    if (isSignal(value)) {
+      store[key] = value;
+      continue;
     }
-  };
-  tree.subscribe = fn => {
-    try {
-      const destroyRef = inject(DestroyRef);
-      let isDestroyed = false;
-      const effectRef = effect(() => {
-        if (!isDestroyed) {
-          fn(tree());
-        }
+    if (value === null || value === undefined || typeof value !== 'object') {
+      store[key] = signal(value, {
+        equal: equalityFn
       });
-      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);
-      }
-      throw error;
-    }
-  };
-  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);
+      continue;
     }
-  };
-  tree.invalidatePattern = () => {
-    if (config.debugMode) {
-      console.warn(SIGNAL_TREE_MESSAGES.PERFORMANCE_NOT_ENABLED);
+    if (Array.isArray(value) || isBuiltInObject(value)) {
+      store[key] = signal(value, {
+        equal: equalityFn
+      });
+      continue;
     }
-    return 0;
-  };
-  const treeWithEngine = tree;
-  if (!treeWithEngine.updateEngine) {
-    treeWithEngine.updateEngine = new OptimizedUpdateEngine(tree);
+    const nested = createSignalStore(value, equalityFn);
+    store[key] = makeNodeAccessor(nested);
   }
-  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.entities = () => {
-    console.warn('[@signaltree/core] tree.entities() is deprecated and will be removed in v6.0. ' + 'Use entityMap<E>() + withEntities() + tree.$.collectionName instead. ' + 'See https://signaltree.dev/docs/migration for migration guide.');
-    if (config.debugMode) {
-      console.warn(SIGNAL_TREE_MESSAGES.ENTITY_HELPERS_NOT_AVAILABLE);
-    }
-    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);
-    }
-  };
+  return store;
 }
-function create(obj, config = {}) {
-  if (obj === null || obj === undefined) {
+function create(initialState, config) {
+  if (initialState === null || initialState === undefined) {
     throw new Error(SIGNAL_TREE_MESSAGES.NULL_OR_UNDEFINED);
   }
-  validateTree(obj, config);
-  const estimatedSize = estimateObjectSize(obj);
+  validateTree(initialState, config);
   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;
-  }
-  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)));
-  }
+  const estimatedSize = estimateObjectSize(initialState);
+  const useLazy = shouldUseLazy(initialState, config, estimatedSize);
   let signalState;
   let memoryManager;
-  try {
-    if (useLazy && typeof obj === 'object') {
+  if (useLazy && typeof initialState === 'object') {
+    try {
       memoryManager = new SignalMemoryManager();
-      signalState = createLazySignalTree(obj, equalityFn, '', memoryManager);
-    } else {
-      signalState = createSignalStore(obj, equalityFn);
-    }
-  } catch (error) {
-    if (useLazy) {
+      signalState = createLazySignalTree(initialState, equalityFn, '', memoryManager);
+    } catch (error) {
       console.warn(SIGNAL_TREE_MESSAGES.LAZY_FALLBACK, error);
-      signalState = createSignalStore(obj, equalityFn);
+      signalState = createSignalStore(initialState, equalityFn);
       memoryManager = undefined;
-    } else {
-      throw error;
     }
+  } else {
+    signalState = createSignalStore(initialState, equalityFn);
   }
   const tree = function (arg) {
     if (arguments.length === 0) {
@@ -529,89 +190,88 @@ function create(obj, config = {}) {
     }
     if (typeof arg === 'function') {
       const updater = arg;
-      const currentValue = unwrap(signalState);
-      const newValue = updater(currentValue);
-      recursiveUpdate(signalState, newValue);
+      const current = unwrap(signalState);
+      recursiveUpdate(signalState, updater(current));
     } else {
       recursiveUpdate(signalState, arg);
     }
   };
-  Object.defineProperty(tree, NODE_ACCESSOR_SYMBOL, {
-    value: true,
-    enumerable: false
-  });
+  tree[NODE_ACCESSOR_SYMBOL] = true;
   Object.defineProperty(tree, 'state', {
     value: signalState,
-    enumerable: false
+    enumerable: false,
+    writable: false
   });
   Object.defineProperty(tree, '$', {
     value: signalState,
-    enumerable: false
+    enumerable: false,
+    writable: 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 {}
+  Object.defineProperty(tree, 'with', {
+    value: function (enhancer) {
+      if (typeof enhancer !== 'function') {
+        throw new Error('Enhancer must be a function');
+      }
+      return enhancer(tree);
+    },
+    enumerable: false,
+    writable: false
+  });
+  Object.defineProperty(tree, 'bind', {
+    value: function (thisArg) {
+      return Function.prototype.bind.call(tree, thisArg);
+    },
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(tree, 'destroy', {
+    value: function () {
+      if (memoryManager) {
+        memoryManager.dispose();
+      }
+      if (config.debugMode) {
+        console.log(SIGNAL_TREE_MESSAGES.TREE_DESTROYED);
+      }
+    },
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(tree, 'clearCache', {
+    value: () => {},
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(tree, 'batchUpdate', {
+    value: function (arg) {
+      if (arguments.length === 0) return;
+      if (typeof arg === 'function') {
+        const updater = arg;
+        const current = unwrap(signalState);
+        recursiveUpdate(signalState, updater(current));
+      } else {
+        recursiveUpdate(signalState, arg);
       }
+    },
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
+  for (const key of Object.keys(signalState)) {
+    if (!(key in tree)) {
+      Object.defineProperty(tree, key, {
+        value: signalState[key],
+        enumerable: true,
+        configurable: true
+      });
     }
   }
   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
-  }
-};
-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);
-  }
-  const config = configOrPreset || {};
-  return create(obj, config);
+function signalTree(initialState, config = {}) {
+  return create(initialState, config);
 }
 
 export { isNodeAccessor, signalTree };