@signaltree/core 6.0.0 → 6.0.1

package/dist/lib/memory/memory-manager.js

@@ -0,0 +1,164 @@
+class SignalMemoryManager {
+  cache = new Map();
+  registry = null;
+  config;
+  stats = {
+    cleanedUpSignals: 0,
+    peakCachedSignals: 0,
+    manualDisposes: 0
+  };
+  constructor(config = {}) {
+    this.config = {
+      enableAutoCleanup: config.enableAutoCleanup ?? true,
+      debugMode: config.debugMode ?? false,
+      onCleanup: config.onCleanup ?? (() => {})
+    };
+    if (this.config.enableAutoCleanup && typeof FinalizationRegistry !== 'undefined') {
+      this.registry = new FinalizationRegistry(path => {
+        this.handleCleanup(path);
+      });
+    }
+    if (this.config.debugMode) {
+      console.log('[SignalMemoryManager] Initialized', {
+        autoCleanup: this.config.enableAutoCleanup,
+        hasRegistry: !!this.registry
+      });
+    }
+  }
+  cacheSignal(path, signal) {
+    const ref = new WeakRef(signal);
+    const entry = {
+      ref,
+      path,
+      cachedAt: Date.now()
+    };
+    this.cache.set(path, entry);
+    if (this.registry) {
+      this.registry.register(signal, path, signal);
+    }
+    const currentSize = this.cache.size;
+    if (currentSize > this.stats.peakCachedSignals) {
+      this.stats.peakCachedSignals = currentSize;
+    }
+    if (this.config.debugMode) {
+      console.log(`[SignalMemoryManager] Cached signal: ${path}`, {
+        cacheSize: currentSize,
+        peak: this.stats.peakCachedSignals
+      });
+    }
+  }
+  getSignal(path) {
+    const entry = this.cache.get(path);
+    if (!entry) {
+      return undefined;
+    }
+    const signal = entry.ref.deref();
+    if (!signal) {
+      this.cache.delete(path);
+      if (this.config.debugMode) {
+        console.log(`[SignalMemoryManager] Signal GC'd: ${path}`);
+      }
+      return undefined;
+    }
+    return signal;
+  }
+  hasSignal(path) {
+    return this.cache.has(path);
+  }
+  removeSignal(path) {
+    const entry = this.cache.get(path);
+    if (!entry) {
+      return false;
+    }
+    const signal = entry.ref.deref();
+    if (signal && this.registry) {
+      this.registry.unregister(signal);
+    }
+    this.cache.delete(path);
+    if (this.config.debugMode) {
+      console.log(`[SignalMemoryManager] Removed signal: ${path}`);
+    }
+    return true;
+  }
+  handleCleanup(path) {
+    this.cache.delete(path);
+    this.stats.cleanedUpSignals++;
+    const currentStats = this.getStats();
+    if (this.config.debugMode) {
+      console.log(`[SignalMemoryManager] Auto cleanup: ${path}`, currentStats);
+    }
+    this.config.onCleanup(path, currentStats);
+  }
+  getStats() {
+    let validSignals = 0;
+    for (const [path, entry] of this.cache.entries()) {
+      if (entry.ref.deref()) {
+        validSignals++;
+      } else {
+        this.cache.delete(path);
+      }
+    }
+    const estimatedMemoryBytes = validSignals * 100;
+    return {
+      cachedSignals: validSignals,
+      cleanedUpSignals: this.stats.cleanedUpSignals,
+      peakCachedSignals: this.stats.peakCachedSignals,
+      manualDisposes: this.stats.manualDisposes,
+      estimatedMemoryBytes
+    };
+  }
+  dispose() {
+    if (this.config.debugMode) {
+      console.log('[SignalMemoryManager] Disposing', {
+        cachedSignals: this.cache.size
+      });
+    }
+    if (this.registry) {
+      for (const entry of this.cache.values()) {
+        const signal = entry.ref.deref();
+        if (signal) {
+          this.registry.unregister(signal);
+        }
+      }
+    }
+    this.cache.clear();
+    this.stats.manualDisposes++;
+    if (this.config.debugMode) {
+      console.log('[SignalMemoryManager] Disposed', this.getStats());
+    }
+  }
+  getCachedPaths() {
+    const paths = [];
+    for (const [path, entry] of this.cache.entries()) {
+      if (entry.ref.deref()) {
+        paths.push(path);
+      }
+    }
+    return paths;
+  }
+  clearStale() {
+    let removed = 0;
+    for (const [path, entry] of this.cache.entries()) {
+      if (!entry.ref.deref()) {
+        this.cache.delete(path);
+        removed++;
+      }
+    }
+    if (this.config.debugMode && removed > 0) {
+      console.log(`[SignalMemoryManager] Cleared ${removed} stale entries`);
+    }
+    return removed;
+  }
+  resetStats() {
+    this.stats = {
+      cleanedUpSignals: 0,
+      peakCachedSignals: 0,
+      manualDisposes: 0
+    };
+    if (this.config.debugMode) {
+      console.log('[SignalMemoryManager] Stats reset');
+    }
+  }
+}
+
+export { SignalMemoryManager };

package/dist/lib/path-notifier.js

@@ -0,0 +1,106 @@
+class PathNotifier {
+  subscribers = new Map();
+  interceptors = new Map();
+  subscribe(pattern, handler) {
+    if (!this.subscribers.has(pattern)) {
+      this.subscribers.set(pattern, new Set());
+    }
+    const handlers = this.subscribers.get(pattern);
+    if (!handlers) {
+      return () => {};
+    }
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.subscribers.delete(pattern);
+      }
+    };
+  }
+  intercept(pattern, interceptor) {
+    if (!this.interceptors.has(pattern)) {
+      this.interceptors.set(pattern, new Set());
+    }
+    const interceptors = this.interceptors.get(pattern);
+    if (!interceptors) {
+      return () => {};
+    }
+    interceptors.add(interceptor);
+    return () => {
+      interceptors.delete(interceptor);
+      if (interceptors.size === 0) {
+        this.interceptors.delete(pattern);
+      }
+    };
+  }
+  notify(path, value, prev) {
+    let blocked = false;
+    let transformed = value;
+    for (const [pattern, interceptorSet] of this.interceptors) {
+      if (this.matches(pattern, path)) {
+        for (const interceptor of interceptorSet) {
+          const result = interceptor(transformed, prev, path);
+          if (result.block) {
+            blocked = true;
+          }
+          if (result.transform !== undefined) {
+            transformed = result.transform;
+          }
+        }
+      }
+    }
+    if (blocked) {
+      return {
+        blocked: true,
+        value: prev
+      };
+    }
+    for (const [pattern, handlers] of this.subscribers) {
+      if (this.matches(pattern, path)) {
+        for (const handler of handlers) {
+          handler(transformed, prev, path);
+        }
+      }
+    }
+    return {
+      blocked: false,
+      value: transformed
+    };
+  }
+  matches(pattern, path) {
+    if (pattern === '**') return true;
+    if (pattern === path) return true;
+    if (pattern.endsWith('.*')) {
+      const prefix = pattern.slice(0, -2);
+      return path.startsWith(prefix + '.');
+    }
+    return false;
+  }
+  clear() {
+    this.subscribers.clear();
+    this.interceptors.clear();
+  }
+  getSubscriberCount() {
+    let count = 0;
+    for (const handlers of this.subscribers.values()) {
+      count += handlers.size;
+    }
+    return count;
+  }
+  getInterceptorCount() {
+    let count = 0;
+    for (const interceptors of this.interceptors.values()) {
+      count += interceptors.size;
+    }
+    return count;
+  }
+}
+let globalPathNotifier = null;
+function getPathNotifier() {
+  if (!globalPathNotifier) {
+    globalPathNotifier = new PathNotifier();
+  }
+  return globalPathNotifier;
+}
+
+export { PathNotifier, getPathNotifier };

package/dist/lib/presets.js

@@ -0,0 +1,21 @@
+import { signalTree } from './signal-tree.js';
+import { effects } from '../enhancers/effects/effects.js';
+import { batching } from '../enhancers/batching/batching.js';
+import { memoization } from '../enhancers/memoization/memoization.js';
+import { entities } from '../enhancers/entities/entities.js';
+import { timeTravel } from '../enhancers/time-travel/time-travel.js';
+import { devTools } from '../enhancers/devtools/devtools.js';
+
+function createDevTree(initialState, config = {}) {
+  if (arguments.length === 0) {
+    const enhancer = tree => tree.with(effects()).with(batching()).with(memoization()).with(entities()).with(timeTravel()).with(devTools());
+    return {
+      enhancer
+    };
+  }
+  const base = signalTree(initialState, config);
+  const enhanced = base.with(effects()).with(batching(config.batching)).with(memoization(config.memoization)).with(entities()).with(timeTravel(config.timeTravel)).with(devTools(config.devTools));
+  return enhanced;
+}
+
+export { createDevTree };

package/dist/lib/security/security-validator.js

@@ -0,0 +1,121 @@
+const DANGEROUS_KEYS = ['__proto__', 'constructor', 'prototype'];
+const HTML_TAG_PATTERN = /<[^>]*>/g;
+const DANGEROUS_HTML_PATTERNS = [/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, /on\w+\s*=/gi, /javascript:/gi, /<iframe\b/gi, /<object\b/gi, /<embed\b/gi];
+class SecurityValidator {
+  config;
+  dangerousKeys;
+  constructor(config = {}) {
+    this.config = {
+      preventPrototypePollution: config.preventPrototypePollution ?? true,
+      preventXSS: config.preventXSS ?? false,
+      preventFunctions: config.preventFunctions ?? true,
+      customDangerousKeys: config.customDangerousKeys ?? [],
+      onSecurityEvent: config.onSecurityEvent ?? (() => {}),
+      sanitizationMode: config.sanitizationMode ?? 'strict'
+    };
+    this.dangerousKeys = new Set([...DANGEROUS_KEYS, ...this.config.customDangerousKeys]);
+  }
+  validateKey(key) {
+    if (!this.config.preventPrototypePollution) {
+      return;
+    }
+    if (this.dangerousKeys.has(key)) {
+      const event = {
+        type: 'dangerous-key-blocked',
+        key,
+        reason: `Dangerous key "${key}" blocked to prevent prototype pollution`,
+        timestamp: Date.now()
+      };
+      this.config.onSecurityEvent(event);
+      throw new Error(`[SignalTree Security] Dangerous key "${key}" is not allowed. ` + `This key can lead to prototype pollution attacks. ` + `Blocked keys: ${Array.from(this.dangerousKeys).join(', ')}`);
+    }
+  }
+  validateValue(value) {
+    if (this.config.preventFunctions && typeof value === 'function') {
+      const event = {
+        type: 'function-value-blocked',
+        value,
+        reason: 'Function values are not allowed - state must be serializable',
+        timestamp: Date.now()
+      };
+      this.config.onSecurityEvent(event);
+      throw new Error(`[SignalTree Security] Function values are not allowed in state trees. ` + `Functions cannot be serialized, breaking features like time-travel, ` + `persistence, debugging, and SSR. ` + `\n\nTo fix this:` + `\n  - Store function references outside the tree` + `\n  - Use method names (strings) and a function registry` + `\n  - Use computed signals for derived values` + `\n\nBlocked value: ${value.toString().substring(0, 100)}...`);
+    }
+    if (!this.config.preventXSS || typeof value !== 'string') {
+      return value;
+    }
+    let hasDangerousPattern = false;
+    for (const pattern of DANGEROUS_HTML_PATTERNS) {
+      pattern.lastIndex = 0;
+      if (pattern.test(value)) {
+        hasDangerousPattern = true;
+        break;
+      }
+    }
+    if (hasDangerousPattern) {
+      const event = {
+        type: 'xss-attempt-blocked',
+        value,
+        reason: 'Dangerous HTML pattern detected and sanitized',
+        timestamp: Date.now()
+      };
+      this.config.onSecurityEvent(event);
+      return this.sanitize(value);
+    }
+    return this.sanitize(value);
+  }
+  sanitize(value) {
+    if (this.config.sanitizationMode === 'strict') {
+      let sanitized = value;
+      for (const pattern of DANGEROUS_HTML_PATTERNS) {
+        pattern.lastIndex = 0;
+        sanitized = sanitized.replace(pattern, '');
+      }
+      return sanitized.replace(HTML_TAG_PATTERN, '');
+    } else {
+      let sanitized = value;
+      for (const pattern of DANGEROUS_HTML_PATTERNS) {
+        pattern.lastIndex = 0;
+        sanitized = sanitized.replace(pattern, '');
+      }
+      return sanitized;
+    }
+  }
+  validateKeyValue(key, value) {
+    this.validateKey(key);
+    return this.validateValue(value);
+  }
+  isDangerousKey(key) {
+    return this.dangerousKeys.has(key);
+  }
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+}
+const SecurityPresets = {
+  strict: () => new SecurityValidator({
+    preventPrototypePollution: true,
+    preventXSS: true,
+    preventFunctions: true,
+    sanitizationMode: 'strict'
+  }),
+  standard: () => new SecurityValidator({
+    preventPrototypePollution: true,
+    preventXSS: false,
+    preventFunctions: true
+  }),
+  permissive: () => new SecurityValidator({
+    preventPrototypePollution: true,
+    preventXSS: false,
+    preventFunctions: false
+  }),
+  disabled: () => new SecurityValidator({
+    preventPrototypePollution: false,
+    preventXSS: false,
+    preventFunctions: false
+  })
+};
+
+export { SecurityPresets, SecurityValidator };

package/dist/lib/signal-tree.js

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

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