@revisium/schema-toolkit 0.18.0 → 0.19.1

package/dist/{chunk-5FFJ2R3L.js → chunk-R6VYCHY2.js}

@@ -1412,12 +1412,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);
@@ -1427,9 +1422,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;
@@ -2019,19 +2029,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);
@@ -2039,10 +2061,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
@@ -2053,6 +2094,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) {
@@ -2240,7 +2317,9 @@ var PatchEnricher = class {
   constructor(currentTree, baseTree) {
     this.currentTree = currentTree;
     this.baseTree = baseTree;
+    this.extractors = this.buildExtractors();
   }
+  extractors;
   enrich(patch) {
     const fieldName = this.getFieldNameFromPath(patch.path);
     if (patch.op === "add") {
@@ -2257,18 +2336,13 @@ var PatchEnricher = class {
   enrichAddPatch(patch, fieldName) {
     const currentNode = this.getNodeAtPath(this.currentTree, patch.path);
     if (!currentNode) {
-      return { patch, fieldName, metadataChanges: [] };
+      return { patch, fieldName, propertyChanges: [] };
     }
-    const metadata = this.computeAddMetadata(currentNode);
-    return {
-      patch,
-      fieldName,
-      metadataChanges: this.computeMetadataChanges(metadata),
-      ...metadata
-    };
+    const propertyChanges = this.computeAddPropertyChanges(currentNode);
+    return { patch, fieldName, propertyChanges };
   }
   enrichRemovePatch(patch, fieldName) {
-    return { patch, fieldName, metadataChanges: [] };
+    return { patch, fieldName, propertyChanges: [] };
   }
   enrichMovePatch(patch, fieldName) {
     const fromPath = patch.from;
@@ -2276,98 +2350,98 @@ var PatchEnricher = class {
     const movesIntoArray = this.movesIntoArrayBoundary(fromPath, patch.path);
     const baseNode = this.getNodeAtPath(this.baseTree, fromPath);
     const currentNode = this.getNodeAtPath(this.currentTree, patch.path);
-    const formulaChange = this.computeFormulaChange(baseNode, currentNode);
-    const metadataChanges = [];
-    if (formulaChange) {
-      metadataChanges.push("formula");
-    }
+    const propertyChanges = this.computePropertyChanges(baseNode, currentNode);
     return {
       patch,
       fieldName,
-      metadataChanges,
+      propertyChanges,
       isRename: isRename || void 0,
-      movesIntoArray: movesIntoArray || void 0,
-      formulaChange
+      movesIntoArray: movesIntoArray || void 0
     };
   }
   enrichReplacePatch(patch, fieldName) {
     const baseNode = this.getNodeAtPath(this.baseTree, patch.path);
     const currentNode = this.getNodeAtPath(this.currentTree, patch.path);
     const isArrayMetadataPatch = baseNode?.isArray() && currentNode?.isArray();
-    const formulaChange = this.computeFormulaChange(baseNode, currentNode);
-    const defaultChange = isArrayMetadataPatch ? void 0 : this.computeDefaultChange(baseNode, currentNode);
-    const descriptionChange = this.computeDescriptionChange(baseNode, currentNode);
-    const deprecatedChange = this.computeDeprecatedChange(baseNode, currentNode);
-    const foreignKeyChange = this.computeForeignKeyChange(baseNode, currentNode);
-    const contentMediaTypeChange = this.computeContentMediaTypeChange(baseNode, currentNode);
-    const metadataChanges = this.computeMetadataChanges({
-      formulaChange,
-      defaultChange,
-      descriptionChange,
-      deprecatedChange,
-      foreignKeyChange,
-      contentMediaTypeChange
-    });
+    const skipProperties = isArrayMetadataPatch ? ["default"] : [];
+    const propertyChanges = this.computePropertyChanges(
+      baseNode,
+      currentNode,
+      { skipProperties }
+    );
     return {
       patch,
       fieldName,
-      metadataChanges,
-      typeChange: this.computeTypeChange(baseNode, currentNode, isArrayMetadataPatch),
-      formulaChange,
-      defaultChange,
-      descriptionChange,
-      deprecatedChange,
-      foreignKeyChange,
-      contentMediaTypeChange
+      propertyChanges,
+      typeChange: this.computeTypeChange(baseNode, currentNode, isArrayMetadataPatch)
     };
   }
-  computeAddMetadata(node) {
-    const result = {};
-    const formula = node.formula();
-    if (formula) {
-      result.formulaChange = {
-        fromFormula: void 0,
-        toFormula: this.getFormulaExpression(formula, this.currentTree, node.id()),
-        fromVersion: void 0,
-        toVersion: formula.version()
-      };
-    }
-    const defaultValue = node.defaultValue();
-    if (defaultValue !== void 0 && isPrimitiveDefault(defaultValue)) {
-      result.defaultChange = {
-        fromDefault: void 0,
-        toDefault: defaultValue
-      };
-    }
-    const meta = node.metadata();
-    if (meta.description) {
-      result.descriptionChange = {
-        fromDescription: void 0,
-        toDescription: meta.description
-      };
-    }
-    if (meta.deprecated) {
-      result.deprecatedChange = {
-        fromDeprecated: void 0,
-        toDeprecated: meta.deprecated
-      };
-    }
-    const foreignKey = node.foreignKey();
-    if (foreignKey) {
-      result.foreignKeyChange = {
-        fromForeignKey: void 0,
-        toForeignKey: foreignKey
-      };
-    }
-    const contentMediaType = node.contentMediaType();
-    if (contentMediaType) {
-      result.contentMediaTypeChange = {
-        fromContentMediaType: void 0,
-        toContentMediaType: contentMediaType
-      };
+  buildExtractors() {
+    return [
+      {
+        property: "formula",
+        extract: (node, tree) => {
+          const formula = node?.formula();
+          if (!formula || !node) {
+            return void 0;
+          }
+          return FormulaSerializer.serializeExpression(tree, node.id(), formula, { strict: false });
+        },
+        compare: (from, to) => from === to
+      },
+      {
+        property: "default",
+        extract: (node) => {
+          const value = node?.defaultValue();
+          return isPrimitiveDefault(value) ? value : void 0;
+        }
+      },
+      {
+        property: "description",
+        extract: (node) => node?.metadata().description
+      },
+      {
+        property: "deprecated",
+        extract: (node) => node?.metadata().deprecated
+      },
+      {
+        property: "foreignKey",
+        extract: (node) => node?.foreignKey()
+      },
+      {
+        property: "contentMediaType",
+        extract: (node) => node?.contentMediaType()
+      },
+      {
+        property: "ref",
+        extract: (node) => node?.ref()
+      },
+      {
+        property: "title",
+        extract: (node) => node?.metadata().title
+      }
+    ];
+  }
+  computePropertyChanges(baseNode, currentNode, options) {
+    const skipSet = options?.skipProperties;
+    const result = [];
+    for (const extractor of this.extractors) {
+      if (skipSet?.includes(extractor.property)) {
+        continue;
+      }
+      const from = extractor.extract(baseNode, this.baseTree);
+      const to = extractor.extract(currentNode, this.currentTree);
+      const areEqual = extractor.compare ? extractor.compare(from, to) : from === to;
+      if (!areEqual) {
+        result.push({ property: extractor.property, from, to });
+      }
     }
     return result;
   }
+  computeAddPropertyChanges(node) {
+    const allChanges = this.computePropertyChanges(null, node);
+    return allChanges.filter((change) => change.to !== void 0);
+  }
   computeTypeChange(baseNode, currentNode, ignoreItems) {
     if (!baseNode || !currentNode) {
       return void 0;
@@ -2386,98 +2460,6 @@ var PatchEnricher = class {
     }
     return void 0;
   }
-  computeFormulaChange(baseNode, currentNode) {
-    const baseFormula = baseNode?.formula();
-    const currentFormula = currentNode?.formula();
-    const baseExpr = baseFormula && baseNode ? this.getFormulaExpression(baseFormula, this.baseTree, baseNode.id()) : void 0;
-    const currentExpr = currentFormula && currentNode ? this.getFormulaExpression(currentFormula, this.currentTree, currentNode.id()) : void 0;
-    const baseVersion = baseFormula?.version();
-    const currentVersion = currentFormula?.version();
-    if (baseExpr !== currentExpr || baseVersion !== currentVersion) {
-      return {
-        fromFormula: baseExpr,
-        toFormula: currentExpr,
-        fromVersion: baseVersion,
-        toVersion: currentVersion
-      };
-    }
-    return void 0;
-  }
-  getFormulaExpression(formula, tree, nodeId) {
-    return FormulaSerializer.serializeExpression(tree, nodeId, formula, { strict: false });
-  }
-  computeDefaultChange(baseNode, currentNode) {
-    const baseDefault = baseNode?.defaultValue();
-    const currentDefault = currentNode?.defaultValue();
-    const safeBaseDefault = isPrimitiveDefault(baseDefault) ? baseDefault : void 0;
-    const safeCurrentDefault = isPrimitiveDefault(
-      currentDefault
-    ) ? currentDefault : void 0;
-    if (safeBaseDefault !== safeCurrentDefault) {
-      return {
-        fromDefault: safeBaseDefault,
-        toDefault: safeCurrentDefault
-      };
-    }
-    return void 0;
-  }
-  computeDescriptionChange(baseNode, currentNode) {
-    const baseDesc = baseNode?.metadata().description;
-    const currentDesc = currentNode?.metadata().description;
-    if (baseDesc !== currentDesc) {
-      return { fromDescription: baseDesc, toDescription: currentDesc };
-    }
-    return void 0;
-  }
-  computeDeprecatedChange(baseNode, currentNode) {
-    const baseDeprecated = baseNode?.metadata().deprecated;
-    const currentDeprecated = currentNode?.metadata().deprecated;
-    if (baseDeprecated !== currentDeprecated) {
-      return { fromDeprecated: baseDeprecated, toDeprecated: currentDeprecated };
-    }
-    return void 0;
-  }
-  computeForeignKeyChange(baseNode, currentNode) {
-    const baseFk = baseNode?.foreignKey();
-    const currentFk = currentNode?.foreignKey();
-    if (baseFk !== currentFk) {
-      return { fromForeignKey: baseFk, toForeignKey: currentFk };
-    }
-    return void 0;
-  }
-  computeContentMediaTypeChange(baseNode, currentNode) {
-    const baseMediaType = baseNode?.contentMediaType();
-    const currentMediaType = currentNode?.contentMediaType();
-    if (baseMediaType !== currentMediaType) {
-      return {
-        fromContentMediaType: baseMediaType,
-        toContentMediaType: currentMediaType
-      };
-    }
-    return void 0;
-  }
-  computeMetadataChanges(changes) {
-    const result = [];
-    if (changes.formulaChange) {
-      result.push("formula");
-    }
-    if (changes.defaultChange) {
-      result.push("default");
-    }
-    if (changes.descriptionChange) {
-      result.push("description");
-    }
-    if (changes.deprecatedChange) {
-      result.push("deprecated");
-    }
-    if (changes.foreignKeyChange) {
-      result.push("foreignKey");
-    }
-    if (changes.contentMediaTypeChange) {
-      result.push("contentMediaType");
-    }
-    return result;
-  }
   getNodeType(node) {
     if (node.isArray()) {
       const items = node.items();
@@ -2955,5 +2937,5 @@ function buildArrayItemsPath(parentPath) {
 }
 
 export { AbstractBasePath, ChangeCoalescer, ChangeCollector, CompositeRule, EMPTY_METADATA, EMPTY_PATH, EnumValidator, FIELD_NAME_ERROR_MESSAGE, ForeignKeyValidator, FormulaChangeDetector, FormulaDependencyIndex, FormulaPath, FormulaPathBuilder, FormulaSerializer, ItemsSegment, MaxLengthValidator, MaximumValidator, MinLengthValidator, MinimumValidator, NULL_NODE, NodePathIndex, ParsedFormula, PatchBuilder, PatchEnricher, PatchGenerator, PatternValidator, PropertySegment, RequiredValidator, ResolvedDependency, SchemaDiff, SchemaPropertyRule, SchemaSerializer, SchemaTruthyRule, ValidationEngine, ValidatorRegistry, ValidatorResolver, areNodesContentEqual, areNodesEqual, coalesceChanges, collectChanges, createArrayNode, createBooleanNode, createDefaultValidatorRegistry, createMobxProvider, createNumberNode, createObjectNode, createPath, createRefNode, createSchemaTree, createStringNode, createValidationEngine, isValidFieldName, jsonPointerToPath, jsonPointerToSegments, jsonPointerToSimplePath, makeAutoObservable, makeObservable, observable, reaction, resetReactivityProvider, runInAction, setReactivityProvider, validateFormulas, validateSchema };
-//# sourceMappingURL=chunk-5FFJ2R3L.js.map
-//# sourceMappingURL=chunk-5FFJ2R3L.js.map
+//# sourceMappingURL=chunk-R6VYCHY2.js.map
+//# sourceMappingURL=chunk-R6VYCHY2.js.map