@signaltree/core 6.2.1 → 6.2.2

package/dist/lib/entity-signal.js

@@ -0,0 +1,283 @@
+import { signal, computed } from '@angular/core';
+
+class EntitySignalImpl {
+  pathNotifier;
+  basePath;
+  storage = new Map();
+  allSignal;
+  countSignal;
+  idsSignal;
+  mapSignal;
+  nodeCache = new Map();
+  selectId;
+  tapHandlers = [];
+  interceptHandlers = [];
+  constructor(config, pathNotifier, basePath) {
+    this.pathNotifier = pathNotifier;
+    this.basePath = basePath;
+    this.selectId = config.selectId ?? (entity => entity['id']);
+    this.allSignal = signal([]);
+    this.countSignal = signal(0);
+    this.idsSignal = signal([]);
+    this.mapSignal = signal(new Map());
+  }
+  byId(id) {
+    const entity = this.storage.get(id);
+    if (!entity) return undefined;
+    return this.getOrCreateNode(id, entity);
+  }
+  byIdOrFail(id) {
+    const node = this.byId(id);
+    if (!node) {
+      throw new Error(`Entity with id ${String(id)} not found`);
+    }
+    return node;
+  }
+  get all() {
+    return this.allSignal;
+  }
+  get count() {
+    return this.countSignal;
+  }
+  get ids() {
+    return this.idsSignal;
+  }
+  get map() {
+    return this.mapSignal;
+  }
+  has(id) {
+    return computed(() => this.storage.has(id));
+  }
+  get isEmpty() {
+    return computed(() => this.storage.size === 0);
+  }
+  where(predicate) {
+    return computed(() => {
+      const result = [];
+      for (const entity of this.storage.values()) {
+        if (predicate(entity)) {
+          result.push(entity);
+        }
+      }
+      return result;
+    });
+  }
+  find(predicate) {
+    return computed(() => {
+      for (const entity of this.storage.values()) {
+        if (predicate(entity)) {
+          return entity;
+        }
+      }
+      return undefined;
+    });
+  }
+  addOne(entity, opts) {
+    const id = opts?.selectId?.(entity) ?? this.selectId(entity);
+    if (this.storage.has(id)) {
+      throw new Error(`Entity with id ${String(id)} already exists`);
+    }
+    let transformedEntity = entity;
+    for (const handler of this.interceptHandlers) {
+      const ctx = {
+        block: reason => {
+          throw new Error(`Cannot add entity: ${reason || 'blocked by interceptor'}`);
+        },
+        transform: value => {
+          transformedEntity = value;
+        },
+        blocked: false,
+        blockReason: undefined
+      };
+      handler.onAdd?.(entity, ctx);
+    }
+    this.storage.set(id, transformedEntity);
+    this.nodeCache.delete(id);
+    this.updateSignals();
+    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, transformedEntity, undefined);
+    for (const handler of this.tapHandlers) {
+      handler.onAdd?.(transformedEntity, id);
+    }
+    return id;
+  }
+  addMany(entities, opts) {
+    const ids = [];
+    for (const entity of entities) {
+      ids.push(this.addOne(entity, opts));
+    }
+    return ids;
+  }
+  updateOne(id, changes) {
+    const entity = this.storage.get(id);
+    if (!entity) {
+      throw new Error(`Entity with id ${String(id)} not found`);
+    }
+    const prev = entity;
+    let transformedChanges = changes;
+    for (const handler of this.interceptHandlers) {
+      const ctx = {
+        block: reason => {
+          throw new Error(`Cannot update entity: ${reason || 'blocked by interceptor'}`);
+        },
+        transform: value => {
+          transformedChanges = value;
+        },
+        blocked: false,
+        blockReason: undefined
+      };
+      handler.onUpdate?.(id, changes, ctx);
+    }
+    const finalUpdated = {
+      ...entity,
+      ...transformedChanges
+    };
+    this.storage.set(id, finalUpdated);
+    this.nodeCache.delete(id);
+    this.updateSignals();
+    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, finalUpdated, prev);
+    for (const handler of this.tapHandlers) {
+      handler.onUpdate?.(id, transformedChanges, finalUpdated);
+    }
+  }
+  updateMany(ids, changes) {
+    for (const id of ids) {
+      this.updateOne(id, changes);
+    }
+  }
+  updateWhere(predicate, changes) {
+    let count = 0;
+    for (const [id, entity] of this.storage) {
+      if (predicate(entity)) {
+        this.updateOne(id, changes);
+        count++;
+      }
+    }
+    return count;
+  }
+  removeOne(id) {
+    const entity = this.storage.get(id);
+    if (!entity) {
+      throw new Error(`Entity with id ${String(id)} not found`);
+    }
+    for (const handler of this.interceptHandlers) {
+      const ctx = {
+        block: reason => {
+          throw new Error(`Cannot remove entity: ${reason || 'blocked by interceptor'}`);
+        },
+        transform: () => {},
+        blocked: false,
+        blockReason: undefined
+      };
+      handler.onRemove?.(id, entity, ctx);
+    }
+    this.storage.delete(id);
+    this.nodeCache.delete(id);
+    this.updateSignals();
+    this.pathNotifier.notify(`${this.basePath}.${String(id)}`, undefined, entity);
+    for (const handler of this.tapHandlers) {
+      handler.onRemove?.(id, entity);
+    }
+  }
+  removeMany(ids) {
+    for (const id of ids) {
+      this.removeOne(id);
+    }
+  }
+  removeWhere(predicate) {
+    const idsToRemove = [];
+    for (const [id, entity] of this.storage) {
+      if (predicate(entity)) {
+        idsToRemove.push(id);
+      }
+    }
+    let count = 0;
+    for (const id of idsToRemove) {
+      this.removeOne(id);
+      count++;
+    }
+    return count;
+  }
+  upsertOne(entity, opts) {
+    const id = opts?.selectId?.(entity) ?? this.selectId(entity);
+    if (this.storage.has(id)) {
+      this.updateOne(id, entity);
+    } else {
+      this.addOne(entity, opts);
+    }
+    return id;
+  }
+  upsertMany(entities, opts) {
+    return entities.map(e => this.upsertOne(e, opts));
+  }
+  clear() {
+    this.storage.clear();
+    this.nodeCache.clear();
+    this.updateSignals();
+  }
+  removeAll() {
+    this.clear();
+  }
+  setAll(entities, opts) {
+    this.clear();
+    this.addMany(entities, opts);
+  }
+  tap(handlers) {
+    this.tapHandlers.push(handlers);
+    return () => {
+      const idx = this.tapHandlers.indexOf(handlers);
+      if (idx > -1) this.tapHandlers.splice(idx, 1);
+    };
+  }
+  intercept(handlers) {
+    this.interceptHandlers.push(handlers);
+    return () => {
+      const idx = this.interceptHandlers.indexOf(handlers);
+      if (idx > -1) this.interceptHandlers.splice(idx, 1);
+    };
+  }
+  updateSignals() {
+    const entities = Array.from(this.storage.values());
+    const ids = Array.from(this.storage.keys());
+    const map = new Map(this.storage);
+    this.allSignal.set(entities);
+    this.countSignal.set(entities.length);
+    this.idsSignal.set(ids);
+    this.mapSignal.set(map);
+  }
+  getOrCreateNode(id, entity) {
+    let node = this.nodeCache.get(id);
+    if (!node) {
+      node = this.createEntityNode(id, entity);
+      this.nodeCache.set(id, node);
+    }
+    return node;
+  }
+  createEntityNode(id, entity) {
+    const node = () => this.storage.get(id);
+    for (const key of Object.keys(entity)) {
+      Object.defineProperty(node, key, {
+        get: () => {
+          const current = this.storage.get(id);
+          const value = current?.[key];
+          return () => value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return node;
+  }
+}
+function createEntitySignal(config, pathNotifier, basePath) {
+  const impl = new EntitySignalImpl(config, pathNotifier, basePath);
+  return new Proxy(impl, {
+    get: (target, prop) => {
+      if (typeof prop === 'string' && !isNaN(Number(prop))) {
+        return target.byId(Number(prop));
+      }
+      return target[prop];
+    }
+  });
+}
+
+export { EntitySignalImpl, createEntitySignal };

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 };