@signaltree/enterprise 11.5.1 → 11.5.2

package/dist/lib/diff-engine.js

@@ -41,6 +41,11 @@ class DiffEngine {
     if (depth > opts.maxDepth) {
       return;
     }
+    if (typeof curr === 'function') {
+      try {
+        curr = curr();
+      } catch (_a) {}
+    }
     if (curr === upd) {
       return;
     }

package/dist/lib/path-index.js

@@ -142,10 +142,11 @@ class PathIndex {
       this.set(path, tree);
       return;
     }
-    if (typeof tree !== 'object') {
+    if (typeof tree !== 'object' && typeof tree !== 'function') {
       return;
     }
     for (const [key, value] of Object.entries(tree)) {
+      if (key.startsWith('_') || key === 'set' || key === 'update') continue;
       this.buildFromTree(value, [...path, key]);
     }
   }

package/dist/lib/update-engine.js

@@ -150,11 +150,26 @@ class OptimizedUpdateEngine {
       for (let i = 0; i < patch.path.length - 1; i++) {
         const key = patch.path[i];
         current = current[key];
-        if (!current || typeof current !== 'object') {
+        if (!current || typeof current !== 'object' && typeof current !== 'function') {
           return false;
         }
       }
       const lastKey = patch.path[patch.path.length - 1];
+      const target = current[lastKey];
+      if (target && (typeof target === 'function' || typeof target === 'object')) {
+        if (isSignal(target)) {
+          const leaf = target;
+          if (this.isEqual(leaf(), patch.value)) {
+            return false;
+          }
+          leaf.set(patch.value);
+          return true;
+        }
+        if (patch.value && typeof patch.value === 'object') {
+          return this.applyDeepToNode(target, patch.value);
+        }
+        return false;
+      }
       if (this.isEqual(current[lastKey], patch.value)) {
         return false;
       }
@@ -165,6 +180,23 @@ class OptimizedUpdateEngine {
       return false;
     }
   }
+  applyDeepToNode(node, value) {
+    if (!node) return false;
+    if (isSignal(node)) {
+      const leaf = node;
+      if (this.isEqual(leaf(), value)) return false;
+      leaf.set(value);
+      return true;
+    }
+    if ((typeof node === 'object' || typeof node === 'function') && value && typeof value === 'object') {
+      let changed = false;
+      for (const [key, child] of Object.entries(value)) {
+        changed = this.applyDeepToNode(node[key], child) || changed;
+      }
+      return changed;
+    }
+    return false;
+  }
   isEqual(a, b) {
     if (a === b) return true;
     if (typeof a !== typeof b) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/enterprise",
-  "version": "11.5.1",
+  "version": "11.5.2",
   "description": "Enterprise optimizations for SignalTree reactive JSON. Diff-based updates, bulk operations, and advanced change tracking for large-scale applications.",
   "license": "BUSL-1.1",
   "type": "module",
@@ -68,7 +68,7 @@
   },
   "peerDependencies": {
     "@angular/core": "^20.0.0 || ^21.0.0 || ^22.0.0",
-    "@signaltree/core": "^11.5.1",
+    "@signaltree/core": "^11.5.2",
     "tslib": "^2.0.0"
   },
   "peerDependenciesMeta": {},

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

@@ -28,5 +28,6 @@ export declare class OptimizedUpdateEngine {
     private applyPatches;
     private batchApplyPatches;
     private applyPatch;
+    private applyDeepToNode;
     private isEqual;
 }