@signaltree/core 4.0.15 → 4.1.0

package/dist/lib/types.js

@@ -1,9 +1,3 @@
-export const ENHANCER_META = Symbol('signaltree:enhancer:meta');
-export function isSignalTree(value) {
-    return (value !== null &&
-        typeof value === 'function' &&
-        'state' in value &&
-        '$' in value &&
-        'with' in value &&
-        'destroy' in value);
-}
+const ENHANCER_META = Symbol('signaltree:enhancer:meta');
+
+export { ENHANCER_META };

package/dist/lib/utils.js

@@ -1,286 +1,254 @@
-import { isSignal, signal } from '@angular/core';
-import { deepEqual, isBuiltInObject, parsePath } from '@signaltree/shared';
+import { isSignal, signal, runInInjectionContext, effect } from '@angular/core';
+import { isBuiltInObject } from '../is-built-in-object.js';
+
 const CALLABLE_SIGNAL_SYMBOL = Symbol.for('NodeAccessor');
-export { deepEqual };
-export { deepEqual as equal };
-export { isBuiltInObject };
-export { parsePath };
-export function isNodeAccessor(value) {
-    return (typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value);
+function isNodeAccessor(value) {
+  return typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value;
 }
-export function isAnySignal(value) {
-    return isSignal(value) || isNodeAccessor(value);
+function isAnySignal(value) {
+  return isSignal(value) || isNodeAccessor(value);
 }
-export function composeEnhancers(...enhancers) {
-    return (tree) => enhancers.reduce((t, e) => e(t), tree);
+function toWritableSignal(node, injector) {
+  const sig = signal(node());
+  const originalSet = sig.set.bind(sig);
+  const runner = () => {
+    originalSet(node());
+  };
+  if (injector) {
+    runInInjectionContext(injector, () => effect(runner));
+  } else {
+    try {
+      effect(runner);
+    } catch {
+      console.warn('[SignalTree] toWritableSignal called without injection context; pass Injector for reactivity.');
+    }
+  }
+  sig.set = value => {
+    node(value);
+    originalSet(value);
+  };
+  sig.update = updater => {
+    sig.set(updater(sig()));
+  };
+  return sig;
 }
-export function createLazySignalTree(obj, equalityFn, basePath = '', memoryManager) {
-    const signalCache = new Map();
-    const nestedProxies = new Map();
-    const nestedCleanups = new Map();
-    const cleanup = () => {
-        nestedCleanups.forEach((fn) => {
-            try {
-                fn();
-            }
-            catch (error) {
-                console.warn('Error during nested cleanup:', error);
-            }
-        });
-        nestedCleanups.clear();
-        signalCache.clear();
-        nestedProxies.clear();
-        if (memoryManager) {
-            memoryManager.dispose();
-        }
-    };
-    const proxy = new Proxy(obj, {
-        get(target, prop) {
-            if (prop === '__cleanup__')
-                return cleanup;
-            if (typeof prop === 'symbol') {
-                return target[prop];
-            }
-            if (prop === 'valueOf' || prop === 'toString') {
-                return target[prop];
-            }
-            const key = prop;
-            const path = basePath ? `${basePath}.${key}` : key;
-            if (!(key in target))
-                return undefined;
-            const value = target[key];
-            if (isSignal(value))
-                return value;
-            if (memoryManager) {
-                const cached = memoryManager.getSignal(path);
-                if (cached)
-                    return cached;
-            }
-            if (signalCache.has(path))
-                return signalCache.get(path);
-            if (nestedProxies.has(path))
-                return nestedProxies.get(path);
-            if (value &&
-                typeof value === 'object' &&
-                !Array.isArray(value) &&
-                !isSignal(value) &&
-                !isBuiltInObject(value)) {
-                try {
-                    const nestedProxy = createLazySignalTree(value, equalityFn, path, memoryManager);
-                    nestedProxies.set(path, nestedProxy);
-                    const proxyWithCleanup = nestedProxy;
-                    if (typeof proxyWithCleanup.__cleanup__ === 'function') {
-                        nestedCleanups.set(path, proxyWithCleanup.__cleanup__);
-                    }
-                    return nestedProxy;
-                }
-                catch (error) {
-                    console.warn(`Failed to create lazy proxy for path "${path}":`, error);
-                    const fallbackSignal = signal(value, { equal: equalityFn });
-                    signalCache.set(path, fallbackSignal);
-                    if (memoryManager) {
-                        memoryManager.cacheSignal(path, fallbackSignal);
-                    }
-                    return fallbackSignal;
-                }
-            }
-            try {
-                const newSignal = signal(value, { equal: equalityFn });
-                signalCache.set(path, newSignal);
-                if (memoryManager) {
-                    memoryManager.cacheSignal(path, newSignal);
-                }
-                return newSignal;
-            }
-            catch (error) {
-                console.warn(`Failed to create signal for path "${path}":`, error);
-                return value;
-            }
-        },
-        set(target, prop, value) {
-            if (typeof prop === 'symbol') {
-                target[prop] = value;
-                return true;
-            }
-            const key = prop;
-            const path = basePath ? `${basePath}.${key}` : key;
-            try {
-                target[key] = value;
-                const cachedSignal = signalCache.get(path);
-                if (cachedSignal && 'set' in cachedSignal) {
-                    cachedSignal.set(value);
-                }
-                if (nestedProxies.has(path)) {
-                    const nestedCleanup = nestedCleanups.get(path);
-                    if (nestedCleanup) {
-                        nestedCleanup();
-                        nestedCleanups.delete(path);
-                    }
-                    nestedProxies.delete(path);
-                }
-                return true;
-            }
-            catch (error) {
-                console.warn(`Failed to set value for path "${path}":`, error);
-                return false;
-            }
-        },
-        has(target, prop) {
-            return prop in target;
-        },
-        ownKeys(target) {
-            return Reflect.ownKeys(target);
-        },
-        getOwnPropertyDescriptor(target, prop) {
-            return Reflect.getOwnPropertyDescriptor(target, prop);
-        },
-    });
-    return proxy;
+function composeEnhancers(...enhancers) {
+  return tree => enhancers.reduce((t, e) => e(t), tree);
 }
-export function unwrap(node) {
-    if (node === null || node === undefined) {
-        return node;
+function createLazySignalTree(obj, equalityFn, basePath = '', memoryManager) {
+  const signalCache = new Map();
+  const nestedProxies = new Map();
+  const nestedCleanups = new Map();
+  const cleanup = () => {
+    nestedCleanups.forEach(fn => {
+      try {
+        fn();
+      } catch (error) {
+        console.warn('Error during nested cleanup:', error);
+      }
+    });
+    nestedCleanups.clear();
+    signalCache.clear();
+    nestedProxies.clear();
+    if (memoryManager) {
+      memoryManager.dispose();
     }
-    if (isNodeAccessor(node)) {
-        const result = {};
-        for (const key in node) {
-            if (!Object.prototype.hasOwnProperty.call(node, key))
-                continue;
-            if (key === 'length' || key === 'prototype')
-                continue;
-            if (key === 'name') {
-                const value = node[key];
-                if (!isSignal(value) && !isNodeAccessor(value)) {
-                    continue;
-                }
-            }
-            const value = node[key];
-            if (isNodeAccessor(value)) {
-                result[key] = unwrap(value);
-            }
-            else if (isSignal(value)) {
-                const unwrappedValue = value();
-                if (typeof unwrappedValue === 'object' &&
-                    unwrappedValue !== null &&
-                    !Array.isArray(unwrappedValue) &&
-                    !isBuiltInObject(unwrappedValue)) {
-                    result[key] = unwrap(unwrappedValue);
-                }
-                else {
-                    result[key] = unwrappedValue;
-                }
-            }
-            else if (typeof value === 'object' &&
-                value !== null &&
-                !Array.isArray(value) &&
-                !isBuiltInObject(value)) {
-                result[key] = unwrap(value);
-            }
-            else {
-                result[key] = value;
-            }
+  };
+  const proxy = new Proxy(obj, {
+    get(target, prop) {
+      if (prop === '__cleanup__') return cleanup;
+      if (typeof prop === 'symbol') {
+        return target[prop];
+      }
+      if (prop === 'valueOf' || prop === 'toString') {
+        return target[prop];
+      }
+      const key = prop;
+      const path = basePath ? `${basePath}.${key}` : key;
+      if (!(key in target)) return undefined;
+      const value = target[key];
+      if (isSignal(value)) return value;
+      if (memoryManager) {
+        const cached = memoryManager.getSignal(path);
+        if (cached) return cached;
+      }
+      if (signalCache.has(path)) return signalCache.get(path);
+      if (nestedProxies.has(path)) return nestedProxies.get(path);
+      if (value && typeof value === 'object' && !Array.isArray(value) && !isSignal(value) && !isBuiltInObject(value)) {
+        try {
+          const nestedProxy = createLazySignalTree(value, equalityFn, path, memoryManager);
+          nestedProxies.set(path, nestedProxy);
+          const proxyWithCleanup = nestedProxy;
+          if (typeof proxyWithCleanup.__cleanup__ === 'function') {
+            nestedCleanups.set(path, proxyWithCleanup.__cleanup__);
+          }
+          return nestedProxy;
+        } catch (error) {
+          console.warn(`Failed to create lazy proxy for path "${path}":`, error);
+          const fallbackSignal = signal(value, {
+            equal: equalityFn
+          });
+          signalCache.set(path, fallbackSignal);
+          if (memoryManager) {
+            memoryManager.cacheSignal(path, fallbackSignal);
+          }
+          return fallbackSignal;
         }
-        return result;
-    }
-    if (isSignal(node)) {
-        const value = node();
-        if (typeof value === 'object' &&
-            value !== null &&
-            !Array.isArray(value) &&
-            !isBuiltInObject(value)) {
-            return unwrap(value);
+      }
+      try {
+        const newSignal = signal(value, {
+          equal: equalityFn
+        });
+        signalCache.set(path, newSignal);
+        if (memoryManager) {
+          memoryManager.cacheSignal(path, newSignal);
         }
+        return newSignal;
+      } catch (error) {
+        console.warn(`Failed to create signal for path "${path}":`, error);
         return value;
+      }
+    },
+    set(target, prop, value) {
+      if (typeof prop === 'symbol') {
+        target[prop] = value;
+        return true;
+      }
+      const key = prop;
+      const path = basePath ? `${basePath}.${key}` : key;
+      try {
+        target[key] = value;
+        const cachedSignal = signalCache.get(path);
+        if (cachedSignal && 'set' in cachedSignal) {
+          cachedSignal.set(value);
+        }
+        if (nestedProxies.has(path)) {
+          const nestedCleanup = nestedCleanups.get(path);
+          if (nestedCleanup) {
+            nestedCleanup();
+            nestedCleanups.delete(path);
+          }
+          nestedProxies.delete(path);
+        }
+        return true;
+      } catch (error) {
+        console.warn(`Failed to set value for path "${path}":`, error);
+        return false;
+      }
+    },
+    has(target, prop) {
+      return prop in target;
+    },
+    ownKeys(target) {
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      return Reflect.getOwnPropertyDescriptor(target, prop);
     }
-    if (typeof node !== 'object') {
-        return node;
-    }
-    if (Array.isArray(node)) {
-        return node;
-    }
-    if (isBuiltInObject(node)) {
-        return node;
-    }
+  });
+  return proxy;
+}
+function unwrap(node) {
+  if (node === null || node === undefined) {
+    return node;
+  }
+  if (isNodeAccessor(node)) {
     const result = {};
     for (const key in node) {
-        if (!Object.prototype.hasOwnProperty.call(node, key))
-            continue;
-        if (key === 'set' || key === 'update') {
-            const v = node[key];
-            if (typeof v === 'function')
-                continue;
-        }
+      if (!Object.prototype.hasOwnProperty.call(node, key)) continue;
+      if (key === 'length' || key === 'prototype') continue;
+      if (key === 'name') {
         const value = node[key];
-        if (isNodeAccessor(value)) {
-            const unwrappedValue = value();
-            if (typeof unwrappedValue === 'object' &&
-                unwrappedValue !== null &&
-                !Array.isArray(unwrappedValue) &&
-                !isBuiltInObject(unwrappedValue)) {
-                result[key] = unwrap(unwrappedValue);
-            }
-            else {
-                result[key] = unwrappedValue;
-            }
-        }
-        else if (isSignal(value)) {
-            const unwrappedValue = value();
-            if (typeof unwrappedValue === 'object' &&
-                unwrappedValue !== null &&
-                !Array.isArray(unwrappedValue) &&
-                !isBuiltInObject(unwrappedValue)) {
-                result[key] = unwrap(unwrappedValue);
-            }
-            else {
-                result[key] = unwrappedValue;
-            }
-        }
-        else if (typeof value === 'object' &&
-            value !== null &&
-            !Array.isArray(value) &&
-            !isBuiltInObject(value)) {
-            result[key] = unwrap(value);
+        if (!isSignal(value) && !isNodeAccessor(value)) {
+          continue;
         }
-        else {
-            result[key] = value;
-        }
-    }
-    const symbols = Object.getOwnPropertySymbols(node);
-    for (const sym of symbols) {
-        const value = node[sym];
-        if (isNodeAccessor(value)) {
-            const unwrappedValue = value();
-            if (typeof unwrappedValue === 'object' &&
-                unwrappedValue !== null &&
-                !Array.isArray(unwrappedValue) &&
-                !isBuiltInObject(unwrappedValue)) {
-                result[sym] = unwrap(unwrappedValue);
-            }
-            else {
-                result[sym] = unwrappedValue;
-            }
-        }
-        else if (isSignal(value)) {
-            const unwrappedValue = value();
-            if (typeof unwrappedValue === 'object' &&
-                unwrappedValue !== null &&
-                !Array.isArray(unwrappedValue) &&
-                !isBuiltInObject(unwrappedValue)) {
-                result[sym] = unwrap(unwrappedValue);
-            }
-            else {
-                result[sym] = unwrappedValue;
-            }
-        }
-        else if (typeof value === 'object' &&
-            value !== null &&
-            !Array.isArray(value) &&
-            !isBuiltInObject(value)) {
-            result[sym] = unwrap(value);
-        }
-        else {
-            result[sym] = value;
+      }
+      const value = node[key];
+      if (isNodeAccessor(value)) {
+        result[key] = unwrap(value);
+      } else if (isSignal(value)) {
+        const unwrappedValue = value();
+        if (typeof unwrappedValue === 'object' && unwrappedValue !== null && !Array.isArray(unwrappedValue) && !isBuiltInObject(unwrappedValue)) {
+          result[key] = unwrap(unwrappedValue);
+        } else {
+          result[key] = unwrappedValue;
         }
+      } else if (typeof value === 'object' && value !== null && !Array.isArray(value) && !isBuiltInObject(value)) {
+        result[key] = unwrap(value);
+      } else {
+        result[key] = value;
+      }
     }
     return result;
+  }
+  if (isSignal(node)) {
+    const value = node();
+    if (typeof value === 'object' && value !== null && !Array.isArray(value) && !isBuiltInObject(value)) {
+      return unwrap(value);
+    }
+    return value;
+  }
+  if (typeof node !== 'object') {
+    return node;
+  }
+  if (Array.isArray(node)) {
+    return node;
+  }
+  if (isBuiltInObject(node)) {
+    return node;
+  }
+  const result = {};
+  for (const key in node) {
+    if (!Object.prototype.hasOwnProperty.call(node, key)) continue;
+    if (key === 'set' || key === 'update') {
+      const v = node[key];
+      if (typeof v === 'function') continue;
+    }
+    const value = node[key];
+    if (isNodeAccessor(value)) {
+      const unwrappedValue = value();
+      if (typeof unwrappedValue === 'object' && unwrappedValue !== null && !Array.isArray(unwrappedValue) && !isBuiltInObject(unwrappedValue)) {
+        result[key] = unwrap(unwrappedValue);
+      } else {
+        result[key] = unwrappedValue;
+      }
+    } else if (isSignal(value)) {
+      const unwrappedValue = value();
+      if (typeof unwrappedValue === 'object' && unwrappedValue !== null && !Array.isArray(unwrappedValue) && !isBuiltInObject(unwrappedValue)) {
+        result[key] = unwrap(unwrappedValue);
+      } else {
+        result[key] = unwrappedValue;
+      }
+    } else if (typeof value === 'object' && value !== null && !Array.isArray(value) && !isBuiltInObject(value)) {
+      result[key] = unwrap(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  const symbols = Object.getOwnPropertySymbols(node);
+  for (const sym of symbols) {
+    const value = node[sym];
+    if (isNodeAccessor(value)) {
+      const unwrappedValue = value();
+      if (typeof unwrappedValue === 'object' && unwrappedValue !== null && !Array.isArray(unwrappedValue) && !isBuiltInObject(unwrappedValue)) {
+        result[sym] = unwrap(unwrappedValue);
+      } else {
+        result[sym] = unwrappedValue;
+      }
+    } else if (isSignal(value)) {
+      const unwrappedValue = value();
+      if (typeof unwrappedValue === 'object' && unwrappedValue !== null && !Array.isArray(unwrappedValue) && !isBuiltInObject(unwrappedValue)) {
+        result[sym] = unwrap(unwrappedValue);
+      } else {
+        result[sym] = unwrappedValue;
+      }
+    } else if (typeof value === 'object' && value !== null && !Array.isArray(value) && !isBuiltInObject(value)) {
+      result[sym] = unwrap(value);
+    } else {
+      result[sym] = value;
+    }
+  }
+  return result;
 }
+
+export { composeEnhancers, createLazySignalTree, isAnySignal, isBuiltInObject, isNodeAccessor, toWritableSignal, unwrap };

package/dist/lru-cache.js

@@ -0,0 +1,64 @@
+class LRUCache {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.cache = new Map();
+    if (!Number.isFinite(maxSize) || maxSize <= 0) {
+      throw new Error('LRUCache maxSize must be a positive, finite number');
+    }
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    }
+    this.cache.set(key, value);
+    if (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.cache.delete(oldestKey);
+      }
+    }
+  }
+  get(key) {
+    if (!this.cache.has(key)) return undefined;
+    const value = this.cache.get(key);
+    if (value !== undefined) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+  forEach(callback) {
+    this.cache.forEach((value, key) => callback(value, key));
+  }
+  entries() {
+    return this.cache.entries();
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  resize(newSize) {
+    if (!Number.isFinite(newSize) || newSize <= 0) {
+      throw new Error('LRUCache newSize must be a positive, finite number');
+    }
+    this.maxSize = newSize;
+    while (this.cache.size > this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey === undefined) break;
+      this.cache.delete(oldestKey);
+    }
+  }
+}
+
+export { LRUCache };

package/dist/parse-path.js

@@ -0,0 +1,13 @@
+import { DEFAULT_PATH_CACHE_SIZE } from './constants.js';
+import { LRUCache } from './lru-cache.js';
+
+const pathCache = new LRUCache(DEFAULT_PATH_CACHE_SIZE);
+function parsePath(path) {
+  const cached = pathCache.get(path);
+  if (cached) return cached;
+  const segments = path.split('.');
+  pathCache.set(path, segments);
+  return segments;
+}
+
+export { parsePath };