@itwin/ecschema-metadata 4.0.0-dev.52 → 4.0.0-dev.55

package/lib/cjs/UnitProvider/SchemaUnitProvider.js

@@ -1,235 +1,235 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaUnitProvider = void 0;
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-const core_bentley_1 = require("@itwin/core-bentley");
-const Context_1 = require("../Context");
-const SchemaItem_1 = require("../Metadata/SchemaItem");
-const SchemaKey_1 = require("../SchemaKey");
-const Unit_1 = require("../Metadata/Unit");
-const ECObjects_1 = require("../ECObjects");
-const UnitConverter_1 = require("../UnitConversion/UnitConverter");
-/**
- * Class used to find Units in SchemaContext by attributes such as Phenomenon and DisplayLabel.
- * @alpha
- */
-class SchemaUnitProvider {
-    /**
-     *
-     * @param contextOrLocater The SchemaContext or a different ISchemaLocater implementation used to retrieve the schema. The SchemaContext
-     * class implements the ISchemaLocater interface. If the provided locater is not a SchemaContext instance a new SchemaContext will be
-     * created and the locater will be added.
-     * @param _unitExtraData Additional data like alternate display label not found in Units Schema to match with Units; Defaults to empty array.
-     */
-    constructor(contextOrLocater, _unitExtraData = []) {
-        this._unitExtraData = _unitExtraData;
-        if (contextOrLocater instanceof Context_1.SchemaContext) {
-            this._context = contextOrLocater;
-        }
-        else {
-            this._context = new Context_1.SchemaContext();
-            this._context.addLocater(contextOrLocater);
-        }
-        this._unitConverter = new UnitConverter_1.UnitConverter(this._context);
-    }
-    /**
-     * Find unit in a schema that has unitName.
-     * @param unitName Full name of unit.
-     * @returns UnitProps interface from @itwin/core-quantity whose name matches unitName.
-     */
-    async findUnitByName(unitName) {
-        const unit = await this.findECUnitByName(unitName);
-        return this.getUnitsProps(unit);
-    }
-    /**
-     * Find all units in context that belongs to given phenomenon.
-     * @param phenomenon Full name of phenomenon.
-     * @returns Array of UnitProps (from @itwin/core-quantity) interface objects whose name matches phenomenon param.
-     */
-    async getUnitsByFamily(phenomenon) {
-        // Check if schema exists and phenomenon exists in schema
-        const [schemaName, schemaItemName] = SchemaItem_1.SchemaItem.parseFullName(phenomenon);
-        const schemaKey = new SchemaKey_1.SchemaKey(schemaName);
-        const schema = await this._context.getSchema(schemaKey);
-        if (!schema) {
-            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find schema for phenomenon", () => {
-                return { phenomenon, schema: schemaName };
-            });
-        }
-        const itemKey = new SchemaKey_1.SchemaItemKey(schemaItemName, schema.schemaKey);
-        const phenom = await this._context.getSchemaItem(itemKey);
-        if (!phenom)
-            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find schema item/phenomenon", () => {
-                return { item: schemaItemName, schema: schemaName };
-            });
-        if (phenom.schemaItemType !== ECObjects_1.SchemaItemType.Phenomenon)
-            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Item is not a phenomenon", () => {
-                return { itemType: phenom.key.fullName };
-            });
-        // Find units' full name that match given phenomenon param.
-        const filteredUnits = [];
-        const schemaItems = this._context.getSchemaItems();
-        let { value, done } = schemaItems.next();
-        while (!done) {
-            if (Unit_1.Unit.isUnit(value)) {
-                const foundPhenomenon = await value.phenomenon;
-                if (foundPhenomenon && foundPhenomenon.key.matchesFullName(phenomenon)) {
-                    const unitProps = this.getUnitsProps(value);
-                    filteredUnits.push(unitProps);
-                }
-            }
-            ({ value, done } = schemaItems.next());
-        }
-        return filteredUnits;
-    }
-    /**
-     * Find alternate display labels associated with unitName, if any.
-     * @param unitName Full name of Unit.
-     */
-    getAlternateDisplayLabels(unitName) {
-        let alternateLabels = [];
-        for (const entry of this._unitExtraData) {
-            if (entry.name.toLowerCase() === unitName.toLowerCase()) {
-                alternateLabels = entry.altDisplayLabels;
-            }
-        }
-        return alternateLabels;
-    }
-    /**
-     * Finds Unit by unitLabel, which could be a display label in the schema or alternate an display label defined in
-     * this._unitExtraData. If there are duplicates of the same display label in the context or teh same alternate display
-     * labels, specify schemaName, phenomenon, or unitSystem to get a specific unit.
-     *
-     * @param unitLabel Display label or alternate display label to query unit by.
-     * @param schemaName Ensure Unit with unitLabel belongs to Schema with schemaName.
-     * @param phenomenon Full name of phenomenon that Unit belongs to.
-     * @param unitSystem Full name of unitSystem that Unit belongs to.
-     * @returns The UnitProps interface from the @itwin/core-quantity package.
-     */
-    async findUnit(unitLabel, schemaName, phenomenon, unitSystem) {
-        const findLabel = unitLabel.toLowerCase();
-        const findSchema = schemaName ? schemaName.toLowerCase() : undefined;
-        const findPhenomenon = phenomenon ? phenomenon.toLowerCase() : undefined;
-        const findUnitSystem = unitSystem ? unitSystem.toLowerCase() : undefined;
-        let foundUnit;
-        try {
-            try {
-                foundUnit = await this.findUnitByDisplayLabel(findLabel, findSchema, findPhenomenon, findUnitSystem);
-            }
-            catch (err) {
-                // If there is no Unit with display label that matches label, then check for alternate display labels that may match
-                foundUnit = await this.findUnitByAltDisplayLabel(findLabel, findSchema, findPhenomenon, findUnitSystem);
-            }
-        }
-        catch (err) {
-            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find unit with label", () => {
-                return { unitLabel };
-            });
-        }
-        return this.getUnitsProps(foundUnit);
-    }
-    /**
-     * Gets the @itwin/core-quantity UnitConversion for the given fromUnit and toUnit.
-     * @param fromUnit The UnitProps of the 'from' unit.
-     * @param toUnit The UnitProps of the 'to' unit.
-     * @returns The UnitConversion interface from the @itwin/core-quantity package.
-     */
-    async getConversion(fromUnit, toUnit) {
-        const conversion = await this._unitConverter.calculateConversion(fromUnit.name, toUnit.name);
-        return {
-            factor: conversion.factor,
-            offset: conversion.offset,
-        };
-    }
-    /**
-     * Find unit in a schema that has unitName.
-     * @param unitName Full name of unit.
-     * @returns Unit whose full name matches unitName.
-     */
-    async findECUnitByName(unitName) {
-        // Check if schema exists and unit exists in schema
-        const [schemaName, schemaItemName] = SchemaItem_1.SchemaItem.parseFullName(unitName);
-        const schemaKey = new SchemaKey_1.SchemaKey(schemaName);
-        const schema = await this._context.getSchema(schemaKey);
-        if (!schema) {
-            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find schema for unit", () => {
-                return { schema: schemaName, unit: unitName };
-            });
-        }
-        const itemKey = new SchemaKey_1.SchemaItemKey(schemaItemName, schema.schemaKey);
-        const item = await this._context.getSchemaItem(itemKey);
-        if (!item)
-            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find schema item/unit", () => {
-                return { item: schemaItemName, schema: schemaName };
-            });
-        if (item.schemaItemType === ECObjects_1.SchemaItemType.Unit)
-            return item;
-        throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Item is not a unit", () => {
-            return { itemType: item.key.fullName };
-        });
-    }
-    /**
-     * Gets the @itwin/core UnitProps for the given Unit.
-     * @param unit The Unit to convert.
-     * @returns UnitProps interface from @itwin/core.
-     */
-    getUnitsProps(unit) {
-        return {
-            name: unit.fullName,
-            label: unit.label ?? "",
-            phenomenon: unit.phenomenon ? unit.phenomenon.fullName : "",
-            isValid: true,
-            system: unit.unitSystem === undefined ? "" : unit.unitSystem.fullName,
-        };
-    }
-    /**
-     * Finds Unit by displayLabel and that it belongs to schemaName, phenomenon, and unitSystem if defined.
-     * @internal
-     */
-    async findUnitByDisplayLabel(displayLabel, schemaName, phenomenon, unitSystem) {
-        const schemaItems = this._context.getSchemaItems();
-        let { value, done } = schemaItems.next();
-        while (!done) {
-            if (Unit_1.Unit.isUnit(value) && value.label?.toLowerCase() === displayLabel) {
-                const currPhenomenon = await value.phenomenon;
-                const currUnitSystem = await value.unitSystem;
-                if (!schemaName || value.schema.name.toLowerCase() === schemaName)
-                    if (!phenomenon || (currPhenomenon && currPhenomenon.key.matchesFullName(phenomenon)))
-                        if (!unitSystem || (currUnitSystem && currUnitSystem.key.matchesFullName(unitSystem)))
-                            return value;
-            }
-            ({ value, done } = schemaItems.next());
-        }
-        throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find unit with display label", () => {
-            return { displayLabel };
-        });
-    }
-    /**
-     * Finds Unit by altDisplayLabel and that it belongs to schemaName, phenomenon, and unitSystem if defined.
-     * @internal
-     */
-    async findUnitByAltDisplayLabel(altDisplayLabel, schemaName, phenomenon, unitSystem) {
-        for (const entry of this._unitExtraData) {
-            if (entry.altDisplayLabels && entry.altDisplayLabels.length > 0) {
-                if (entry.altDisplayLabels.findIndex((ref) => ref.toLowerCase() === altDisplayLabel) !== -1) {
-                    // Found altDisplayLabel that matches label to find
-                    const unit = await this.findECUnitByName(entry.name);
-                    const foundPhenomenon = await unit.phenomenon;
-                    const foundUnitSystem = await unit.unitSystem;
-                    if (!schemaName || unit.schema.name.toLowerCase() === schemaName)
-                        if (!phenomenon || (foundPhenomenon && foundPhenomenon.key.matchesFullName(phenomenon)))
-                            if (!unitSystem || (foundUnitSystem && foundUnitSystem.key.matchesFullName(unitSystem)))
-                                return unit;
-                }
-            }
-        }
-        throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find unit with alternate display label", () => {
-            return { altDisplayLabel };
-        });
-    }
-}
-exports.SchemaUnitProvider = SchemaUnitProvider;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaUnitProvider = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+const core_bentley_1 = require("@itwin/core-bentley");
+const Context_1 = require("../Context");
+const SchemaItem_1 = require("../Metadata/SchemaItem");
+const SchemaKey_1 = require("../SchemaKey");
+const Unit_1 = require("../Metadata/Unit");
+const ECObjects_1 = require("../ECObjects");
+const UnitConverter_1 = require("../UnitConversion/UnitConverter");
+/**
+ * Class used to find Units in SchemaContext by attributes such as Phenomenon and DisplayLabel.
+ * @alpha
+ */
+class SchemaUnitProvider {
+    /**
+     *
+     * @param contextOrLocater The SchemaContext or a different ISchemaLocater implementation used to retrieve the schema. The SchemaContext
+     * class implements the ISchemaLocater interface. If the provided locater is not a SchemaContext instance a new SchemaContext will be
+     * created and the locater will be added.
+     * @param _unitExtraData Additional data like alternate display label not found in Units Schema to match with Units; Defaults to empty array.
+     */
+    constructor(contextOrLocater, _unitExtraData = []) {
+        this._unitExtraData = _unitExtraData;
+        if (contextOrLocater instanceof Context_1.SchemaContext) {
+            this._context = contextOrLocater;
+        }
+        else {
+            this._context = new Context_1.SchemaContext();
+            this._context.addLocater(contextOrLocater);
+        }
+        this._unitConverter = new UnitConverter_1.UnitConverter(this._context);
+    }
+    /**
+     * Find unit in a schema that has unitName.
+     * @param unitName Full name of unit.
+     * @returns UnitProps interface from @itwin/core-quantity whose name matches unitName.
+     */
+    async findUnitByName(unitName) {
+        const unit = await this.findECUnitByName(unitName);
+        return this.getUnitsProps(unit);
+    }
+    /**
+     * Find all units in context that belongs to given phenomenon.
+     * @param phenomenon Full name of phenomenon.
+     * @returns Array of UnitProps (from @itwin/core-quantity) interface objects whose name matches phenomenon param.
+     */
+    async getUnitsByFamily(phenomenon) {
+        // Check if schema exists and phenomenon exists in schema
+        const [schemaName, schemaItemName] = SchemaItem_1.SchemaItem.parseFullName(phenomenon);
+        const schemaKey = new SchemaKey_1.SchemaKey(schemaName);
+        const schema = await this._context.getSchema(schemaKey);
+        if (!schema) {
+            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find schema for phenomenon", () => {
+                return { phenomenon, schema: schemaName };
+            });
+        }
+        const itemKey = new SchemaKey_1.SchemaItemKey(schemaItemName, schema.schemaKey);
+        const phenom = await this._context.getSchemaItem(itemKey);
+        if (!phenom)
+            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find schema item/phenomenon", () => {
+                return { item: schemaItemName, schema: schemaName };
+            });
+        if (phenom.schemaItemType !== ECObjects_1.SchemaItemType.Phenomenon)
+            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Item is not a phenomenon", () => {
+                return { itemType: phenom.key.fullName };
+            });
+        // Find units' full name that match given phenomenon param.
+        const filteredUnits = [];
+        const schemaItems = this._context.getSchemaItems();
+        let { value, done } = schemaItems.next();
+        while (!done) {
+            if (Unit_1.Unit.isUnit(value)) {
+                const foundPhenomenon = await value.phenomenon;
+                if (foundPhenomenon && foundPhenomenon.key.matchesFullName(phenomenon)) {
+                    const unitProps = this.getUnitsProps(value);
+                    filteredUnits.push(unitProps);
+                }
+            }
+            ({ value, done } = schemaItems.next());
+        }
+        return filteredUnits;
+    }
+    /**
+     * Find alternate display labels associated with unitName, if any.
+     * @param unitName Full name of Unit.
+     */
+    getAlternateDisplayLabels(unitName) {
+        let alternateLabels = [];
+        for (const entry of this._unitExtraData) {
+            if (entry.name.toLowerCase() === unitName.toLowerCase()) {
+                alternateLabels = entry.altDisplayLabels;
+            }
+        }
+        return alternateLabels;
+    }
+    /**
+     * Finds Unit by unitLabel, which could be a display label in the schema or alternate an display label defined in
+     * this._unitExtraData. If there are duplicates of the same display label in the context or teh same alternate display
+     * labels, specify schemaName, phenomenon, or unitSystem to get a specific unit.
+     *
+     * @param unitLabel Display label or alternate display label to query unit by.
+     * @param schemaName Ensure Unit with unitLabel belongs to Schema with schemaName.
+     * @param phenomenon Full name of phenomenon that Unit belongs to.
+     * @param unitSystem Full name of unitSystem that Unit belongs to.
+     * @returns The UnitProps interface from the @itwin/core-quantity package.
+     */
+    async findUnit(unitLabel, schemaName, phenomenon, unitSystem) {
+        const findLabel = unitLabel.toLowerCase();
+        const findSchema = schemaName ? schemaName.toLowerCase() : undefined;
+        const findPhenomenon = phenomenon ? phenomenon.toLowerCase() : undefined;
+        const findUnitSystem = unitSystem ? unitSystem.toLowerCase() : undefined;
+        let foundUnit;
+        try {
+            try {
+                foundUnit = await this.findUnitByDisplayLabel(findLabel, findSchema, findPhenomenon, findUnitSystem);
+            }
+            catch (err) {
+                // If there is no Unit with display label that matches label, then check for alternate display labels that may match
+                foundUnit = await this.findUnitByAltDisplayLabel(findLabel, findSchema, findPhenomenon, findUnitSystem);
+            }
+        }
+        catch (err) {
+            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find unit with label", () => {
+                return { unitLabel };
+            });
+        }
+        return this.getUnitsProps(foundUnit);
+    }
+    /**
+     * Gets the @itwin/core-quantity UnitConversion for the given fromUnit and toUnit.
+     * @param fromUnit The UnitProps of the 'from' unit.
+     * @param toUnit The UnitProps of the 'to' unit.
+     * @returns The UnitConversion interface from the @itwin/core-quantity package.
+     */
+    async getConversion(fromUnit, toUnit) {
+        const conversion = await this._unitConverter.calculateConversion(fromUnit.name, toUnit.name);
+        return {
+            factor: conversion.factor,
+            offset: conversion.offset,
+        };
+    }
+    /**
+     * Find unit in a schema that has unitName.
+     * @param unitName Full name of unit.
+     * @returns Unit whose full name matches unitName.
+     */
+    async findECUnitByName(unitName) {
+        // Check if schema exists and unit exists in schema
+        const [schemaName, schemaItemName] = SchemaItem_1.SchemaItem.parseFullName(unitName);
+        const schemaKey = new SchemaKey_1.SchemaKey(schemaName);
+        const schema = await this._context.getSchema(schemaKey);
+        if (!schema) {
+            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find schema for unit", () => {
+                return { schema: schemaName, unit: unitName };
+            });
+        }
+        const itemKey = new SchemaKey_1.SchemaItemKey(schemaItemName, schema.schemaKey);
+        const item = await this._context.getSchemaItem(itemKey);
+        if (!item)
+            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find schema item/unit", () => {
+                return { item: schemaItemName, schema: schemaName };
+            });
+        if (item.schemaItemType === ECObjects_1.SchemaItemType.Unit)
+            return item;
+        throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Item is not a unit", () => {
+            return { itemType: item.key.fullName };
+        });
+    }
+    /**
+     * Gets the @itwin/core UnitProps for the given Unit.
+     * @param unit The Unit to convert.
+     * @returns UnitProps interface from @itwin/core.
+     */
+    getUnitsProps(unit) {
+        return {
+            name: unit.fullName,
+            label: unit.label ?? "",
+            phenomenon: unit.phenomenon ? unit.phenomenon.fullName : "",
+            isValid: true,
+            system: unit.unitSystem === undefined ? "" : unit.unitSystem.fullName,
+        };
+    }
+    /**
+     * Finds Unit by displayLabel and that it belongs to schemaName, phenomenon, and unitSystem if defined.
+     * @internal
+     */
+    async findUnitByDisplayLabel(displayLabel, schemaName, phenomenon, unitSystem) {
+        const schemaItems = this._context.getSchemaItems();
+        let { value, done } = schemaItems.next();
+        while (!done) {
+            if (Unit_1.Unit.isUnit(value) && value.label?.toLowerCase() === displayLabel) {
+                const currPhenomenon = await value.phenomenon;
+                const currUnitSystem = await value.unitSystem;
+                if (!schemaName || value.schema.name.toLowerCase() === schemaName)
+                    if (!phenomenon || (currPhenomenon && currPhenomenon.key.matchesFullName(phenomenon)))
+                        if (!unitSystem || (currUnitSystem && currUnitSystem.key.matchesFullName(unitSystem)))
+                            return value;
+            }
+            ({ value, done } = schemaItems.next());
+        }
+        throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find unit with display label", () => {
+            return { displayLabel };
+        });
+    }
+    /**
+     * Finds Unit by altDisplayLabel and that it belongs to schemaName, phenomenon, and unitSystem if defined.
+     * @internal
+     */
+    async findUnitByAltDisplayLabel(altDisplayLabel, schemaName, phenomenon, unitSystem) {
+        for (const entry of this._unitExtraData) {
+            if (entry.altDisplayLabels && entry.altDisplayLabels.length > 0) {
+                if (entry.altDisplayLabels.findIndex((ref) => ref.toLowerCase() === altDisplayLabel) !== -1) {
+                    // Found altDisplayLabel that matches label to find
+                    const unit = await this.findECUnitByName(entry.name);
+                    const foundPhenomenon = await unit.phenomenon;
+                    const foundUnitSystem = await unit.unitSystem;
+                    if (!schemaName || unit.schema.name.toLowerCase() === schemaName)
+                        if (!phenomenon || (foundPhenomenon && foundPhenomenon.key.matchesFullName(phenomenon)))
+                            if (!unitSystem || (foundUnitSystem && foundUnitSystem.key.matchesFullName(unitSystem)))
+                                return unit;
+                }
+            }
+        }
+        throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find unit with alternate display label", () => {
+            return { altDisplayLabel };
+        });
+    }
+}
+exports.SchemaUnitProvider = SchemaUnitProvider;
 //# sourceMappingURL=SchemaUnitProvider.js.map

package/lib/cjs/Validation/SchemaWalker.d.ts

@@ -1,24 +1,24 @@
-import { Schema } from "../Metadata/Schema";
-import { ISchemaPartVisitor } from "../SchemaPartVisitorDelegate";
-/**
- * The purpose of this class is to traverse a given schema, allowing clients to hook into
- * the traversal process via Visitors to allow for custom processing of the schema elements.
- * @internal
- */
-export declare class SchemaWalker {
-    private _visitorHelper;
-    private _schema?;
-    /**
-     * Initializes a new SchemaWalker instance.
-     * @param visitor An ISchemaWalkerVisitor implementation whose methods will be called during schema traversal.
-     */
-    constructor(visitor: ISchemaPartVisitor);
-    /**
-     * Traverses the given Schema, calling ISchemaWalkerVisitor methods along the way.
-     * @param schema The Schema to traverse.
-     */
-    traverseSchema<T extends Schema>(schema: T): Promise<T>;
-    private traverseSchemaItem;
-    private traverseClass;
-}
+import { Schema } from "../Metadata/Schema";
+import { ISchemaPartVisitor } from "../SchemaPartVisitorDelegate";
+/**
+ * The purpose of this class is to traverse a given schema, allowing clients to hook into
+ * the traversal process via Visitors to allow for custom processing of the schema elements.
+ * @internal
+ */
+export declare class SchemaWalker {
+    private _visitorHelper;
+    private _schema?;
+    /**
+     * Initializes a new SchemaWalker instance.
+     * @param visitor An ISchemaWalkerVisitor implementation whose methods will be called during schema traversal.
+     */
+    constructor(visitor: ISchemaPartVisitor);
+    /**
+     * Traverses the given Schema, calling ISchemaWalkerVisitor methods along the way.
+     * @param schema The Schema to traverse.
+     */
+    traverseSchema<T extends Schema>(schema: T): Promise<T>;
+    private traverseSchemaItem;
+    private traverseClass;
+}
 //# sourceMappingURL=SchemaWalker.d.ts.map

package/lib/cjs/Validation/SchemaWalker.js

@@ -1,54 +1,54 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaWalker = void 0;
-const ECObjects_1 = require("../ECObjects");
-const Class_1 = require("../Metadata/Class");
-const SchemaPartVisitorDelegate_1 = require("../SchemaPartVisitorDelegate");
-/**
- * The purpose of this class is to traverse a given schema, allowing clients to hook into
- * the traversal process via Visitors to allow for custom processing of the schema elements.
- * @internal
- */
-class SchemaWalker {
-    /**
-     * Initializes a new SchemaWalker instance.
-     * @param visitor An ISchemaWalkerVisitor implementation whose methods will be called during schema traversal.
-     */
-    constructor(visitor) {
-        this._visitorHelper = new SchemaPartVisitorDelegate_1.SchemaPartVisitorDelegate(visitor);
-    }
-    /**
-     * Traverses the given Schema, calling ISchemaWalkerVisitor methods along the way.
-     * @param schema The Schema to traverse.
-     */
-    async traverseSchema(schema) {
-        this._schema = schema;
-        await this._visitorHelper.visitSchema(schema);
-        await this._visitorHelper.visitSchemaPart(schema);
-        for (const item of this._schema.getItems())
-            await this.traverseSchemaItem(item);
-        return schema;
-    }
-    async traverseSchemaItem(schemaItem) {
-        await this._visitorHelper.visitSchemaPart(schemaItem);
-        if (Class_1.ECClass.isECClass(schemaItem))
-            await this.traverseClass(schemaItem);
-    }
-    async traverseClass(ecClass) {
-        if (ecClass.properties) {
-            for (const property of ecClass.properties) {
-                await this._visitorHelper.visitSchemaPart(property);
-            }
-        }
-        if (ecClass.schemaItemType === ECObjects_1.SchemaItemType.RelationshipClass) {
-            await this._visitorHelper.visitSchemaPart(ecClass.source);
-            await this._visitorHelper.visitSchemaPart(ecClass.target);
-        }
-    }
-}
-exports.SchemaWalker = SchemaWalker;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaWalker = void 0;
+const ECObjects_1 = require("../ECObjects");
+const Class_1 = require("../Metadata/Class");
+const SchemaPartVisitorDelegate_1 = require("../SchemaPartVisitorDelegate");
+/**
+ * The purpose of this class is to traverse a given schema, allowing clients to hook into
+ * the traversal process via Visitors to allow for custom processing of the schema elements.
+ * @internal
+ */
+class SchemaWalker {
+    /**
+     * Initializes a new SchemaWalker instance.
+     * @param visitor An ISchemaWalkerVisitor implementation whose methods will be called during schema traversal.
+     */
+    constructor(visitor) {
+        this._visitorHelper = new SchemaPartVisitorDelegate_1.SchemaPartVisitorDelegate(visitor);
+    }
+    /**
+     * Traverses the given Schema, calling ISchemaWalkerVisitor methods along the way.
+     * @param schema The Schema to traverse.
+     */
+    async traverseSchema(schema) {
+        this._schema = schema;
+        await this._visitorHelper.visitSchema(schema);
+        await this._visitorHelper.visitSchemaPart(schema);
+        for (const item of this._schema.getItems())
+            await this.traverseSchemaItem(item);
+        return schema;
+    }
+    async traverseSchemaItem(schemaItem) {
+        await this._visitorHelper.visitSchemaPart(schemaItem);
+        if (Class_1.ECClass.isECClass(schemaItem))
+            await this.traverseClass(schemaItem);
+    }
+    async traverseClass(ecClass) {
+        if (ecClass.properties) {
+            for (const property of ecClass.properties) {
+                await this._visitorHelper.visitSchemaPart(property);
+            }
+        }
+        if (ecClass.schemaItemType === ECObjects_1.SchemaItemType.RelationshipClass) {
+            await this._visitorHelper.visitSchemaPart(ecClass.source);
+            await this._visitorHelper.visitSchemaPart(ecClass.target);
+        }
+    }
+}
+exports.SchemaWalker = SchemaWalker;
 //# sourceMappingURL=SchemaWalker.js.map