@itwin/ecschema-metadata 4.0.0-dev.10 → 4.0.0-dev.100

package/lib/cjs/UnitConversion/UnitConverter.js

@@ -1,117 +1,117 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnitConverter = 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 SchemaItem_1 = require("../Metadata/SchemaItem");
-const Unit_1 = require("../Metadata/Unit");
-const SchemaKey_1 = require("../SchemaKey");
-const UnitConversion_1 = require("./UnitConversion");
-const UnitTree_1 = require("./UnitTree");
-/**
- * Class constructed with SchemaContext and used to calculate [[UnitConversion]] between Units
- * @internal
- */
-class UnitConverter {
-    /**
-     * Create Converter context
-     * @param _context SchemaContext with contexts added to it.
-     */
-    constructor(_context) {
-        this._context = _context;
-        this._uGraph = new UnitTree_1.UnitGraph(this._context);
-    }
-    /**
-     * Find conversion between from and to units, formatted {schemaName}.{schemaItemName} or {schemaName}:{schemaItemName}
-     * @param fromUnit SchemaItem full name of source unit
-     * @param toUnit SchemaItem full name of target unit
-     * @returns [[UnitConversion]] converting fromUnit -> toUnit with a factor and an offset
-     * @throws Error if from and to Units' SchemaItem is not found in Schema or Schema prefix is not found in SchemaContext
-     * @throws Error if from and to Units do not belong to the same phenomenon
-     * @throws Error if definitions' SchemaItems cannot be found in its own or referenced Schemas
-     * @throws Error if base units of source and target unit do not match
-     */
-    async calculateConversion(fromUnit, toUnit) {
-        const [fromSchemaName, fromSchemaItemName] = SchemaItem_1.SchemaItem.parseFullName(fromUnit);
-        const [toSchemaName, toSchemaItemName] = SchemaItem_1.SchemaItem.parseFullName(toUnit);
-        const fromSchemaKey = new SchemaKey_1.SchemaKey(fromSchemaName);
-        const toSchemaKey = new SchemaKey_1.SchemaKey(toSchemaName);
-        const fromSchema = await this._context.getSchema(fromSchemaKey);
-        const toSchema = await this._context.getSchema(toSchemaKey);
-        if (!fromSchema || !toSchema) {
-            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find from's and/or to's schema", () => {
-                return { from: fromUnit, fromSchema: fromSchemaName, to: toUnit, toSchema: toSchemaName };
-            });
-        }
-        const from = await this._uGraph.resolveUnit(fromSchemaItemName, fromSchema);
-        const to = await this._uGraph.resolveUnit(toSchemaItemName, toSchema);
-        return this.processUnits(from, to);
-    }
-    /**
-     * @param from Source unit converted from
-     * @param to Target unit converted to
-     * @internal
-     */
-    async processUnits(from, to) {
-        if (from.key.matches(to.key))
-            return UnitConversion_1.UnitConversion.identity;
-        const areCompatible = await Unit_1.Unit.areCompatible(from, to);
-        if (!areCompatible)
-            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, `Source and target units do not belong to same phenomenon`, () => {
-                return { from, to };
-            });
-        // Add nodes and subsequent children to graph
-        await this._uGraph.addUnit(from);
-        await this._uGraph.addUnit(to);
-        const fromBaseUnits = new Map();
-        const toBaseUnits = new Map();
-        // Calculate map of UnitConversions to get between from -> base
-        const fromMapStore = this._uGraph.reduce(from, fromBaseUnits);
-        // Calculate map of UnitConversions to get between base -> to
-        const toMapStore = this._uGraph.reduce(to, toBaseUnits);
-        if (!this.checkBaseUnitsMatch(fromBaseUnits, toBaseUnits))
-            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, `Source and target units do not have matching base units`, () => {
-                return { from, to };
-            });
-        // Final calculations to get singular UnitConversion between from -> to
-        const fromMap = fromMapStore.get(from.key.fullName) || UnitConversion_1.UnitConversion.identity;
-        const toMap = toMapStore.get(to.key.fullName) || UnitConversion_1.UnitConversion.identity;
-        const fromInverse = fromMap.inverse();
-        return fromInverse.compose(toMap);
-    }
-    /**
-     * Check if fromBaseUnits's base units and exponents matches toBaseUnits's
-     * @param fromBaseUnits Map of base units for source unit
-     * @param toBaseUnits Map of base units for target unit
-     * @internal
-     */
-    checkBaseUnitsMatch(fromBaseUnits, toBaseUnits) {
-        // Trim maps of "One" and value that equal zero as they do not affect the base units and calculations
-        for (const [key, value] of fromBaseUnits.entries()) {
-            const [, schemaItemName] = SchemaItem_1.SchemaItem.parseFullName(key);
-            if (schemaItemName === "ONE" || value === 0) {
-                fromBaseUnits.delete(key);
-            }
-        }
-        for (const [key, value] of toBaseUnits.entries()) {
-            const [, schemaItemName] = SchemaItem_1.SchemaItem.parseFullName(key);
-            if (schemaItemName === "ONE" || value === 0) {
-                toBaseUnits.delete(key);
-            }
-        }
-        if (fromBaseUnits.size !== toBaseUnits.size)
-            return false;
-        for (const key of fromBaseUnits.keys()) {
-            if (!toBaseUnits.has(key) || fromBaseUnits.get(key) !== toBaseUnits.get(key)) {
-                // Mismatching key or value
-                return false;
-            }
-        }
-        return true;
-    }
-}
-exports.UnitConverter = UnitConverter;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitConverter = 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 SchemaItem_1 = require("../Metadata/SchemaItem");
+const Unit_1 = require("../Metadata/Unit");
+const SchemaKey_1 = require("../SchemaKey");
+const UnitConversion_1 = require("./UnitConversion");
+const UnitTree_1 = require("./UnitTree");
+/**
+ * Class constructed with SchemaContext and used to calculate [[UnitConversion]] between Units
+ * @internal
+ */
+class UnitConverter {
+    /**
+     * Create Converter context
+     * @param _context SchemaContext with contexts added to it.
+     */
+    constructor(_context) {
+        this._context = _context;
+        this._uGraph = new UnitTree_1.UnitGraph(this._context);
+    }
+    /**
+     * Find conversion between from and to units, formatted {schemaName}.{schemaItemName} or {schemaName}:{schemaItemName}
+     * @param fromUnit SchemaItem full name of source unit
+     * @param toUnit SchemaItem full name of target unit
+     * @returns [[UnitConversion]] converting fromUnit -> toUnit with a factor and an offset
+     * @throws Error if from and to Units' SchemaItem is not found in Schema or Schema prefix is not found in SchemaContext
+     * @throws Error if from and to Units do not belong to the same phenomenon
+     * @throws Error if definitions' SchemaItems cannot be found in its own or referenced Schemas
+     * @throws Error if base units of source and target unit do not match
+     */
+    async calculateConversion(fromUnit, toUnit) {
+        const [fromSchemaName, fromSchemaItemName] = SchemaItem_1.SchemaItem.parseFullName(fromUnit);
+        const [toSchemaName, toSchemaItemName] = SchemaItem_1.SchemaItem.parseFullName(toUnit);
+        const fromSchemaKey = new SchemaKey_1.SchemaKey(fromSchemaName);
+        const toSchemaKey = new SchemaKey_1.SchemaKey(toSchemaName);
+        const fromSchema = await this._context.getSchema(fromSchemaKey);
+        const toSchema = await this._context.getSchema(toSchemaKey);
+        if (!fromSchema || !toSchema) {
+            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, "Cannot find from's and/or to's schema", () => {
+                return { from: fromUnit, fromSchema: fromSchemaName, to: toUnit, toSchema: toSchemaName };
+            });
+        }
+        const from = await this._uGraph.resolveUnit(fromSchemaItemName, fromSchema);
+        const to = await this._uGraph.resolveUnit(toSchemaItemName, toSchema);
+        return this.processUnits(from, to);
+    }
+    /**
+     * @param from Source unit converted from
+     * @param to Target unit converted to
+     * @internal
+     */
+    async processUnits(from, to) {
+        if (from.key.matches(to.key))
+            return UnitConversion_1.UnitConversion.identity;
+        const areCompatible = await Unit_1.Unit.areCompatible(from, to);
+        if (!areCompatible)
+            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, `Source and target units do not belong to same phenomenon`, () => {
+                return { from, to };
+            });
+        // Add nodes and subsequent children to graph
+        await this._uGraph.addUnit(from);
+        await this._uGraph.addUnit(to);
+        const fromBaseUnits = new Map();
+        const toBaseUnits = new Map();
+        // Calculate map of UnitConversions to get between from -> base
+        const fromMapStore = this._uGraph.reduce(from, fromBaseUnits);
+        // Calculate map of UnitConversions to get between base -> to
+        const toMapStore = this._uGraph.reduce(to, toBaseUnits);
+        if (!this.checkBaseUnitsMatch(fromBaseUnits, toBaseUnits))
+            throw new core_bentley_1.BentleyError(core_bentley_1.BentleyStatus.ERROR, `Source and target units do not have matching base units`, () => {
+                return { from, to };
+            });
+        // Final calculations to get singular UnitConversion between from -> to
+        const fromMap = fromMapStore.get(from.key.fullName) || UnitConversion_1.UnitConversion.identity;
+        const toMap = toMapStore.get(to.key.fullName) || UnitConversion_1.UnitConversion.identity;
+        const fromInverse = fromMap.inverse();
+        return fromInverse.compose(toMap);
+    }
+    /**
+     * Check if fromBaseUnits's base units and exponents matches toBaseUnits's
+     * @param fromBaseUnits Map of base units for source unit
+     * @param toBaseUnits Map of base units for target unit
+     * @internal
+     */
+    checkBaseUnitsMatch(fromBaseUnits, toBaseUnits) {
+        // Trim maps of "One" and value that equal zero as they do not affect the base units and calculations
+        for (const [key, value] of fromBaseUnits.entries()) {
+            const [, schemaItemName] = SchemaItem_1.SchemaItem.parseFullName(key);
+            if (schemaItemName === "ONE" || value === 0) {
+                fromBaseUnits.delete(key);
+            }
+        }
+        for (const [key, value] of toBaseUnits.entries()) {
+            const [, schemaItemName] = SchemaItem_1.SchemaItem.parseFullName(key);
+            if (schemaItemName === "ONE" || value === 0) {
+                toBaseUnits.delete(key);
+            }
+        }
+        if (fromBaseUnits.size !== toBaseUnits.size)
+            return false;
+        for (const key of fromBaseUnits.keys()) {
+            if (!toBaseUnits.has(key) || fromBaseUnits.get(key) !== toBaseUnits.get(key)) {
+                // Mismatching key or value
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.UnitConverter = UnitConverter;
 //# sourceMappingURL=UnitConverter.js.map

package/lib/cjs/UnitConversion/UnitTree.d.ts

@@ -1,44 +1,44 @@
-import { SchemaContext } from "../Context";
-import { Constant } from "../Metadata/Constant";
-import { Schema } from "../Metadata/Schema";
-import { Unit } from "../Metadata/Unit";
-import { UnitConversion } from "./UnitConversion";
-import { Graph } from "./Graph";
-/** @internal */
-export declare class GraphUtils {
-    /**
-     * DFS traversal - Post order
-     * @param _graph Graph to traverse
-     * @param start Starting node
-     * @param keyFrom Get key from label
-     * @param op Reducing function
-     * @param initial Initial label
-     */
-    static dfsReduce<T>(_graph: Graph<Unit | Constant>, key: string, op: (previous: T, current: string) => T, initial: T, baseUnitsMap: Map<string, number>, accumulatedExponent: number): T;
-}
-/** @internal */
-export declare class UnitGraph {
-    private _context;
-    private _graph;
-    constructor(_context: SchemaContext);
-    /**
-     * Tries to find the unit/constant given by name in currentSchema
-     * @param name SchemaItem name or parsed definition to find unit of; Could be {schemaName}:{schemaItemName} or {alias}:{schemaItemName} or {schemaItemName}
-     * @param currentSchema schema to find name in; name could also be in a referenced schema of current schema
-     */
-    resolveUnit(name: string, currentSchema: Schema): Promise<Unit | Constant>;
-    /**
-     * Adds unit and corresponding children to graph as well as edges between units
-     * @param unit Current unit to be added to graph
-     */
-    addUnit(unit: Unit | Constant): Promise<void>;
-    private isIdentity;
-    /**
-     * Reduce the tree to produce a single map
-     * @param unit Unit to be processed
-     * @param stopNodes The tree exploration should stop here
-     */
-    reduce(unit: Unit | Constant, baseUnitsMap: Map<string, number>): Map<string, UnitConversion>;
-    private reducingFunction;
-}
+import { SchemaContext } from "../Context";
+import { Constant } from "../Metadata/Constant";
+import { Schema } from "../Metadata/Schema";
+import { Unit } from "../Metadata/Unit";
+import { UnitConversion } from "./UnitConversion";
+import { Graph } from "./Graph";
+/** @internal */
+export declare class GraphUtils {
+    /**
+     * DFS traversal - Post order
+     * @param _graph Graph to traverse
+     * @param start Starting node
+     * @param keyFrom Get key from label
+     * @param op Reducing function
+     * @param initial Initial label
+     */
+    static dfsReduce<T>(_graph: Graph<Unit | Constant>, key: string, op: (previous: T, current: string) => T, initial: T, baseUnitsMap: Map<string, number>, accumulatedExponent: number): T;
+}
+/** @internal */
+export declare class UnitGraph {
+    private _context;
+    private _graph;
+    constructor(_context: SchemaContext);
+    /**
+     * Tries to find the unit/constant given by name in currentSchema
+     * @param name SchemaItem name or parsed definition to find unit of; Could be {schemaName}:{schemaItemName} or {alias}:{schemaItemName} or {schemaItemName}
+     * @param currentSchema schema to find name in; name could also be in a referenced schema of current schema
+     */
+    resolveUnit(name: string, currentSchema: Schema): Promise<Unit | Constant>;
+    /**
+     * Adds unit and corresponding children to graph as well as edges between units
+     * @param unit Current unit to be added to graph
+     */
+    addUnit(unit: Unit | Constant): Promise<void>;
+    private isIdentity;
+    /**
+     * Reduce the tree to produce a single map
+     * @param unit Unit to be processed
+     * @param stopNodes The tree exploration should stop here
+     */
+    reduce(unit: Unit | Constant, baseUnitsMap: Map<string, number>): Map<string, UnitConversion>;
+    private reducingFunction;
+}
 //# sourceMappingURL=UnitTree.d.ts.map