@revisium/schema-toolkit 0.18.0 → 0.19.0

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

@@ -2240,7 +2240,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 +2259,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 +2273,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 +2383,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 +2860,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-EPFW6FVB.js.map
+//# sourceMappingURL=chunk-EPFW6FVB.js.map