@signaltree/core 5.1.0 → 5.1.1

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,106 +0,0 @@
-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/performance/diff-engine.js

@@ -1,156 +0,0 @@
-var ChangeType;
-(function (ChangeType) {
-  ChangeType["ADD"] = "add";
-  ChangeType["UPDATE"] = "update";
-  ChangeType["DELETE"] = "delete";
-  ChangeType["REPLACE"] = "replace";
-})(ChangeType || (ChangeType = {}));
-class DiffEngine {
-  defaultOptions = {
-    maxDepth: 100,
-    detectDeletions: false,
-    ignoreArrayOrder: false,
-    equalityFn: (a, b) => a === b,
-    keyValidator: undefined
-  };
-  diff(current, updates, options = {}) {
-    const opts = {
-      ...this.defaultOptions,
-      ...options
-    };
-    const changes = [];
-    const visited = new WeakSet();
-    this.traverse(current, updates, [], changes, visited, opts, 0);
-    return {
-      changes,
-      hasChanges: changes.length > 0
-    };
-  }
-  traverse(curr, upd, path, changes, visited, opts, depth) {
-    if (depth > opts.maxDepth) {
-      return;
-    }
-    if (typeof upd !== 'object' || upd === null) {
-      if (!opts.equalityFn(curr, upd)) {
-        changes.push({
-          type: curr === undefined ? ChangeType.ADD : ChangeType.UPDATE,
-          path: [...path],
-          value: upd,
-          oldValue: curr
-        });
-      }
-      return;
-    }
-    if (visited.has(upd)) {
-      return;
-    }
-    visited.add(upd);
-    if (Array.isArray(upd)) {
-      this.diffArrays(curr, upd, path, changes, visited, opts, depth);
-      return;
-    }
-    if (!curr || typeof curr !== 'object' || Array.isArray(curr)) {
-      changes.push({
-        type: ChangeType.REPLACE,
-        path: [...path],
-        value: upd,
-        oldValue: curr
-      });
-      return;
-    }
-    const currObj = curr;
-    const updObj = upd;
-    for (const key in updObj) {
-      if (Object.prototype.hasOwnProperty.call(updObj, key)) {
-        if (opts.keyValidator && !opts.keyValidator(key)) {
-          continue;
-        }
-        this.traverse(currObj[key], updObj[key], [...path, key], changes, visited, opts, depth + 1);
-      }
-    }
-    if (opts.detectDeletions) {
-      for (const key in currObj) {
-        if (Object.prototype.hasOwnProperty.call(currObj, key) && !(key in updObj)) {
-          changes.push({
-            type: ChangeType.DELETE,
-            path: [...path, key],
-            oldValue: currObj[key]
-          });
-        }
-      }
-    }
-  }
-  diffArrays(curr, upd, path, changes, visited, opts, depth) {
-    if (!Array.isArray(curr)) {
-      changes.push({
-        type: ChangeType.REPLACE,
-        path: [...path],
-        value: upd,
-        oldValue: curr
-      });
-      return;
-    }
-    if (opts.ignoreArrayOrder) {
-      this.diffArraysUnordered(curr, upd, path, changes, opts);
-    } else {
-      this.diffArraysOrdered(curr, upd, path, changes, visited, opts, depth);
-    }
-  }
-  diffArraysOrdered(curr, upd, path, changes, visited, opts, depth) {
-    const maxLength = Math.max(curr.length, upd.length);
-    for (let i = 0; i < maxLength; i++) {
-      if (i >= upd.length) {
-        if (opts.detectDeletions) {
-          changes.push({
-            type: ChangeType.DELETE,
-            path: [...path, i],
-            oldValue: curr[i]
-          });
-        }
-      } else if (i >= curr.length) {
-        changes.push({
-          type: ChangeType.ADD,
-          path: [...path, i],
-          value: upd[i]
-        });
-      } else {
-        this.traverse(curr[i], upd[i], [...path, i], changes, visited, opts, depth + 1);
-      }
-    }
-  }
-  diffArraysUnordered(curr, upd, path, changes, opts) {
-    const currSet = new Set(curr.map(v => this.stringify(v)));
-    const updSet = new Set(upd.map(v => this.stringify(v)));
-    upd.forEach((value, index) => {
-      const str = this.stringify(value);
-      if (!currSet.has(str)) {
-        changes.push({
-          type: ChangeType.ADD,
-          path: [...path, index],
-          value
-        });
-      }
-    });
-    if (opts.detectDeletions) {
-      curr.forEach((value, index) => {
-        const str = this.stringify(value);
-        if (!updSet.has(str)) {
-          changes.push({
-            type: ChangeType.DELETE,
-            path: [...path, index],
-            oldValue: value
-          });
-        }
-      });
-    }
-  }
-  stringify(value) {
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return String(value);
-    }
-  }
-}
-
-export { ChangeType, DiffEngine };

package/dist/lib/performance/path-index.js

@@ -1,156 +0,0 @@
-import { isSignal } from '@angular/core';
-
-class TrieNode {
-  value = null;
-  children = new Map();
-}
-class PathIndex {
-  root = new TrieNode();
-  pathCache = new Map();
-  stats = {
-    hits: 0,
-    misses: 0,
-    sets: 0,
-    cleanups: 0
-  };
-  set(path, signal) {
-    const pathStr = this.pathToString(path);
-    const ref = new WeakRef(signal);
-    let node = this.root;
-    for (const segment of path) {
-      const key = String(segment);
-      if (!node.children.has(key)) {
-        node.children.set(key, new TrieNode());
-      }
-      const nextNode = node.children.get(key);
-      if (!nextNode) {
-        throw new Error(`Failed to get node for key: ${key}`);
-      }
-      node = nextNode;
-    }
-    node.value = ref;
-    this.pathCache.set(pathStr, ref);
-    this.stats.sets++;
-  }
-  get(path) {
-    const pathStr = this.pathToString(path);
-    const cached = this.pathCache.get(pathStr);
-    if (cached) {
-      const value = cached.deref();
-      if (value) {
-        this.stats.hits++;
-        return value;
-      }
-      this.pathCache.delete(pathStr);
-      this.stats.cleanups++;
-    }
-    let node = this.root;
-    for (const segment of path) {
-      const key = String(segment);
-      node = node.children.get(key);
-      if (!node) {
-        this.stats.misses++;
-        return null;
-      }
-    }
-    if (node.value) {
-      const value = node.value.deref();
-      if (value) {
-        this.pathCache.set(pathStr, node.value);
-        this.stats.hits++;
-        return value;
-      }
-      node.value = null;
-      this.stats.cleanups++;
-    }
-    this.stats.misses++;
-    return null;
-  }
-  has(path) {
-    return this.get(path) !== null;
-  }
-  getByPrefix(prefix) {
-    const results = new Map();
-    let node = this.root;
-    for (const segment of prefix) {
-      const key = String(segment);
-      node = node.children.get(key);
-      if (!node) {
-        return results;
-      }
-    }
-    this.collectDescendants(node, [], results);
-    return results;
-  }
-  delete(path) {
-    const pathStr = this.pathToString(path);
-    this.pathCache.delete(pathStr);
-    let node = this.root;
-    const nodes = [node];
-    for (const segment of path) {
-      const key = String(segment);
-      node = node.children.get(key);
-      if (!node) {
-        return false;
-      }
-      nodes.push(node);
-    }
-    const hadValue = node.value !== null;
-    node.value = null;
-    for (let i = nodes.length - 1; i > 0; i--) {
-      const current = nodes[i];
-      if (current.value === null && current.children.size === 0) {
-        const parent = nodes[i - 1];
-        const segment = path[i - 1];
-        parent.children.delete(String(segment));
-      } else {
-        break;
-      }
-    }
-    return hadValue;
-  }
-  clear() {
-    this.root = new TrieNode();
-    this.pathCache.clear();
-  }
-  getStats() {
-    const total = this.stats.hits + this.stats.misses;
-    const hitRate = total > 0 ? this.stats.hits / total : 0;
-    return {
-      ...this.stats,
-      hitRate,
-      cacheSize: this.pathCache.size
-    };
-  }
-  buildFromTree(tree, path = []) {
-    if (!tree) {
-      return;
-    }
-    if (isSignal(tree)) {
-      this.set(path, tree);
-      return;
-    }
-    if (typeof tree !== 'object') {
-      return;
-    }
-    for (const [key, value] of Object.entries(tree)) {
-      this.buildFromTree(value, [...path, key]);
-    }
-  }
-  pathToString(path) {
-    return path.join('.');
-  }
-  collectDescendants(node, currentPath, results) {
-    if (node.value) {
-      const value = node.value.deref();
-      if (value) {
-        results.set(this.pathToString(currentPath), value);
-      }
-    }
-    for (const [key, child] of node.children) {
-      this.collectDescendants(child, [...currentPath, key], results);
-    }
-  }
-}
-
-export { PathIndex };