@revisium/schema-toolkit 0.19.0 → 0.19.1

package/dist/{chunk-WJXVLFZN.cjs → chunk-U7N3EEQX.cjs}

@@ -1414,12 +1414,7 @@ var ChangeCoalescer = class {
   hasParentChange(change, allChanges, path) {
     for (const other of allChanges) {
       if (other === change) continue;
-      if (other.type === "modified") {
-        if (!this.isTypeChangeReplacement(other)) {
-          continue;
-        }
-      }
-      if (change.type === "moved" && other.type === "added") {
+      if (this.shouldSkipParentCandidate(change, other)) {
         continue;
       }
       const otherPath = this.getChangePath(other);
@@ -1429,9 +1424,24 @@ var ChangeCoalescer = class {
     }
     return false;
   }
+  shouldSkipParentCandidate(change, other) {
+    if (other.type === "modified" && !this.isTypeChangeReplacement(other)) {
+      return true;
+    }
+    if (change.type === "moved" && other.type === "added") {
+      return true;
+    }
+    if (change.type === "moved" && other.type === "moved") {
+      return this.hasIndependentRename(change);
+    }
+    return false;
+  }
   isTypeChangeReplacement(change) {
     return change.baseNode.nodeType() !== change.currentNode.nodeType();
   }
+  hasIndependentRename(change) {
+    return change.baseNode.name() !== change.currentNode.name();
+  }
   isAffectedByMove(change, movedPaths) {
     if (change.type !== "modified") {
       return false;
@@ -2021,19 +2031,31 @@ var PatchGenerator = class {
     return { prerequisiteAdds, regularAdds };
   }
   generateMovePatches(moved) {
+    const movedNodeIds = this.collectMovedNodeIds(moved);
+    const sorted = this.sortMovesParentFirst(moved);
     const patches = [];
-    for (const change of moved) {
+    const appliedMoves = [];
+    for (const change of sorted) {
       const basePath = this.baseTree.pathOf(change.baseNode.id());
       const currentPath = this.currentTree.pathOf(change.currentNode.id());
+      const adjustedFrom = this.adjustFromPath(
+        basePath.asJsonPointer(),
+        appliedMoves
+      );
       patches.push({
         op: "move",
-        from: basePath.asJsonPointer(),
+        from: adjustedFrom,
         path: currentPath.asJsonPointer()
       });
+      appliedMoves.push({
+        from: adjustedFrom,
+        to: currentPath.asJsonPointer()
+      });
       const modifyPatch = this.generateModifyAfterMove(
         change.baseNode,
         change.currentNode,
-        currentPath.asJsonPointer()
+        currentPath.asJsonPointer(),
+        movedNodeIds
       );
       if (modifyPatch) {
         patches.push(modifyPatch);
@@ -2041,10 +2063,29 @@ var PatchGenerator = class {
     }
     return patches;
   }
-  generateModifyAfterMove(baseNode, currentNode, currentPath) {
+  sortMovesParentFirst(moved) {
+    return [...moved].sort((a, b) => {
+      const pathA = this.baseTree.pathOf(a.baseNode.id()).asJsonPointer();
+      const pathB = this.baseTree.pathOf(b.baseNode.id()).asJsonPointer();
+      return pathA.length - pathB.length;
+    });
+  }
+  adjustFromPath(fromPath, appliedMoves) {
+    let adjusted = fromPath;
+    for (const move of appliedMoves) {
+      if (adjusted.startsWith(move.from + "/")) {
+        adjusted = move.to + adjusted.slice(move.from.length);
+      }
+    }
+    return adjusted;
+  }
+  generateModifyAfterMove(baseNode, currentNode, currentPath, siblingMovedIds) {
     if (areNodesContentEqual(currentNode, baseNode, this.context)) {
       return null;
     }
+    if (this.isDifferenceExplainedByMoves(currentNode, baseNode, siblingMovedIds)) {
+      return null;
+    }
     const currentSchema = this.serializer.serializeNode(
       currentNode,
       this.currentTree
@@ -2055,6 +2096,42 @@ var PatchGenerator = class {
       value: currentSchema
     };
   }
+  isDifferenceExplainedByMoves(currentNode, baseNode, movedIds) {
+    if (!currentNode.isObject() || !baseNode.isObject()) {
+      return false;
+    }
+    const currentProps = currentNode.properties();
+    const baseProps = baseNode.properties();
+    if (currentProps.length !== baseProps.length) {
+      return false;
+    }
+    for (const prop of currentProps) {
+      const matchByName = baseProps.find((b) => b.name() === prop.name());
+      if (matchByName) {
+        if (!this.areNodesEqualAccountingMoves(prop, matchByName, movedIds)) {
+          return false;
+        }
+        continue;
+      }
+      if (!movedIds.has(prop.id())) {
+        return false;
+      }
+      const matchById = baseProps.find((b) => b.id() === prop.id());
+      if (!matchById) {
+        return false;
+      }
+      if (!this.areNodesEqualAccountingMoves(prop, matchById, movedIds)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  areNodesEqualAccountingMoves(currentNode, baseNode, movedIds) {
+    if (areNodesContentEqual(currentNode, baseNode, this.context)) {
+      return true;
+    }
+    return this.isDifferenceExplainedByMoves(currentNode, baseNode, movedIds);
+  }
   generateAddPatches(added, movedNodeIds) {
     const patches = [];
     for (const change of added) {
@@ -2925,5 +3002,5 @@ exports.runInAction = runInAction;
 exports.setReactivityProvider = setReactivityProvider;
 exports.validateFormulas = validateFormulas;
 exports.validateSchema = validateSchema;
-//# sourceMappingURL=chunk-WJXVLFZN.cjs.map
-//# sourceMappingURL=chunk-WJXVLFZN.cjs.map
+//# sourceMappingURL=chunk-U7N3EEQX.cjs.map
+//# sourceMappingURL=chunk-U7N3EEQX.cjs.map