@signaltree/core 5.1.1 → 5.1.2

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/performance/diff-engine.js

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

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