@signaltree/core 7.1.2 → 7.1.4

package/dist/lib/markers/status.js

@@ -1,71 +0,0 @@
-import { signal, computed } from '@angular/core';
-import { registerMarkerProcessor } from '../internals/materialize-markers.js';
-
-const STATUS_MARKER = Symbol('STATUS_MARKER');
-var LoadingState;
-(function (LoadingState) {
-  LoadingState["NotLoaded"] = "NOT_LOADED";
-  LoadingState["Loading"] = "LOADING";
-  LoadingState["Loaded"] = "LOADED";
-  LoadingState["Error"] = "ERROR";
-})(LoadingState || (LoadingState = {}));
-let statusRegistered = false;
-function status(initialState = LoadingState.NotLoaded) {
-  if (!statusRegistered) {
-    statusRegistered = true;
-    registerMarkerProcessor(isStatusMarker, createStatusSignal);
-  }
-  return {
-    [STATUS_MARKER]: true,
-    initialState
-  };
-}
-function isStatusMarker(value) {
-  return value !== null && typeof value === 'object' && STATUS_MARKER in value && value[STATUS_MARKER] === true;
-}
-function createStatusSignal(marker) {
-  const stateSignal = signal(marker.initialState);
-  const errorSignal = signal(null);
-  let _isNotLoaded = null;
-  let _isLoading = null;
-  let _isLoaded = null;
-  let _isError = null;
-  return {
-    state: stateSignal,
-    error: errorSignal,
-    get isNotLoaded() {
-      return _isNotLoaded ??= computed(() => stateSignal() === LoadingState.NotLoaded);
-    },
-    get isLoading() {
-      return _isLoading ??= computed(() => stateSignal() === LoadingState.Loading);
-    },
-    get isLoaded() {
-      return _isLoaded ??= computed(() => stateSignal() === LoadingState.Loaded);
-    },
-    get isError() {
-      return _isError ??= computed(() => stateSignal() === LoadingState.Error);
-    },
-    setNotLoaded() {
-      stateSignal.set(LoadingState.NotLoaded);
-      errorSignal.set(null);
-    },
-    setLoading() {
-      stateSignal.set(LoadingState.Loading);
-      errorSignal.set(null);
-    },
-    setLoaded() {
-      stateSignal.set(LoadingState.Loaded);
-      errorSignal.set(null);
-    },
-    setError(err) {
-      stateSignal.set(LoadingState.Error);
-      errorSignal.set(err);
-    },
-    reset() {
-      stateSignal.set(LoadingState.NotLoaded);
-      errorSignal.set(null);
-    }
-  };
-}
-
-export { LoadingState, STATUS_MARKER, createStatusSignal, isStatusMarker, status };

package/dist/lib/markers/stored.js

@@ -1,111 +0,0 @@
-import { signal } from '@angular/core';
-import { registerMarkerProcessor } from '../internals/materialize-markers.js';
-
-const STORED_MARKER = Symbol('STORED_MARKER');
-let storedRegistered = false;
-function stored(key, defaultValue, options = {}) {
-  if (!storedRegistered) {
-    storedRegistered = true;
-    registerMarkerProcessor(isStoredMarker, createStoredSignal);
-  }
-  return {
-    [STORED_MARKER]: true,
-    key,
-    defaultValue,
-    options
-  };
-}
-function isStoredMarker(value) {
-  return value !== null && typeof value === 'object' && STORED_MARKER in value && value[STORED_MARKER] === true;
-}
-function createStoredSignal(marker) {
-  const {
-    key,
-    defaultValue,
-    options: {
-      serialize = JSON.stringify,
-      deserialize = JSON.parse,
-      debounceMs = 100
-    }
-  } = marker;
-  const storage = marker.options.storage !== undefined ? marker.options.storage : typeof localStorage !== 'undefined' ? localStorage : null;
-  let initialValue = defaultValue;
-  if (storage) {
-    try {
-      const storedValue = storage.getItem(key);
-      if (storedValue !== null) {
-        initialValue = deserialize(storedValue);
-      }
-    } catch (e) {
-      if (typeof ngDevMode === 'undefined' || ngDevMode) {
-        console.warn(`SignalTree: Failed to read "${key}" from storage`, e);
-      }
-    }
-  }
-  const sig = signal(initialValue);
-  let pendingWrite = null;
-  let pendingValue;
-  const saveToStorage = value => {
-    if (!storage) return;
-    if (debounceMs === 0) {
-      queueMicrotask(() => {
-        try {
-          storage.setItem(key, serialize(value));
-        } catch (e) {
-          if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            console.warn(`SignalTree: Failed to save "${key}" to storage`, e);
-          }
-        }
-      });
-      return;
-    }
-    pendingValue = value;
-    if (pendingWrite !== null) {
-      clearTimeout(pendingWrite);
-    }
-    pendingWrite = setTimeout(() => {
-      pendingWrite = null;
-      queueMicrotask(() => {
-        try {
-          storage.setItem(key, serialize(pendingValue));
-        } catch (e) {
-          if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            console.warn(`SignalTree: Failed to save "${key}" to storage`, e);
-          }
-        }
-      });
-    }, debounceMs);
-  };
-  const storedSignal = () => sig();
-  storedSignal.set = value => {
-    sig.set(value);
-    saveToStorage(value);
-  };
-  storedSignal.update = fn => {
-    const newValue = fn(sig());
-    sig.set(newValue);
-    saveToStorage(newValue);
-  };
-  storedSignal.clear = () => {
-    sig.set(defaultValue);
-    if (storage) {
-      storage.removeItem(key);
-    }
-  };
-  storedSignal.reload = () => {
-    if (!storage) return;
-    try {
-      const storedValue = storage.getItem(key);
-      if (storedValue !== null) {
-        sig.set(deserialize(storedValue));
-      } else {
-        sig.set(defaultValue);
-      }
-    } catch {
-      sig.set(defaultValue);
-    }
-  };
-  return storedSignal;
-}
-
-export { STORED_MARKER, createStoredSignal, isStoredMarker, stored };

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

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

@@ -1,178 +0,0 @@
-class PathNotifier {
-  subscribers = new Map();
-  interceptors = new Map();
-  batchingEnabled = true;
-  pendingFlush = false;
-  pending = new Map();
-  firstValues = new Map();
-  flushCallbacks = new Set();
-  constructor(options) {
-    if (options && options.batching === false) this.batchingEnabled = false;
-  }
-  setBatchingEnabled(enabled) {
-    this.batchingEnabled = enabled;
-  }
-  isBatchingEnabled() {
-    return this.batchingEnabled;
-  }
-  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) {
-    if (!this.batchingEnabled) {
-      return this._runNotify(path, value, prev);
-    }
-    if (!this.pending.has(path)) {
-      this.firstValues.set(path, prev);
-    }
-    this.pending.set(path, {
-      newValue: value,
-      oldValue: this.firstValues.get(path)
-    });
-    if (!this.pendingFlush) {
-      this.pendingFlush = true;
-      queueMicrotask(() => this.flush());
-    }
-    return {
-      blocked: false,
-      value
-    };
-  }
-  _runNotify(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
-    };
-  }
-  flush() {
-    const toNotify = new Map(this.pending);
-    this.pending.clear();
-    this.firstValues.clear();
-    this.pendingFlush = false;
-    for (const [path, {
-      newValue,
-      oldValue
-    }] of toNotify) {
-      if (newValue === oldValue) continue;
-      const res = this._runNotify(path, newValue, oldValue);
-      if (res.blocked) ;
-    }
-    for (const cb of Array.from(this.flushCallbacks)) {
-      try {
-        cb();
-      } catch {}
-    }
-  }
-  flushSync() {
-    while (this.pending.size > 0 || this.pendingFlush) {
-      if (this.pendingFlush && this.pending.size === 0) {
-        this.pendingFlush = false;
-        break;
-      }
-      this.flush();
-    }
-  }
-  onFlush(callback) {
-    this.flushCallbacks.add(callback);
-    return () => this.flushCallbacks.delete(callback);
-  }
-  hasPending() {
-    return this.pending.size > 0;
-  }
-  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();
-    this.pending.clear();
-    this.firstValues.clear();
-    this.pendingFlush = false;
-  }
-  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

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

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