@itwin/ecschema-editing 5.0.0-dev.9 → 5.0.0-dev.92

package/lib/esm/Validation/SchemaComparer.js

@@ -0,0 +1,770 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Comparison
+ */
+import { classModifierToString, containerTypeToString, OverrideFormat, primitiveTypeToString, propertyTypeToString, SchemaItem, strengthDirectionToString, strengthToString, } from "@itwin/ecschema-metadata";
+import { formatTraitsToArray } from "@itwin/core-quantity";
+import { SchemaCompareResultDelegate } from "./SchemaCompareResultDelegate";
+import { SchemaCompareVisitor } from "./SchemaCompareVisitor";
+import { SchemaWalker } from "./SchemaWalker";
+/**
+ * Enum that identifies if Schema A is being iterated (Forward) or
+ * Schema B is being iterated (Backward);
+ * @alpha
+ */
+export var SchemaCompareDirection;
+(function (SchemaCompareDirection) {
+    SchemaCompareDirection[SchemaCompareDirection["Forward"] = 0] = "Forward";
+    SchemaCompareDirection[SchemaCompareDirection["Backward"] = 1] = "Backward";
+})(SchemaCompareDirection || (SchemaCompareDirection = {}));
+function labelsMatch(label1, label2) {
+    label1 = label1 === undefined ? "" : label1;
+    label2 = label2 === undefined ? "" : label2;
+    return label1 === label2;
+}
+/**
+ * Compares EC Schemas and reports differences using the [[IDiagnosticReporter]] objects
+ * specified.
+ * @alpha
+ */
+export class SchemaComparer {
+    _compareDirection;
+    _reporter;
+    _reporters;
+    /**
+     * Initializes a new SchemaComparer instance.
+     * @param reporters The [[IDiagnosticReporter]] object(s) to use to report the results.
+     */
+    constructor(...reporters) {
+        this._compareDirection = SchemaCompareDirection.Forward;
+        this._reporters = reporters;
+    }
+    /**
+     * Resolves a schema Item from the given lookup schema.
+     * @internal
+     */
+    async resolveItem(item, lookupSchema, itemConstructor) {
+        return lookupSchema.lookupItem(item.name, itemConstructor);
+    }
+    /**
+     * Resolves a property from a class.
+     * @internal
+     */
+    async resolveProperty(propertyA, ecClass) {
+        return ecClass.getProperty(propertyA.name);
+    }
+    /**
+     * Compares two schema items to determine if they are the same by name.
+     * @internal
+     */
+    areEqualByName(itemKeyA, itemKeyB) {
+        const nameA = itemKeyA ? itemKeyA.name.toUpperCase() : undefined;
+        const nameB = itemKeyB ? itemKeyB.name.toUpperCase() : undefined;
+        return nameA === nameB;
+    }
+    /**
+     * Compares two schemas to identify differences.
+     * @param schemaA The first Schema.
+     * @param schemaB The second Schema.
+     */
+    async compareSchemas(schemaA, schemaB) {
+        this._reporter = new SchemaCompareResultDelegate(schemaA, schemaB, ...this._reporters);
+        let visitor = new SchemaCompareVisitor(this, schemaB);
+        let walker = new SchemaWalker(visitor);
+        await walker.traverseSchema(schemaA);
+        this._compareDirection = SchemaCompareDirection.Backward;
+        visitor = new SchemaCompareVisitor(this, schemaA);
+        walker = new SchemaWalker(visitor);
+        await walker.traverseSchema(schemaB);
+        this._compareDirection = SchemaCompareDirection.Forward;
+        this._reporter.compareComplete();
+    }
+    /**
+     * Compares two schemas to identify differences between property values.
+     * @param schemaA The first Schema.
+     * @param schemaB The second Schema.
+     */
+    async compareSchemaProps(schemaA, schemaB) {
+        const promises = [];
+        for (const ref of schemaA.references) {
+            const refB = await schemaB.getReference(ref.fullName);
+            if (!refB)
+                promises.push(this._reporter.reportSchemaReferenceMissing(schemaA, ref, this._compareDirection));
+            else if (!refB.schemaKey.matches(ref.schemaKey))
+                promises.push(this._reporter.reportSchemaReferenceDelta(schemaA, ref, ref.schemaKey.version.toString(), refB.schemaKey.version.toString(), this._compareDirection));
+        }
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        if (schemaA.schemaKey.toString() !== schemaB.schemaKey.toString())
+            promises.push(this._reporter.reportSchemaDelta(schemaA, "schemaKey", schemaA.schemaKey.toString(), schemaB.schemaKey.toString(), this._compareDirection));
+        if (schemaA.alias !== schemaB.alias)
+            promises.push(this._reporter.reportSchemaDelta(schemaA, "alias", schemaA.alias, schemaB.alias, this._compareDirection));
+        if (schemaA.description !== schemaB.description)
+            promises.push(this._reporter.reportSchemaDelta(schemaA, "description", schemaA.description, schemaB.description, this._compareDirection));
+        if (schemaA.label !== schemaB.label)
+            promises.push(this._reporter.reportSchemaDelta(schemaA, "label", schemaA.label, schemaB.label, this._compareDirection));
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two SchemaItems to identify differences between property values.
+     * @param schemaItemA The first SchemaItem.
+     * @param schemaItemB The second SchemaItem.
+     */
+    async compareSchemaItems(schemaItemA, schemaItemB) {
+        const promises = [];
+        if (!schemaItemB) {
+            promises.push(this._reporter.reportSchemaItemMissing(schemaItemA, this._compareDirection));
+            await Promise.all(promises);
+            return;
+        }
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        if (schemaItemA.schemaItemType !== schemaItemB.schemaItemType) {
+            const aType = schemaItemA.schemaItemType;
+            const bType = schemaItemB.schemaItemType;
+            promises.push(this._reporter.reportSchemaItemDelta(schemaItemA, "schemaItemType", aType, bType, this._compareDirection));
+            await Promise.all(promises);
+            return;
+        }
+        if (schemaItemA.description !== schemaItemB.description)
+            promises.push(this._reporter.reportSchemaItemDelta(schemaItemA, "description", schemaItemA.description, schemaItemB.description, this._compareDirection));
+        if (!labelsMatch(schemaItemA.label, schemaItemB.label))
+            promises.push(this._reporter.reportSchemaItemDelta(schemaItemA, "label", schemaItemA.label, schemaItemB.label, this._compareDirection));
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two ECClasses to identify differences between property values.
+     * @param classA The first ECClass.
+     * @param classB The second ECClass.
+     */
+    async compareClasses(classA, classB) {
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        const promises = [];
+        if (classA.modifier !== classB.modifier) {
+            const aMod = classModifierToString(classA.modifier);
+            const bMod = classModifierToString(classB.modifier);
+            promises.push(this._reporter.reportClassDelta(classA, "modifier", aMod, bMod, this._compareDirection));
+        }
+        if (classA.baseClass || classB.baseClass) {
+            const fullNameA = classA.baseClass?.fullName;
+            const fullNameB = classB.baseClass?.fullName;
+            if (fullNameA !== fullNameB) {
+                const areSameByName = this.areItemsSameByName(classA.baseClass, classB.baseClass, classA.schema.name, classB.schema.name);
+                if (!areSameByName) {
+                    const baseA = await classA.baseClass;
+                    const baseB = await classB.baseClass;
+                    promises.push(this._reporter.reportBaseClassDelta(classA, baseA, baseB, this._compareDirection));
+                }
+            }
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two ECProperties to identify differences between property values.
+     * @param propertyA The first ECProperty.
+     * @param propertyB The second ECProperty.
+     */
+    async compareProperties(propertyA, propertyB) {
+        const promises = [];
+        if (!propertyB) {
+            promises.push(this._reporter.reportPropertyMissing(propertyA, this._compareDirection));
+            await Promise.all(promises);
+            return;
+        }
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        const propertyTypeA = propertyTypeToString(propertyA.propertyType);
+        const propertyTypeB = propertyTypeToString(propertyB.propertyType);
+        if (propertyTypeA !== propertyTypeB) {
+            promises.push(this._reporter.reportPropertyDelta(propertyA, "type", propertyTypeA, propertyTypeB, this._compareDirection));
+            await Promise.all(promises);
+            return;
+        }
+        if (!labelsMatch(propertyA.label, propertyB.label))
+            promises.push(this._reporter.reportPropertyDelta(propertyA, "label", propertyA.label, propertyB.label, this._compareDirection));
+        if (propertyA.description !== propertyB.description)
+            promises.push(this._reporter.reportPropertyDelta(propertyA, "description", propertyA.description, propertyB.description, this._compareDirection));
+        if (propertyA.isReadOnly !== propertyB.isReadOnly)
+            promises.push(this._reporter.reportPropertyDelta(propertyA, "isReadOnly", propertyA.isReadOnly, propertyB.isReadOnly, this._compareDirection));
+        if (propertyA.priority !== propertyB.priority)
+            promises.push(this._reporter.reportPropertyDelta(propertyA, "priority", propertyA.priority, propertyB.priority, this._compareDirection));
+        if (propertyA.category || propertyB.category) {
+            const catKeyA = propertyA.category?.fullName;
+            const catKeyB = propertyB.category?.fullName;
+            if (catKeyA !== catKeyB) {
+                const areSameByName = this.areItemsSameByName(propertyA.category, propertyB.category, propertyA.schema.name, propertyB.schema.name);
+                if (!areSameByName)
+                    promises.push(this._reporter.reportPropertyDelta(propertyA, "category", catKeyA, catKeyB, this._compareDirection));
+            }
+        }
+        if (propertyA.kindOfQuantity || propertyB.kindOfQuantity) {
+            const koqKeyA = propertyA.kindOfQuantity?.fullName;
+            const koqKeyB = propertyB.kindOfQuantity?.fullName;
+            if (koqKeyA !== koqKeyB) {
+                const areSameByName = this.areItemsSameByName(propertyA.kindOfQuantity, propertyB.kindOfQuantity, propertyA.schema.name, propertyB.schema.name);
+                if (!areSameByName)
+                    promises.push(this._reporter.reportPropertyDelta(propertyA, "kindOfQuantity", koqKeyA, koqKeyB, this._compareDirection));
+            }
+        }
+        promises.push(this.comparePropertyType(propertyA, propertyB));
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two EntityClass objects to identify differences between property values.
+     * @param entityA
+     * @param entityB
+     */
+    async compareEntityClasses(entityA, entityB) {
+        const promises = [];
+        for (const mixinA of entityA.mixins) {
+            if (-1 === entityB.mixins.findIndex((mixinB) => this.areItemsSameByName(mixinA, mixinB, entityA.schema.name, entityB.schema.name)))
+                promises.push(this._reporter.reportEntityMixinMissing(entityA, await mixinA, this._compareDirection));
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two Mixin objects to identify differences between property values.
+     * @param mixinA
+     * @param mixinB
+     */
+    async compareMixins(mixinA, mixinB) {
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        if (mixinA.appliesTo || mixinB.appliesTo) {
+            const appliesToA = mixinA.appliesTo?.fullName;
+            const appliesToB = mixinB.appliesTo?.fullName;
+            if (appliesToA !== appliesToB) {
+                const areSameByName = this.areItemsSameByName(mixinA.appliesTo, mixinB.appliesTo, mixinA.schema.name, mixinB.schema.name);
+                if (!areSameByName)
+                    await this._reporter.reportMixinDelta(mixinA, "appliesTo", appliesToA, appliesToB, this._compareDirection);
+            }
+        }
+    }
+    /**
+     * Compares two RelationshipClass objects to identify differences between property values.
+     * @param relationshipA
+     * @param relationshipB
+     */
+    async compareRelationshipClasses(relationshipA, relationshipB) {
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        const promises = [];
+        if (relationshipA.strength !== relationshipB.strength) {
+            const strengthAString = strengthToString(relationshipA.strength);
+            const strengthBString = strengthToString(relationshipB.strength);
+            promises.push(this._reporter.reportRelationshipClassDelta(relationshipA, "strength", strengthAString, strengthBString, this._compareDirection));
+        }
+        if (relationshipA.strengthDirection !== relationshipB.strengthDirection) {
+            const directionAString = strengthDirectionToString(relationshipA.strengthDirection);
+            const directionBString = strengthDirectionToString(relationshipB.strengthDirection);
+            promises.push(this._reporter.reportRelationshipClassDelta(relationshipA, "strengthDirection", directionAString, directionBString, this._compareDirection));
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two RelationshipConstraint objects to identify differences between property values.
+     * @param relationshipConstraintA
+     * @param relationshipConstraintB
+     */
+    async compareRelationshipConstraints(constraintA, constraintB) {
+        const promises = [];
+        if (constraintA.constraintClasses) {
+            for (const classA of constraintA.constraintClasses) {
+                if (!constraintB.constraintClasses || -1 === constraintB.constraintClasses.findIndex((classB) => this.areItemsSameByName(classA, classB, constraintA.schema.name, constraintB.schema.name)))
+                    promises.push(this._reporter.reportRelationshipConstraintClassMissing(constraintA, await classA, this._compareDirection));
+            }
+        }
+        if (this._compareDirection === SchemaCompareDirection.Backward) {
+            await Promise.all(promises);
+            return;
+        }
+        if (constraintA.multiplicity || constraintB.multiplicity) {
+            const multiplicityA = constraintA.multiplicity.toString();
+            const multiplicityB = constraintB.multiplicity.toString();
+            if (multiplicityA !== multiplicityB)
+                promises.push(this._reporter.reportRelationshipConstraintDelta(constraintA, "multiplicity", multiplicityA, multiplicityB, this._compareDirection));
+        }
+        if (constraintA.roleLabel !== constraintB.roleLabel)
+            promises.push(this._reporter.reportRelationshipConstraintDelta(constraintA, "roleLabel", constraintA.roleLabel, constraintB.roleLabel, this._compareDirection));
+        if (constraintA.polymorphic !== constraintB.polymorphic)
+            promises.push(this._reporter.reportRelationshipConstraintDelta(constraintA, "polymorphic", constraintA.polymorphic, constraintB.polymorphic, this._compareDirection));
+        if (constraintA.abstractConstraint || constraintB.abstractConstraint) {
+            const abstractA = constraintA.abstractConstraint?.fullName;
+            const abstractB = constraintB.abstractConstraint?.fullName;
+            if (abstractA !== abstractB) {
+                const areSameByName = this.areItemsSameByName(constraintA.abstractConstraint, constraintB.abstractConstraint, constraintA.schema.name, constraintB.schema.name);
+                if (!areSameByName) {
+                    promises.push(this._reporter.reportRelationshipConstraintDelta(constraintA, "abstractConstraint", abstractA, abstractB, this._compareDirection));
+                }
+            }
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two CustomAttributeClass objects to identify differences between property values.
+     * @param customAttributeClassA
+     * @param customAttributeClassB
+     */
+    async compareCustomAttributeClasses(customAttributeClassA, customAttributeClassB) {
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        if (customAttributeClassA.appliesTo !== customAttributeClassB.appliesTo) {
+            const typeA = containerTypeToString(customAttributeClassA.appliesTo);
+            const typeB = containerTypeToString(customAttributeClassB.appliesTo);
+            await this._reporter.reportCustomAttributeClassDelta(customAttributeClassA, "appliesTo", typeA, typeB, this._compareDirection);
+        }
+    }
+    /**
+     * Compares two CustomAttributeContainerProps objects to identify differences between property values.
+     * @param containerA
+     * @param containerB
+     */
+    async compareCustomAttributeContainers(containerA, containerB) {
+        const promises = [];
+        if (containerA.customAttributes) {
+            for (const ca of containerA.customAttributes) {
+                if (!containerB.customAttributes || !this.containerHasClass(ca[1], containerA, containerB))
+                    promises.push(this._reporter.reportCustomAttributeInstanceClassMissing(containerA, ca[1], this._compareDirection));
+            }
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two Enumeration objects to identify differences between property values.
+     * @param enumA
+     * @param enumB
+     */
+    async compareEnumerations(enumA, enumB) {
+        const promises = [];
+        for (const enumeratorA of enumA.enumerators) {
+            const enumeratorB = enumB.enumerators.find((e) => e.name === enumeratorA.name);
+            if (!enumeratorB) {
+                promises.push(this._reporter.reportEnumeratorMissing(enumA, enumeratorA, this._compareDirection));
+            }
+            else if (this._compareDirection === SchemaCompareDirection.Forward) {
+                promises.push(this.compareEnumerators(enumeratorA, enumeratorB, enumA, enumB));
+            }
+        }
+        if (this._compareDirection === SchemaCompareDirection.Backward) {
+            await Promise.all(promises);
+            return;
+        }
+        if (enumA.type !== enumB.type) {
+            const typeAString = enumA.type ? primitiveTypeToString(enumA.type) : undefined;
+            const typeBString = enumB.type ? primitiveTypeToString(enumB.type) : undefined;
+            promises.push(this._reporter.reportEnumerationDelta(enumA, "type", typeAString, typeBString, this._compareDirection));
+        }
+        if (enumA.isStrict !== enumB.isStrict)
+            promises.push(this._reporter.reportEnumerationDelta(enumA, "isStrict", enumA.isStrict, enumB.isStrict, this._compareDirection));
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two KindOfQuantity objects to identify differences between property values.
+     * @param koqA
+     * @param koqB
+     */
+    async compareKindOfQuantities(koqA, koqB) {
+        const promises = [];
+        if (koqA.presentationFormats) {
+            for (const unitA of koqA.presentationFormats) {
+                if (-1 === koqB.presentationFormats.findIndex((unitB) => this.areOverrideFormatsSameByName(unitA, unitB, koqA.schema.name, koqB.schema.name)))
+                    promises.push(this._reporter.reportPresentationUnitMissing(koqA, unitA, this._compareDirection));
+            }
+        }
+        if (this._compareDirection === SchemaCompareDirection.Backward) {
+            await Promise.all(promises);
+            return;
+        }
+        if (koqA.relativeError !== koqB.relativeError) {
+            promises.push(this._reporter.reportKoqDelta(koqA, "relativeError", koqA.relativeError, koqB.relativeError, this._compareDirection));
+        }
+        if (koqA.persistenceUnit || koqB.persistenceUnit) {
+            const unitNameA = koqA.persistenceUnit?.fullName;
+            const unitNameB = koqB.persistenceUnit?.fullName;
+            if (unitNameA !== unitNameB) {
+                const eqByName = this.areItemsSameByName(koqA.persistenceUnit, koqB.persistenceUnit, koqA.schema.name, koqB.schema.name);
+                if (!eqByName)
+                    promises.push(this._reporter.reportKoqDelta(koqA, "persistenceUnit", unitNameA, unitNameB, this._compareDirection));
+            }
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two PropertyCategory objects to identify differences between property values.
+     * @param categoryA
+     * @param categoryB
+     */
+    async comparePropertyCategories(categoryA, categoryB) {
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        if (categoryA.priority !== categoryB.priority)
+            await this._reporter.reportPropertyCategoryDelta(categoryA, "priority", categoryA.priority, categoryB.priority, this._compareDirection);
+    }
+    /**
+     * Compares two Format objects to identify differences between property values.
+     * @param formatA
+     * @param formatB
+     */
+    async compareFormats(formatA, formatB) {
+        const promises = [];
+        promises.push(this.compareFormatUnits(formatA, formatB));
+        if (this._compareDirection === SchemaCompareDirection.Backward) {
+            await Promise.all(promises);
+            return;
+        }
+        if (formatA.roundFactor !== formatB.roundFactor)
+            promises.push(this._reporter.reportFormatDelta(formatA, "roundFactor", formatA.roundFactor, formatB.roundFactor, this._compareDirection));
+        if (formatA.type !== formatB.type) {
+            const typeAString = formatA.type;
+            const typeBString = formatB.type;
+            promises.push(this._reporter.reportFormatDelta(formatA, "type", typeAString, typeBString, this._compareDirection));
+        }
+        if (formatA.precision !== formatB.precision)
+            promises.push(this._reporter.reportFormatDelta(formatA, "precision", formatA.precision, formatB.precision, this._compareDirection));
+        if (formatA.minWidth !== formatB.minWidth)
+            promises.push(this._reporter.reportFormatDelta(formatA, "minWidth", formatA.minWidth, formatB.minWidth, this._compareDirection));
+        if (formatA.scientificType !== formatB.scientificType) {
+            const typeAString = formatA.scientificType !== undefined ? formatA.scientificType : undefined;
+            const typeBString = formatB.scientificType !== undefined ? formatB.scientificType : undefined;
+            promises.push(this._reporter.reportFormatDelta(formatA, "scientificType", typeAString, typeBString, this._compareDirection));
+        }
+        if (formatA.showSignOption !== formatB.showSignOption) {
+            const optionA = formatA.showSignOption;
+            const optionB = formatB.showSignOption;
+            promises.push(this._reporter.reportFormatDelta(formatA, "showSignOption", optionA, optionB, this._compareDirection));
+        }
+        if (formatA.decimalSeparator !== formatB.decimalSeparator)
+            promises.push(this._reporter.reportFormatDelta(formatA, "decimalSeparator", formatA.decimalSeparator, formatB.decimalSeparator, this._compareDirection));
+        if (formatA.thousandSeparator !== formatB.thousandSeparator)
+            promises.push(this._reporter.reportFormatDelta(formatA, "thousandSeparator", formatA.thousandSeparator, formatB.thousandSeparator, this._compareDirection));
+        if (formatA.uomSeparator !== formatB.uomSeparator)
+            promises.push(this._reporter.reportFormatDelta(formatA, "uomSeparator", formatA.uomSeparator, formatB.uomSeparator, this._compareDirection));
+        if (formatA.stationSeparator !== formatB.stationSeparator)
+            promises.push(this._reporter.reportFormatDelta(formatA, "stationSeparator", formatA.stationSeparator, formatB.stationSeparator, this._compareDirection));
+        if (formatA.stationOffsetSize !== formatB.stationOffsetSize)
+            promises.push(this._reporter.reportFormatDelta(formatA, "stationOffsetSize", formatA.stationOffsetSize, formatB.stationOffsetSize, this._compareDirection));
+        if (formatA.formatTraits !== formatB.formatTraits) {
+            const traitsA = formatTraitsToArray(formatA.formatTraits);
+            const traitsB = formatTraitsToArray(formatB.formatTraits);
+            promises.push(this._reporter.reportFormatDelta(formatA, "formatTraits", traitsA.toString(), traitsB.toString(), this._compareDirection));
+        }
+        if (formatA.spacer !== formatB.spacer)
+            promises.push(this._reporter.reportFormatDelta(formatA, "spacer", formatA.spacer, formatB.spacer, this._compareDirection));
+        if (formatA.includeZero !== formatB.includeZero)
+            promises.push(this._reporter.reportFormatDelta(formatA, "includeZero", formatA.includeZero, formatB.includeZero, this._compareDirection));
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two Unit objects to identify differences between property values.
+     * @param unitA
+     * @param unitB
+     */
+    async compareUnits(unitA, unitB) {
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        const promises = [];
+        if (unitA.phenomenon || unitB.phenomenon) {
+            const fullNameA = unitA.phenomenon?.fullName;
+            const fullNameB = unitB.phenomenon?.fullName;
+            if (fullNameA !== fullNameB) {
+                const eqByName = this.areItemsSameByName(unitA.phenomenon, unitB.phenomenon, unitA.schema.name, unitB.schema.name);
+                if (!eqByName)
+                    promises.push(this._reporter.reportUnitDelta(unitA, "phenomenon", fullNameA, fullNameB, this._compareDirection));
+            }
+        }
+        if (unitA.unitSystem || unitB.unitSystem) {
+            const fullNameA = unitA.unitSystem?.fullName;
+            const fullNameB = unitB.unitSystem?.fullName;
+            if (fullNameA !== fullNameB) {
+                const eqByName = this.areItemsSameByName(unitA.unitSystem, unitB.unitSystem, unitA.schema.name, unitB.schema.name);
+                if (!eqByName)
+                    promises.push(this._reporter.reportUnitDelta(unitA, "unitSystem", fullNameA, fullNameB, this._compareDirection));
+            }
+        }
+        if (unitA.definition !== unitB.definition)
+            promises.push(this._reporter.reportUnitDelta(unitA, "definition", unitA.definition, unitB.definition, this._compareDirection));
+        if (unitA.numerator !== unitB.numerator)
+            promises.push(this._reporter.reportUnitDelta(unitA, "numerator", unitA.numerator, unitB.numerator, this._compareDirection));
+        if (unitA.denominator !== unitB.denominator)
+            promises.push(this._reporter.reportUnitDelta(unitA, "denominator", unitA.denominator, unitB.denominator, this._compareDirection));
+        if (unitA.offset !== unitB.offset)
+            promises.push(this._reporter.reportUnitDelta(unitA, "offset", unitA.offset, unitB.offset, this._compareDirection));
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two InvertedUnit objects to identify differences between property values.
+     * @param invertedUnitA
+     * @param invertedUnitB
+     */
+    async compareInvertedUnits(invertedUnitA, invertedUnitB) {
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        const promises = [];
+        if (invertedUnitA.invertsUnit || invertedUnitB.invertsUnit) {
+            const fullNameA = invertedUnitA.invertsUnit?.fullName;
+            const fullNameB = invertedUnitB.invertsUnit?.fullName;
+            if (fullNameA !== fullNameB) {
+                const eqByName = this.areItemsSameByName(invertedUnitA.invertsUnit, invertedUnitB.invertsUnit, invertedUnitA.schema.name, invertedUnitB.schema.name);
+                if (!eqByName)
+                    promises.push(this._reporter.reportInvertedUnitDelta(invertedUnitA, "invertsUnit", fullNameA, fullNameB, this._compareDirection));
+            }
+        }
+        if (invertedUnitA.unitSystem || invertedUnitB.unitSystem) {
+            const fullNameA = invertedUnitA.unitSystem?.fullName;
+            const fullNameB = invertedUnitB.unitSystem?.fullName;
+            if (fullNameA !== fullNameB) {
+                const eqByName = this.areItemsSameByName(invertedUnitA.unitSystem, invertedUnitB.unitSystem, invertedUnitA.schema.name, invertedUnitB.schema.name);
+                if (!eqByName)
+                    promises.push(this._reporter.reportInvertedUnitDelta(invertedUnitA, "unitSystem", fullNameA, fullNameB, this._compareDirection));
+            }
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Compares two Phenomenon objects to identify differences between property values.
+     * @param phenomenonA
+     * @param phenomenonB
+     */
+    async comparePhenomenons(phenomenonA, phenomenonB) {
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        if (phenomenonA.definition !== phenomenonB.definition)
+            await this._reporter.reportPhenomenonDelta(phenomenonA, "definition", phenomenonA.definition, phenomenonB.definition, this._compareDirection);
+    }
+    /**
+     * Compares two Constant objects to identify differences between property values.
+     * @param constantA
+     * @param constantB
+     */
+    async compareConstants(constantA, constantB) {
+        if (this._compareDirection === SchemaCompareDirection.Backward)
+            return;
+        const promises = [];
+        if (constantA.phenomenon || constantB.phenomenon) {
+            const fullNameA = constantA.phenomenon?.fullName;
+            const fullNameB = constantB.phenomenon?.fullName;
+            if (fullNameA !== fullNameB) {
+                const eqByName = this.areItemsSameByName(constantA.phenomenon, constantB.phenomenon, constantA.schema.name, constantB.schema.name);
+                if (!eqByName)
+                    promises.push(this._reporter.reportConstantDelta(constantA, "phenomenon", fullNameA, fullNameB, this._compareDirection));
+            }
+        }
+        if (constantA.definition !== constantB.definition)
+            promises.push(this._reporter.reportConstantDelta(constantA, "definition", constantA.definition, constantB.definition, this._compareDirection));
+        if (constantA.numerator !== constantB.numerator)
+            promises.push(this._reporter.reportConstantDelta(constantA, "numerator", constantA.numerator, constantB.numerator, this._compareDirection));
+        if (constantA.denominator !== constantB.denominator)
+            promises.push(this._reporter.reportConstantDelta(constantA, "denominator", constantA.denominator, constantB.denominator, this._compareDirection));
+        await Promise.all(promises);
+    }
+    async comparePropertyType(propertyA, propertyB) {
+        const promises = [];
+        if (propertyA.isArray()) {
+            const minOccursB = propertyB.isArray() ? propertyB.minOccurs : undefined;
+            if (propertyA.minOccurs !== minOccursB) {
+                promises.push(this._reporter.reportPropertyDelta(propertyA, "minOccurs", propertyA.minOccurs, minOccursB, this._compareDirection));
+            }
+            const maxOccursB = propertyB.isArray() ? propertyB.maxOccurs : undefined;
+            if (propertyA.maxOccurs !== maxOccursB) {
+                promises.push(this._reporter.reportPropertyDelta(propertyA, "maxOccurs", propertyA.maxOccurs, maxOccursB, this._compareDirection));
+            }
+        }
+        if (propertyA.isEnumeration()) {
+            const enumerationB = propertyB.isEnumeration() ? propertyB.enumeration : undefined;
+            if (propertyA.enumeration || enumerationB) {
+                const enumA = propertyA.enumeration?.fullName;
+                const enumB = enumerationB?.fullName;
+                if (enumA !== enumB) {
+                    const areSameByName = this.areItemsSameByName(propertyA.enumeration, enumerationB, propertyA.schema.name, propertyB.schema.name);
+                    if (!areSameByName) {
+                        promises.push(this._reporter.reportPropertyDelta(propertyA, "enumeration", enumA, enumB, this._compareDirection));
+                    }
+                }
+            }
+        }
+        if (propertyA.isNavigation()) {
+            const strengthDirectionB = propertyB.isNavigation() ? propertyB.direction : undefined;
+            if (propertyA.direction !== strengthDirectionB) {
+                const dirA = strengthDirectionToString(propertyA.direction);
+                const dirB = strengthDirectionB !== undefined ? strengthDirectionToString(strengthDirectionB) : undefined;
+                promises.push(this._reporter.reportPropertyDelta(propertyA, "direction", dirA, dirB, this._compareDirection));
+            }
+            if (propertyA.relationshipClass) { // eslint-disable-line @typescript-eslint/no-misused-promises
+                const relationshipClassB = propertyB.isNavigation() ? propertyB.relationshipClass : undefined;
+                const relA = propertyA.relationshipClass.fullName;
+                const relB = relationshipClassB ? relationshipClassB.fullName : undefined;
+                if (relA !== relB) {
+                    const areSameByName = this.areItemsSameByName(propertyA.relationshipClass, relationshipClassB, propertyA.schema.name, propertyB.schema.name);
+                    if (!areSameByName)
+                        promises.push(this._reporter.reportPropertyDelta(propertyA, "relationshipClass", relA, relB, this._compareDirection));
+                }
+            }
+        }
+        if (propertyA.isPrimitive()) {
+            const primitiveTypeB = propertyB.isPrimitive() ? propertyB.primitiveType : undefined;
+            if (propertyA.primitiveType !== primitiveTypeB) {
+                const aType = primitiveTypeToString(propertyA.primitiveType);
+                const bType = primitiveTypeB !== undefined ? primitiveTypeToString(primitiveTypeB) : undefined;
+                promises.push(this._reporter.reportPropertyDelta(propertyA, "primitiveType", aType, bType, this._compareDirection));
+            }
+            const minLengthB = propertyB.isPrimitive() ? propertyB.minLength : undefined;
+            if (propertyA.minLength !== minLengthB) {
+                promises.push(this._reporter.reportPropertyDelta(propertyA, "minLength", propertyA.minLength, minLengthB, this._compareDirection));
+            }
+            // valid for primitive and enumeration properties
+            const maxLengthB = propertyB.isPrimitive() ? propertyB.maxLength : undefined;
+            if (propertyA.maxLength !== maxLengthB) {
+                promises.push(this._reporter.reportPropertyDelta(propertyA, "maxLength", propertyA.maxLength, maxLengthB, this._compareDirection));
+            }
+            const minValueB = propertyB.isPrimitive() ? propertyB.minValue : undefined;
+            if (propertyA.minValue !== minValueB) {
+                promises.push(this._reporter.reportPropertyDelta(propertyA, "minValue", propertyA.minValue, minValueB, this._compareDirection));
+            }
+            const maxValueB = propertyB.isPrimitive() ? propertyB.maxValue : undefined;
+            if (propertyA.maxValue !== maxValueB) {
+                promises.push(this._reporter.reportPropertyDelta(propertyA, "maxValue", propertyA.maxValue, maxValueB, this._compareDirection));
+            }
+            const extendedTypeNameB = propertyB.isPrimitive() ? propertyB.extendedTypeName : undefined;
+            if (propertyA.extendedTypeName !== extendedTypeNameB) {
+                promises.push(this._reporter.reportPropertyDelta(propertyA, "extendedTypeName", propertyA.extendedTypeName, extendedTypeNameB, this._compareDirection));
+            }
+        }
+        if (propertyA.isStruct()) {
+            const structA = propertyA.structClass;
+            const structB = propertyB.isStruct() ? propertyB.structClass : undefined;
+            if (structA || structB) {
+                const structNameA = structA.fullName;
+                const structNameB = structB?.fullName;
+                if (structNameA !== structNameB) {
+                    const areSameByName = this.areItemsSameByName(structA.key, structB?.key, propertyA.schema.name, propertyB.schema.name);
+                    if (!areSameByName) {
+                        promises.push(this._reporter.reportPropertyDelta(propertyA, "structClass", structNameA, structNameB, this._compareDirection));
+                    }
+                }
+            }
+        }
+        await Promise.all(promises);
+    }
+    async compareEnumerators(enumeratorA, enumeratorB, enumA, enumB) {
+        const promises = [];
+        if (enumeratorA.description !== enumeratorB.description)
+            promises.push(this._reporter.reportEnumeratorDelta(enumA, enumeratorA, "description", enumeratorA.description, enumeratorB.description, this._compareDirection));
+        if (!labelsMatch(enumeratorA.label, enumeratorB.label))
+            promises.push(this._reporter.reportEnumeratorDelta(enumA, enumeratorA, "label", enumeratorA.label, enumeratorB.label, this._compareDirection));
+        // No need to compare values if the type is different (which will be reported separately)
+        if (enumA.type === enumB.type && enumeratorA.value !== enumeratorB.value)
+            promises.push(this._reporter.reportEnumeratorDelta(enumA, enumeratorA, "value", enumeratorA.value, enumeratorB.value, this._compareDirection));
+        await Promise.all(promises);
+    }
+    async compareFormatUnits(formatA, formatB) {
+        if (!formatA.units)
+            return;
+        const promises = [];
+        for (const unitA of formatA.units) {
+            const unitB = formatB.units ? formatB.units.find((u) => this.areItemsSameByName(unitA[0], u[0], formatA.schema.name, formatB.schema.name)) : undefined;
+            if (!unitB) {
+                promises.push(this._reporter.reportFormatUnitMissing(formatA, unitA, this._compareDirection));
+                continue;
+            }
+            if (this._compareDirection === SchemaCompareDirection.Backward)
+                continue;
+            if (unitA[1] !== unitB[1]) {
+                const labelA = unitA[1];
+                const labelB = unitB[1];
+                promises.push(this._reporter.reportUnitLabelOverrideDelta(formatA, unitA[0], labelA, labelB, this._compareDirection));
+            }
+        }
+        await Promise.all(promises);
+    }
+    areOverrideFormatsSameByName(itemKeyA, itemKeyB, topLevelSchemaNameA, topLevelSchemaNameB) {
+        if (itemKeyA.units) {
+            for (const unitA of itemKeyA.units) {
+                if (!itemKeyB.units
+                    || -1 === itemKeyB.units.findIndex((unitB) => this.areItemsSameByName(unitA[0], unitB[0], topLevelSchemaNameA, topLevelSchemaNameB)
+                        && unitA[1] === unitB[1]))
+                    return false;
+            }
+        }
+        const itemA = OverrideFormat.isOverrideFormat(itemKeyA) ? itemKeyA.parent : itemKeyA;
+        const itemB = OverrideFormat.isOverrideFormat(itemKeyB) ? itemKeyB.parent : itemKeyB;
+        return itemKeyA.precision === itemKeyB.precision && this.areItemsSameByName(itemA, itemB, topLevelSchemaNameA, topLevelSchemaNameB);
+    }
+    /**
+     * Compares two item keys.
+     * @param itemKeyA item key A to compare to.
+     * @param itemKeyB item key B to compare to.
+     * @param topLevelSchemaNameA top level schema name in which the item A exists.
+     * @param topLevelSchemaNameB top level schema name in which the item B exists.
+     * @returns true if both names are the same and they come from their respective top level schema.
+     */
+    areItemsSameByName(itemKeyA, itemKeyB, topLevelSchemaNameA, topLevelSchemaNameB) {
+        const equalByName = this.areEqualByName(itemKeyA, itemKeyB);
+        const schemaNameA = itemKeyA
+            ? SchemaItem.isSchemaItem(itemKeyA)
+                ? itemKeyA.schema.name
+                : itemKeyA.schemaName
+            : undefined;
+        const schemaNameB = itemKeyB
+            ? SchemaItem.isSchemaItem(itemKeyB)
+                ? itemKeyB.schema.name
+                : itemKeyB.schemaName
+            : undefined;
+        return (equalByName && schemaNameA === topLevelSchemaNameA && schemaNameB === topLevelSchemaNameB) || (equalByName && schemaNameA === schemaNameB);
+    }
+    /**
+     * Looks for same classA in containerB using key.
+     * @param classNameA name of the class to look for in containerB.
+     * @param containerA container which classNameA belongs to.
+     * @param containerB container in which to look for classNameA.
+     * @returns true if a same classA is in containerB, otherwise false.
+     */
+    containerHasClass(attributeA, containerA, containerB) {
+        if (containerB && containerB.customAttributes) {
+            for (const [_className, attributeB] of containerB.customAttributes) {
+                const classItemKeyA = containerA.schema.getSchemaItemKey(attributeA.className);
+                const classItemKeyB = containerB.schema.getSchemaItemKey(attributeB.className);
+                if (this.areItemsSameByName(classItemKeyA, classItemKeyB, containerA.schema.name, containerB.schema.name)) {
+                    return Object.keys(attributeA).every((propertyName) => {
+                        const valueA = attributeA[propertyName];
+                        const valueB = attributeB[propertyName];
+                        // If propertyName is class name, they don't need to be compared as this has been done
+                        // in the areItemsSameByName function.
+                        if (propertyName === "className")
+                            return true;
+                        return deepEquals(valueA, valueB);
+                    });
+                }
+            }
+        }
+        return false;
+    }
+}
+/**
+ * Compares two values on their deep equality.
+ * @param a   left side to compare
+ * @param b   right side to compare
+ * @returns   true if they are deeply equal, otherwise false.
+ */
+function deepEquals(a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((value, index) => {
+            return deepEquals(value, b[index]);
+        });
+    }
+    if (isObject(a) && isObject(b)) {
+        const propertiesA = Object.keys(a);
+        const propertiesB = Object.keys(b);
+        return propertiesA.length === propertiesB.length && propertiesA.every((propertyName) => {
+            return deepEquals(a[propertyName], b[propertyName]);
+        });
+    }
+    return a === b;
+}
+function isObject(value) {
+    return typeof value === "object";
+}
+//# sourceMappingURL=SchemaComparer.js.map