@signaltree/enterprise 4.0.7 → 4.0.9

package/src/lib/update-engine.spec.ts

@@ -0,0 +1,93 @@
+import { OptimizedUpdateEngine } from './update-engine';
+
+describe("OptimizedUpdateEngine", () => {
+  it("should detect simple changes", () => {
+    const tree = { name: "Alice", age: 30 };
+    const engine = new OptimizedUpdateEngine(tree);
+
+    const result = engine.update(tree, { age: 31 });
+
+    expect(result.changed).toBe(true);
+    expect(result.changedPaths.some((p) => p.includes("age"))).toBe(true);
+  });
+
+  it("should return false when no changes", () => {
+    const tree = { name: "Alice" };
+    const engine = new OptimizedUpdateEngine(tree);
+
+    const result = engine.update(tree, { name: "Alice" });
+
+    expect(result.changed).toBe(false);
+  });
+
+  it("should handle nested objects", () => {
+    const tree = {
+      user: {
+        profile: { name: "Alice", age: 30 },
+      },
+    };
+
+    const engine = new OptimizedUpdateEngine(tree);
+    const result = engine.update(tree, {
+      user: { profile: { age: 31 } },
+    });
+
+    expect(result.changed).toBe(true);
+  });
+
+  it("should respect maxDepth option", () => {
+    const tree = {
+      level1: {
+        level2: {
+          level3: { deep: "value" },
+        },
+      },
+    };
+
+    const engine = new OptimizedUpdateEngine(tree);
+    const result = engine.update(
+      tree,
+      {
+        level1: {
+          level2: {
+            level3: { deep: "changed" },
+          },
+        },
+      },
+      { maxDepth: 2 }
+    );
+
+    expect(result.changed).toBe(false);
+  });
+
+  it("should return index statistics", () => {
+    const tree = { a: 1, b: 2 };
+    const engine = new OptimizedUpdateEngine(tree);
+
+    const stats = engine.getIndexStats();
+
+    expect(stats).toHaveProperty("hits");
+    expect(stats).toHaveProperty("misses");
+    expect(stats).toHaveProperty("hitRate");
+  });
+
+  it("should handle large objects efficiently", () => {
+    const largeObj: Record<string, unknown> = {};
+    for (let i = 0; i < 1000; i++) {
+      largeObj["field" + i] = i;
+    }
+
+    const updates: Record<string, unknown> = {};
+    for (let i = 0; i < 1000; i++) {
+      updates["field" + i] = i + 1000;
+    }
+
+    const engine = new OptimizedUpdateEngine(largeObj);
+    const start = performance.now();
+    const result = engine.update(largeObj, updates);
+    const duration = performance.now() - start;
+
+    expect(result.changed).toBe(true);
+    expect(duration).toBeLessThan(200);
+  });
+});

package/src/lib/update-engine.ts

@@ -0,0 +1,399 @@
+import { isSignal } from '@angular/core';
+
+import { ChangeType, DiffEngine } from './diff-engine';
+import { PathIndex } from './path-index';
+
+import type { WritableSignal } from '@angular/core';
+import type { Change, DiffOptions } from './diff-engine';
+import type { Path } from './path-index';
+/**
+ * OptimizedUpdateEngine - High-performance tree updates
+ * @packageDocumentation
+ */
+/**
+ * Update options
+ */
+export interface UpdateOptions extends DiffOptions {
+  /** Whether to batch updates */
+  batch?: boolean;
+
+  /** Batch size for chunked updates */
+  batchSize?: number;
+}
+
+/**
+ * Update result
+ */
+export interface UpdateResult {
+  /** Whether any changes were made */
+  changed: boolean;
+
+  /** Update duration in milliseconds */
+  duration: number;
+
+  /** List of changed paths */
+  changedPaths: string[];
+
+  /** Update statistics */
+  stats?: {
+    totalPaths: number;
+    optimizedPaths: number;
+    batchedUpdates: number;
+  };
+}
+
+/**
+ * Patch to apply
+ */
+interface Patch {
+  type: ChangeType;
+  path: Path;
+  value?: unknown;
+  oldValue?: unknown;
+  priority: number;
+  signal?: WritableSignal<unknown> | null;
+}
+
+/**
+ * Apply result (internal)
+ */
+interface ApplyResult {
+  appliedPaths: string[];
+  updateCount: number;
+  batchCount: number;
+}
+
+/**
+ * OptimizedUpdateEngine
+ *
+ * High-performance update engine using path indexing and diffing to minimize
+ * unnecessary signal updates.
+ *
+ * Features:
+ * - Diff-based updates (only update what changed)
+ * - Path indexing for O(k) lookups
+ * - Automatic batching for large updates
+ * - Priority-based patch ordering
+ * - Skip unchanged values
+ *
+ * @example
+ * ```ts
+ * const tree = signalTree(data, { useLazySignals: true });
+ * const engine = new OptimizedUpdateEngine(tree);
+ *
+ * // Optimized update - only changes what's different
+ * const result = engine.update({
+ *   user: { name: 'Alice' } // Only updates if name changed
+ * });
+ *
+ * console.log(result.changedPaths); // ['user.name']
+ * console.log(result.duration); // ~2ms
+ * ```
+ */
+export class OptimizedUpdateEngine {
+  private pathIndex: PathIndex;
+  private diffEngine: DiffEngine;
+
+  constructor(tree: unknown) {
+    this.pathIndex = new PathIndex();
+    this.diffEngine = new DiffEngine();
+
+    // Build initial index
+    this.pathIndex.buildFromTree(tree);
+  }
+
+  /**
+   * Update tree with optimizations
+   *
+   * @param tree - Current tree state
+   * @param updates - Updates to apply
+   * @param options - Update options
+   * @returns Update result
+   */
+  update(
+    tree: unknown,
+    updates: unknown,
+    options: UpdateOptions = {}
+  ): UpdateResult {
+    const startTime = performance.now();
+
+    // Step 1: Generate diff to find actual changes
+    const diffOptions: Partial<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) {
+      // No actual changes, skip update entirely
+      return {
+        changed: false,
+        duration: performance.now() - startTime,
+        changedPaths: [],
+      };
+    }
+
+    // Step 2: Convert diff to optimized patches
+    const patches = this.createPatches(diff.changes);
+
+    // Step 3: Sort patches for optimal application order
+    const sortedPatches = this.sortPatches(patches);
+
+    // Step 4: Apply patches with optional batching
+    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,
+      },
+    };
+  }
+
+  /**
+   * Rebuild path index from current tree state
+   *
+   * @param tree - Current tree
+   */
+  rebuildIndex(tree: unknown): void {
+    this.pathIndex.clear();
+    this.pathIndex.buildFromTree(tree);
+  }
+
+  /**
+   * Get path index statistics
+   */
+  getIndexStats(): ReturnType<PathIndex['getStats']> {
+    return this.pathIndex.getStats();
+  }
+
+  /**
+   * Creates optimized patches from diff changes
+   */
+  private createPatches(changes: Change[]): Patch[] {
+    const patches: Patch[] = [];
+    const processedPaths = new Set<string>();
+
+    for (const change of changes) {
+      const pathStr = change.path.join('.');
+
+      // Skip if parent path already processed (optimization)
+      let skipPath = false;
+      for (const processed of processedPaths) {
+        if (pathStr.startsWith(processed + '.')) {
+          skipPath = true;
+          break;
+        }
+      }
+
+      if (skipPath) {
+        continue;
+      }
+
+      // Create patch based on change type
+      const patch = this.createPatch(change);
+      patches.push(patch);
+
+      // Mark path as processed
+      processedPaths.add(pathStr);
+
+      // If this is an object replacement, skip child paths
+      if (
+        change.type === ChangeType.REPLACE &&
+        typeof change.value === 'object'
+      ) {
+        processedPaths.add(pathStr);
+      }
+    }
+
+    return patches;
+  }
+
+  /**
+   * Creates a single patch from a change
+   */
+  private createPatch(change: Change): Patch {
+    return {
+      type: change.type,
+      path: change.path,
+      value: change.value,
+      oldValue: change.oldValue,
+      priority: this.calculatePriority(change),
+      signal: this.pathIndex.get(change.path),
+    };
+  }
+
+  /**
+   * Calculates update priority for optimal ordering
+   */
+  private calculatePriority(change: Change): number {
+    let priority = 0;
+
+    // Shallow updates have higher priority
+    priority += (10 - change.path.length) * 10;
+
+    // Array updates have lower priority (more expensive)
+    if (change.path.some((p) => typeof p === 'number')) {
+      priority -= 20;
+    }
+
+    // Replace operations have higher priority than nested updates
+    if (change.type === ChangeType.REPLACE) {
+      priority += 30;
+    }
+
+    return priority;
+  }
+
+  /**
+   * Sorts patches for optimal application
+   */
+  private sortPatches(patches: Patch[]): Patch[] {
+    return patches.sort((a, b) => {
+      // Sort by priority (higher first)
+      if (a.priority !== b.priority) {
+        return b.priority - a.priority;
+      }
+
+      // Then by path depth (shallow first)
+      return a.path.length - b.path.length;
+    });
+  }
+
+  /**
+   * Applies patches directly (no batching)
+   */
+  private applyPatches(tree: unknown, patches: Patch[]): ApplyResult {
+    const appliedPaths: string[] = [];
+    let updateCount = 0;
+
+    for (const patch of patches) {
+      if (this.applyPatch(patch, tree)) {
+        appliedPaths.push(patch.path.join('.'));
+        updateCount++;
+      }
+    }
+
+    return {
+      appliedPaths,
+      updateCount,
+      batchCount: 1,
+    };
+  }
+
+  /**
+   * Applies patches with batching for better performance
+   */
+  private batchApplyPatches(
+    tree: unknown,
+    patches: Patch[],
+    batchSize = 50
+  ): ApplyResult {
+    const batches: Patch[][] = [];
+
+    for (let i = 0; i < patches.length; i += batchSize) {
+      batches.push(patches.slice(i, i + batchSize));
+    }
+
+    const appliedPaths: string[] = [];
+    let updateCount = 0;
+
+    // Process patches in batches
+    for (const currentBatch of batches) {
+      for (const patch of currentBatch) {
+        if (this.applyPatch(patch, tree)) {
+          appliedPaths.push(patch.path.join('.'));
+          updateCount++;
+        }
+      }
+    }
+
+    return {
+      appliedPaths,
+      updateCount,
+      batchCount: batches.length,
+    };
+  }
+
+  /**
+   * Applies a single patch to the tree object
+   */
+  private applyPatch(patch: Patch, tree: unknown): boolean {
+    try {
+      // First, try to update via signal if available
+      if (patch.signal && isSignal(patch.signal) && 'set' in patch.signal) {
+        const currentValue = patch.signal();
+
+        // Only update if value actually changed
+        if (this.isEqual(currentValue, patch.value)) {
+          return false;
+        }
+
+        // Update the signal - this will handle reactivity
+        (patch.signal as WritableSignal<unknown>).set(patch.value);
+
+        // After successful ADD, update the index
+        if (patch.type === ChangeType.ADD && patch.value !== undefined) {
+          this.pathIndex.set(patch.path, patch.signal);
+        }
+
+        return true;
+      } // Fallback: Navigate to parent object and update directly
+      let current: Record<string, unknown> = tree as Record<string, unknown>;
+      for (let i = 0; i < patch.path.length - 1; i++) {
+        const key = patch.path[i];
+        current = current[key] as Record<string, unknown>;
+        if (!current || typeof current !== 'object') {
+          return false;
+        }
+      }
+
+      const lastKey = patch.path[patch.path.length - 1];
+
+      // Only update if value actually changed
+      if (this.isEqual(current[lastKey], patch.value)) {
+        return false;
+      }
+
+      // Apply update directly to object
+      current[lastKey] = patch.value;
+      return true;
+    } catch (error) {
+      console.error(`Failed to apply patch at ${patch.path.join('.')}:`, error);
+      return false;
+    }
+  }
+  /**
+   * Check equality
+   */
+  private isEqual(a: unknown, b: unknown): boolean {
+    // Fast path for primitives
+    if (a === b) {
+      return true;
+    }
+    if (typeof a !== typeof b) {
+      return false;
+    }
+    if (typeof a !== 'object' || a === null || b === null) {
+      return false;
+    }
+
+    // Deep equality for objects (simple version)
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch {
+      return false;
+    }
+  }
+}

package/src/test-setup.ts

@@ -0,0 +1,6 @@
+import { setupZoneTestEnv } from 'jest-preset-angular/setup-env/zone';
+
+setupZoneTestEnv({
+  errorOnUnknownElements: true,
+  errorOnUnknownProperties: true,
+});

package/src/types/signaltree-core.d.ts

@@ -0,0 +1,4 @@
+declare module '@signaltree/core' {
+  export type { Enhancer } from '../../../core/src/lib/types';
+  export * from '../../../core/src/index';
+}

package/src/index.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib/diff-engine"), exports);
-tslib_1.__exportStar(require("./lib/path-index"), exports);
-tslib_1.__exportStar(require("./lib/update-engine"), exports);
-tslib_1.__exportStar(require("./lib/enterprise-enhancer"), exports);
-tslib_1.__exportStar(require("./lib/scheduler"), exports);
-tslib_1.__exportStar(require("./lib/thread-pools"), exports);
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/enterprise/src/index.ts"],"names":[],"mappings":";;;AAAA,4DAAkC;AAClC,2DAAiC;AACjC,8DAAoC;AACpC,oEAA0C;AAC1C,0DAAgC;AAChC,6DAAmC"}

package/src/lib/diff-engine.d.ts

@@ -1,108 +0,0 @@
-/**
- * DiffEngine - Efficient change detection for tree updates
- * @packageDocumentation
- */
-import type { Path } from './path-index';
-/**
- * Type of change detected
- */
-export declare enum ChangeType {
-    ADD = "add",
-    UPDATE = "update",
-    DELETE = "delete",
-    REPLACE = "replace"
-}
-/**
- * A detected change
- */
-export interface Change {
-    /** Type of change */
-    type: ChangeType;
-    /** Path to the changed value */
-    path: Path;
-    /** New value */
-    value?: unknown;
-    /** Old value (for updates/deletes) */
-    oldValue?: unknown;
-}
-/**
- * Diff result
- */
-export interface Diff {
-    /** List of changes */
-    changes: Change[];
-    /** Whether any changes were detected */
-    hasChanges: boolean;
-}
-/**
- * Configuration for diff operation
- */
-export interface DiffOptions {
-    /** Maximum depth to traverse */
-    maxDepth?: number;
-    /** Whether to detect deletions */
-    detectDeletions?: boolean;
-    /** Whether to ignore array order */
-    ignoreArrayOrder?: boolean;
-    /** Custom equality function */
-    equalityFn?: (a: unknown, b: unknown) => boolean;
-    /** Optional key validator for security (e.g., to prevent prototype pollution) */
-    keyValidator?: (key: string) => boolean;
-}
-/**
- * DiffEngine
- *
- * Efficiently detects changes between two objects to minimize unnecessary updates.
- *
- * Features:
- * - Deep object comparison
- * - Circular reference detection
- * - Configurable equality checking
- * - Array diffing (ordered and unordered)
- * - Path tracking for precise updates
- *
- * @example
- * ```ts
- * const engine = new DiffEngine();
- *
- * const current = { user: { name: 'Alice', age: 30 } };
- * const updates = { user: { name: 'Alice', age: 31 } };
- *
- * const diff = engine.diff(current, updates);
- *
- * console.log(diff.changes);
- * // [{ type: 'update', path: ['user', 'age'], value: 31, oldValue: 30 }]
- * ```
- */
-export declare class DiffEngine {
-    private defaultOptions;
-    /**
-     * Diff two objects and return changes
-     *
-     * @param current - Current state
-     * @param updates - Updated state
-     * @param options - Diff options
-     * @returns Diff result with all changes
-     */
-    diff(current: unknown, updates: unknown, options?: DiffOptions): Diff;
-    /**
-     * Traverse and compare objects recursively
-     */
-    private traverse;
-    /**
-     * Diff arrays
-     */
-    private diffArrays;
-    /**
-     * Diff arrays in order (index-based)
-     */
-    private diffArraysOrdered;
-    /**
-     * Diff arrays ignoring order (value-based)
-     */
-    private diffArraysUnordered;
-    /**
-     * Stringify value for set comparison
-     */
-    private stringify;
-}