@signaltree/core 6.2.0 → 6.2.1

package/dist/lib/signal-tree.js

@@ -1,277 +0,0 @@
-import { signal, isSignal } from '@angular/core';
-import { SIGNAL_TREE_MESSAGES, SIGNAL_TREE_CONSTANTS } from './constants.js';
-import { SignalMemoryManager } from './memory/memory-manager.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('SignalTree:NodeAccessor');
-function isNodeAccessor(value) {
-  return typeof value === 'function' && value[NODE_ACCESSOR_SYMBOL] === true;
-}
-function isEntityMapMarker(value) {
-  return Boolean(value && typeof value === 'object' && value['__isEntityMap'] === 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;
-  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;
-  }
-  return Math.floor(size);
-}
-function shouldUseLazy(obj, config, precomputedSize) {
-  if (config.useLazySignals !== undefined) return config.useLazySignals;
-  if (config.debugMode || config.enableDevTools) return false;
-  const estimatedSize = precomputedSize ?? estimateObjectSize(obj);
-  return estimatedSize > SIGNAL_TREE_CONSTANTS.LAZY_THRESHOLD;
-}
-function validateTree(obj, config) {
-  if (!config.security) return;
-  const validator = new SecurityValidator(config.security);
-  function validate(value, path) {
-    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, i) => validate(item, [...path, String(i)]));
-      return;
-    }
-    for (const key of Object.keys(value)) {
-      try {
-        validator.validateKey(key);
-      } catch (error) {
-        throw new Error(`${error.message}\nPath: ${[...path, key].join('.')}`);
-      }
-      const val = value[key];
-      try {
-        validator.validateValue(val);
-      } catch (error) {
-        throw new Error(`${error.message}\nPath: ${[...path, key].join('.')}`);
-      }
-      validate(val, [...path, key]);
-    }
-  }
-  validate(obj, []);
-}
-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') {
-    return signal(obj, {
-      equal: equalityFn
-    });
-  }
-  if (Array.isArray(obj)) {
-    return signal(obj, {
-      equal: equalityFn
-    });
-  }
-  if (isBuiltInObject(obj)) {
-    return signal(obj, {
-      equal: equalityFn
-    });
-  }
-  const store = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (isEntityMapMarker(value)) {
-      store[key] = value;
-      continue;
-    }
-    if (isSignal(value)) {
-      store[key] = value;
-      continue;
-    }
-    if (value === null || value === undefined || typeof value !== 'object') {
-      store[key] = signal(value, {
-        equal: equalityFn
-      });
-      continue;
-    }
-    if (Array.isArray(value) || isBuiltInObject(value)) {
-      store[key] = signal(value, {
-        equal: equalityFn
-      });
-      continue;
-    }
-    const nested = createSignalStore(value, equalityFn);
-    store[key] = makeNodeAccessor(nested);
-  }
-  return store;
-}
-function create(initialState, config) {
-  if (initialState === null || initialState === undefined) {
-    throw new Error(SIGNAL_TREE_MESSAGES.NULL_OR_UNDEFINED);
-  }
-  validateTree(initialState, config);
-  const equalityFn = createEqualityFn(config.useShallowComparison ?? false);
-  const estimatedSize = estimateObjectSize(initialState);
-  const useLazy = shouldUseLazy(initialState, config, estimatedSize);
-  let signalState;
-  let memoryManager;
-  if (useLazy && typeof initialState === 'object') {
-    try {
-      memoryManager = new SignalMemoryManager();
-      signalState = createLazySignalTree(initialState, equalityFn, '', memoryManager);
-    } catch (error) {
-      console.warn(SIGNAL_TREE_MESSAGES.LAZY_FALLBACK, error);
-      signalState = createSignalStore(initialState, equalityFn);
-      memoryManager = undefined;
-    }
-  } else {
-    signalState = createSignalStore(initialState, equalityFn);
-  }
-  const tree = function (arg) {
-    if (arguments.length === 0) {
-      return unwrap(signalState);
-    }
-    if (typeof arg === 'function') {
-      const updater = arg;
-      const current = unwrap(signalState);
-      recursiveUpdate(signalState, updater(current));
-    } else {
-      recursiveUpdate(signalState, arg);
-    }
-  };
-  tree[NODE_ACCESSOR_SYMBOL] = true;
-  Object.defineProperty(tree, 'state', {
-    value: signalState,
-    enumerable: false,
-    writable: false
-  });
-  Object.defineProperty(tree, '$', {
-    value: signalState,
-    enumerable: false,
-    writable: false
-  });
-  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;
-}
-function signalTree(initialState, config = {}) {
-  return create(initialState, config);
-}
-
-export { isNodeAccessor, signalTree };

package/dist/lib/types.js

@@ -1,9 +0,0 @@
-function entityMap(config) {
-  return {
-    __isEntityMap: true,
-    __entityMapConfig: config ?? {}
-  };
-}
-const ENHANCER_META = Symbol('signaltree:enhancer:meta');
-
-export { ENHANCER_META, entityMap };

package/dist/lib/utils.js

@@ -1,264 +0,0 @@
-import { isSignal, signal, runInInjectionContext, effect } from '@angular/core';
-import { isBuiltInObject } from '../is-built-in-object.js';
-
-const CALLABLE_SIGNAL_SYMBOL = Symbol.for('SignalTree:NodeAccessor');
-function isEntityMapMarker(value) {
-  return Boolean(value && typeof value === 'object' && value.__isEntityMap === true);
-}
-function isNodeAccessor(value) {
-  return typeof value === 'function' && value && CALLABLE_SIGNAL_SYMBOL in value;
-}
-function isAnySignal(value) {
-  return isSignal(value) || isNodeAccessor(value);
-}
-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;
-}
-function composeEnhancers(...enhancers) {
-  return tree => enhancers.reduce((t, e) => e(t), tree);
-}
-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 (value && typeof value === 'object' && typeof value.addOne === 'function' && typeof value.all === 'function') {
-        return value;
-      }
-      if (isEntityMapMarker(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 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 === '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;
-      }
-    }
-    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;
-}
-function snapshotState(state) {
-  return unwrap(state);
-}
-
-export { composeEnhancers, createLazySignalTree, isAnySignal, isBuiltInObject, isEntityMapMarker, isNodeAccessor, snapshotState, toWritableSignal, unwrap };

package/dist/lru-cache.js

@@ -1,64 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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 };

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

@@ -1,10 +0,0 @@
-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;
-export declare const withBatching: ((config?: BatchingConfig) => <T>(tree: ISignalTree<T>) => ISignalTree<T> & BatchingMethods<T>) & {
-    highPerformance: typeof highPerformanceBatching;
-};

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

@@ -1 +0,0 @@
-export {};

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

@@ -1 +0,0 @@
-export * from './batching';

package/src/enhancers/batching/test-setup.d.ts

@@ -1,3 +0,0 @@
-import '@angular/compiler';
-import 'zone.js';
-import 'zone.js/testing';