@signaltree/core 4.0.15 → 4.1.0

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

@@ -1,154 +1,156 @@
 import { isSignal } from '@angular/core';
+
 class TrieNode {
-    value = null;
-    children = new Map();
+  value = null;
+  children = new Map();
 }
-export 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++;
+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++;
     }
-    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++;
-        }
+    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;
+      }
     }
-    has(path) {
-        return this.get(path) !== 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++;
     }
-    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);
+    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);
     }
-    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;
+    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;
     }
-    clear() {
-        this.root = new TrieNode();
-        this.pathCache.clear();
+    if (isSignal(tree)) {
+      this.set(path, tree);
+      return;
     }
-    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,
-        };
+    if (typeof tree !== 'object') {
+      return;
     }
-    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]);
-        }
+    for (const [key, value] of Object.entries(tree)) {
+      this.buildFromTree(value, [...path, key]);
     }
-    pathToString(path) {
-        return path.join('.');
+  }
+  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);
+      }
     }
-    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);
-        }
+    for (const [key, child] of node.children) {
+      this.collectDescendants(child, [...currentPath, key], results);
     }
+  }
 }
+
+export { PathIndex };

package/dist/lib/performance/update-engine.js

@@ -1,193 +1,188 @@
 import { isSignal } from '@angular/core';
-import { ChangeType, DiffEngine } from './diff-engine';
-import { PathIndex } from './path-index';
-export class OptimizedUpdateEngine {
-    pathIndex;
-    diffEngine;
-    constructor(tree) {
-        this.pathIndex = new PathIndex();
-        this.diffEngine = new DiffEngine();
-        this.pathIndex.buildFromTree(tree);
+import { DiffEngine, ChangeType } from './diff-engine.js';
+import { PathIndex } from './path-index.js';
+
+class OptimizedUpdateEngine {
+  pathIndex;
+  diffEngine;
+  constructor(tree) {
+    this.pathIndex = new PathIndex();
+    this.diffEngine = new DiffEngine();
+    this.pathIndex.buildFromTree(tree);
+  }
+  update(tree, updates, options = {}) {
+    const startTime = performance.now();
+    const diffOptions = {};
+    if (options.maxDepth !== undefined) diffOptions.maxDepth = options.maxDepth;
+    if (options.ignoreArrayOrder !== undefined) diffOptions.ignoreArrayOrder = options.ignoreArrayOrder;
+    if (options.equalityFn !== undefined) diffOptions.equalityFn = options.equalityFn;
+    const diff = this.diffEngine.diff(tree, updates, diffOptions);
+    if (diff.changes.length === 0) {
+      return {
+        changed: false,
+        duration: performance.now() - startTime,
+        changedPaths: []
+      };
     }
-    update(tree, updates, options = {}) {
-        const startTime = performance.now();
-        const diffOptions = {};
-        if (options.maxDepth !== undefined)
-            diffOptions.maxDepth = options.maxDepth;
-        if (options.ignoreArrayOrder !== undefined)
-            diffOptions.ignoreArrayOrder = options.ignoreArrayOrder;
-        if (options.equalityFn !== undefined)
-            diffOptions.equalityFn = options.equalityFn;
-        const diff = this.diffEngine.diff(tree, updates, diffOptions);
-        if (diff.changes.length === 0) {
-            return {
-                changed: false,
-                duration: performance.now() - startTime,
-                changedPaths: [],
-            };
+    const patches = this.createPatches(diff.changes);
+    const sortedPatches = this.sortPatches(patches);
+    const result = options.batch ? this.batchApplyPatches(tree, sortedPatches, options.batchSize) : this.applyPatches(tree, sortedPatches);
+    const duration = performance.now() - startTime;
+    return {
+      changed: true,
+      duration,
+      changedPaths: result.appliedPaths,
+      stats: {
+        totalPaths: diff.changes.length,
+        optimizedPaths: patches.length,
+        batchedUpdates: result.batchCount
+      }
+    };
+  }
+  rebuildIndex(tree) {
+    this.pathIndex.clear();
+    this.pathIndex.buildFromTree(tree);
+  }
+  getIndexStats() {
+    return this.pathIndex.getStats();
+  }
+  createPatches(changes) {
+    const patches = [];
+    const processedPaths = new Set();
+    for (const change of changes) {
+      const pathStr = change.path.join('.');
+      let skipPath = false;
+      for (const processed of processedPaths) {
+        if (pathStr.startsWith(processed + '.')) {
+          skipPath = true;
+          break;
         }
-        const patches = this.createPatches(diff.changes);
-        const sortedPatches = this.sortPatches(patches);
-        const result = options.batch
-            ? this.batchApplyPatches(tree, sortedPatches, options.batchSize)
-            : this.applyPatches(tree, sortedPatches);
-        const duration = performance.now() - startTime;
-        return {
-            changed: true,
-            duration,
-            changedPaths: result.appliedPaths,
-            stats: {
-                totalPaths: diff.changes.length,
-                optimizedPaths: patches.length,
-                batchedUpdates: result.batchCount,
-            },
-        };
+      }
+      if (skipPath) {
+        continue;
+      }
+      const patch = this.createPatch(change);
+      patches.push(patch);
+      processedPaths.add(pathStr);
+      if (change.type === ChangeType.REPLACE && typeof change.value === 'object') {
+        processedPaths.add(pathStr);
+      }
     }
-    rebuildIndex(tree) {
-        this.pathIndex.clear();
-        this.pathIndex.buildFromTree(tree);
+    return patches;
+  }
+  createPatch(change) {
+    return {
+      type: change.type,
+      path: change.path,
+      value: change.value,
+      oldValue: change.oldValue,
+      priority: this.calculatePriority(change),
+      signal: this.pathIndex.get(change.path)
+    };
+  }
+  calculatePriority(change) {
+    let priority = 0;
+    priority += (10 - change.path.length) * 10;
+    if (change.path.some(p => typeof p === 'number')) {
+      priority -= 20;
     }
-    getIndexStats() {
-        return this.pathIndex.getStats();
+    if (change.type === ChangeType.REPLACE) {
+      priority += 30;
     }
-    createPatches(changes) {
-        const patches = [];
-        const processedPaths = new Set();
-        for (const change of changes) {
-            const pathStr = change.path.join('.');
-            let skipPath = false;
-            for (const processed of processedPaths) {
-                if (pathStr.startsWith(processed + '.')) {
-                    skipPath = true;
-                    break;
-                }
-            }
-            if (skipPath) {
-                continue;
-            }
-            const patch = this.createPatch(change);
-            patches.push(patch);
-            processedPaths.add(pathStr);
-            if (change.type === ChangeType.REPLACE &&
-                typeof change.value === 'object') {
-                processedPaths.add(pathStr);
-            }
-        }
-        return patches;
+    return priority;
+  }
+  sortPatches(patches) {
+    return patches.sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return b.priority - a.priority;
+      }
+      return a.path.length - b.path.length;
+    });
+  }
+  applyPatches(tree, patches) {
+    const appliedPaths = [];
+    let updateCount = 0;
+    for (const patch of patches) {
+      if (this.applyPatch(patch, tree)) {
+        appliedPaths.push(patch.path.join('.'));
+        updateCount++;
+      }
     }
-    createPatch(change) {
-        return {
-            type: change.type,
-            path: change.path,
-            value: change.value,
-            oldValue: change.oldValue,
-            priority: this.calculatePriority(change),
-            signal: this.pathIndex.get(change.path),
-        };
+    return {
+      appliedPaths,
+      updateCount,
+      batchCount: 1
+    };
+  }
+  batchApplyPatches(tree, patches, batchSize = 50) {
+    const batches = [];
+    for (let i = 0; i < patches.length; i += batchSize) {
+      batches.push(patches.slice(i, i + batchSize));
     }
-    calculatePriority(change) {
-        let priority = 0;
-        priority += (10 - change.path.length) * 10;
-        if (change.path.some((p) => typeof p === 'number')) {
-            priority -= 20;
-        }
-        if (change.type === ChangeType.REPLACE) {
-            priority += 30;
+    const appliedPaths = [];
+    let updateCount = 0;
+    for (const currentBatch of batches) {
+      for (const patch of currentBatch) {
+        if (this.applyPatch(patch, tree)) {
+          appliedPaths.push(patch.path.join('.'));
+          updateCount++;
         }
-        return priority;
+      }
     }
-    sortPatches(patches) {
-        return patches.sort((a, b) => {
-            if (a.priority !== b.priority) {
-                return b.priority - a.priority;
-            }
-            return a.path.length - b.path.length;
-        });
-    }
-    applyPatches(tree, patches) {
-        const appliedPaths = [];
-        let updateCount = 0;
-        for (const patch of patches) {
-            if (this.applyPatch(patch, tree)) {
-                appliedPaths.push(patch.path.join('.'));
-                updateCount++;
-            }
+    return {
+      appliedPaths,
+      updateCount,
+      batchCount: batches.length
+    };
+  }
+  applyPatch(patch, tree) {
+    try {
+      if (patch.signal && isSignal(patch.signal) && 'set' in patch.signal) {
+        const currentValue = patch.signal();
+        if (this.isEqual(currentValue, patch.value)) {
+          return false;
         }
-        return {
-            appliedPaths,
-            updateCount,
-            batchCount: 1,
-        };
-    }
-    batchApplyPatches(tree, patches, batchSize = 50) {
-        const batches = [];
-        for (let i = 0; i < patches.length; i += batchSize) {
-            batches.push(patches.slice(i, i + batchSize));
+        patch.signal.set(patch.value);
+        if (patch.type === ChangeType.ADD && patch.value !== undefined) {
+          this.pathIndex.set(patch.path, patch.signal);
         }
-        const appliedPaths = [];
-        let updateCount = 0;
-        for (const currentBatch of batches) {
-            for (const patch of currentBatch) {
-                if (this.applyPatch(patch, tree)) {
-                    appliedPaths.push(patch.path.join('.'));
-                    updateCount++;
-                }
-            }
+        return true;
+      }
+      let current = tree;
+      for (let i = 0; i < patch.path.length - 1; i++) {
+        const key = patch.path[i];
+        current = current[key];
+        if (!current || typeof current !== 'object') {
+          return false;
         }
-        return {
-            appliedPaths,
-            updateCount,
-            batchCount: batches.length,
-        };
+      }
+      const lastKey = patch.path[patch.path.length - 1];
+      if (this.isEqual(current[lastKey], patch.value)) {
+        return false;
+      }
+      current[lastKey] = patch.value;
+      return true;
+    } catch (error) {
+      console.error(`Failed to apply patch at ${patch.path.join('.')}:`, error);
+      return false;
     }
-    applyPatch(patch, tree) {
-        try {
-            if (patch.signal && isSignal(patch.signal) && 'set' in patch.signal) {
-                const currentValue = patch.signal();
-                if (this.isEqual(currentValue, patch.value)) {
-                    return false;
-                }
-                patch.signal.set(patch.value);
-                if (patch.type === ChangeType.ADD && patch.value !== undefined) {
-                    this.pathIndex.set(patch.path, patch.signal);
-                }
-                return true;
-            }
-            let current = tree;
-            for (let i = 0; i < patch.path.length - 1; i++) {
-                const key = patch.path[i];
-                current = current[key];
-                if (!current || typeof current !== 'object') {
-                    return false;
-                }
-            }
-            const lastKey = patch.path[patch.path.length - 1];
-            if (this.isEqual(current[lastKey], patch.value)) {
-                return false;
-            }
-            current[lastKey] = patch.value;
-            return true;
-        }
-        catch (error) {
-            console.error(`Failed to apply patch at ${patch.path.join('.')}:`, error);
-            return false;
-        }
+  }
+  isEqual(a, b) {
+    if (a === b) {
+      return true;
     }
-    isEqual(a, b) {
-        if (a === b) {
-            return true;
-        }
-        if (typeof a !== typeof b) {
-            return false;
-        }
-        if (typeof a !== 'object' || a === null || b === null) {
-            return false;
-        }
-        try {
-            return JSON.stringify(a) === JSON.stringify(b);
-        }
-        catch {
-            return false;
-        }
+    if (typeof a !== typeof b) {
+      return false;
+    }
+    if (typeof a !== 'object' || a === null || b === null) {
+      return false;
+    }
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch {
+      return false;
     }
+  }
 }
+
+export { OptimizedUpdateEngine };