@itwin/core-frontend 5.1.0-dev.13 → 5.1.0-dev.14

package/lib/esm/quantity-formatting/QuantityFormatter.js

@@ -5,7 +5,7 @@
 /** @packageDocumentation
  * @module QuantityFormatting
  */
-import { BentleyError, BeUiEvent, Logger } from "@itwin/core-bentley";
+import { BeEvent, BentleyError, BeUiEvent, Logger } from "@itwin/core-bentley";
 import { Format, FormatterSpec, ParseError, ParserSpec, } from "@itwin/core-quantity";
 import { FrontendLoggerCategory } from "../common/FrontendLoggerCategory";
 import { IModelApp } from "../IModelApp";
@@ -135,12 +135,66 @@ class StandardQuantityTypeDefinition {
         return ParserSpec.create(format, unitsProvider, this.persistenceUnit, alternateUnitLabelsProvider);
     }
 }
+/**
+ * A default formatsProvider, that provides a limited set of [[FormatDefinition]], associated to a few [[KindOfQuantity]].
+ * Maps each KindOfQuantity to a [[QuantityType]].
+ * When retrieving a valid [[KindOfQuantity]], returns the [[FormatProps]] for the associated [[QuantityType]].
+ * @internal
+ */
+export class QuantityTypeFormatsProvider {
+    onFormatsChanged = new BeEvent();
+    constructor() {
+        IModelApp.quantityFormatter.onActiveFormattingUnitSystemChanged.addListener(() => {
+            this.onFormatsChanged.raiseEvent({ formatsChanged: "all" });
+        });
+    }
+    _kindOfQuantityMap = new Map([
+        ["AecUnits.LENGTH", QuantityType.Length],
+        ["AecUnits.ANGLE", QuantityType.Angle],
+        ["AecUnits.AREA", QuantityType.Area],
+        ["AecUnits.VOLUME", QuantityType.Volume],
+        ["RoadRailUnits.STATION", QuantityType.Stationing],
+        ["RoadRailUnits.LENGTH", QuantityType.LengthSurvey],
+    ]);
+    async getFormat(name) {
+        const quantityType = this._kindOfQuantityMap.get(name);
+        if (!quantityType)
+            return undefined;
+        return IModelApp.quantityFormatter.getFormatPropsByQuantityType(quantityType);
+    }
+}
+/**
+ * An implementation of the [[FormatsProvider]] interface that forwards calls to getFormats to the underlying FormatsProvider.
+ * Also fires the onFormatsChanged event when the underlying FormatsProvider fires its own onFormatsChanged event.
+ * @internal
+ */
+export class FormatsProviderManager {
+    _formatsProvider;
+    onFormatsChanged = new BeEvent();
+    constructor(_formatsProvider) {
+        this._formatsProvider = _formatsProvider;
+        this._formatsProvider.onFormatsChanged.addListener((args) => {
+            this.onFormatsChanged.raiseEvent(args);
+        });
+    }
+    async getFormat(name) {
+        return this._formatsProvider.getFormat(name);
+    }
+    get formatsProvider() { return this; }
+    set formatsProvider(formatsProvider) {
+        this._formatsProvider = formatsProvider;
+        this._formatsProvider.onFormatsChanged.addListener((args) => {
+            this.onFormatsChanged.raiseEvent(args);
+        });
+        this.onFormatsChanged.raiseEvent({ formatsChanged: "all" });
+    }
+}
 /** Class that supports formatting quantity values into strings and parsing strings into quantity values. This class also maintains
  * the "active" unit system and caches FormatterSpecs and ParserSpecs for the "active" unit system to allow synchronous access to
  * parsing and formatting values. The support unit systems are defined by [[UnitSystemKey]] and is kept in synch with the unit systems
  * provided by the Presentation Manager on the backend. The QuantityFormatter contains a registry of quantity type definitions. These definitions implement
- * the [[QuantityTypeDefinition]] interface, which among other things, provide default [FormatProps]$(core-quantity), and provide methods
- * to generate both a [FormatterSpec]$(core-quantity) and a [ParserSpec]$(core-quantity). There are built-in quantity types that are
+ * the [[QuantityTypeDefinition]] interface, which among other things, provide default [[FormatProps]], and provide methods
+ * to generate both a [[FormatterSpec]] and a [[ParserSpec]]. There are built-in quantity types that are
  * identified by the [[QuantityType]] enum. [[CustomQuantityTypeDefinition]] can be registered to extend the available quantity types available
  * by frontend tools. The QuantityFormatter also allows the default formats to be overriden.
  *
@@ -544,26 +598,51 @@ export class QuantityFormatter {
             requestedSystem = isImperial ? "imperial" : "metric";
         return this.getParserSpecByQuantityTypeAndSystem(type, requestedSystem);
     }
-    /** Generates a formatted string for a quantity given its format spec.
-     * @param magnitude       The magnitude of the quantity.
-     * @param formatSpec      The format specification. See methods getFormatterSpecByQuantityType and findFormatterSpecByQuantityType.
-     * @return the formatted string.
-     */
-    formatQuantity(magnitude, formatSpec) {
-        /** Format a quantity value. Default FormatterSpec implementation uses Formatter.formatQuantity. */
-        if (formatSpec)
-            return formatSpec.applyFormatting(magnitude);
-        return magnitude.toString();
-    }
-    /** Parse input string into quantity given the ParserSpec
-     * @param inString       The magnitude of the quantity.
-     * @param parserSpec     The parse specification the defines the expected format of the string and the conversion to the output unit.
-     * @return QuantityParseResult object containing either the parsed value or an error value if unsuccessful.
-     */
-    parseToQuantityValue(inString, parserSpec) {
-        if (parserSpec)
-            return parserSpec.parseToQuantityValue(inString);
-        return { ok: false, error: ParseError.InvalidParserSpec };
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    formatQuantity(args, spec) {
+        if (typeof args === "number") {
+            /** Format a quantity value. Default FormatterSpec implementation uses Formatter.formatQuantity. */
+            const magnitude = args;
+            if (spec)
+                return spec.applyFormatting(magnitude);
+            return magnitude.toString();
+        }
+        return this.formatQuantityAsync(args);
+    }
+    async formatQuantityAsync(args) {
+        const { value, valueUnitName, kindOfQuantityName } = args;
+        const formatProps = await IModelApp.formatsProvider.getFormat(kindOfQuantityName);
+        if (!formatProps)
+            return value.toString();
+        const formatSpec = await this.createFormatterSpec({
+            persistenceUnitName: valueUnitName,
+            formatProps,
+            formatName: kindOfQuantityName,
+        });
+        return formatSpec.applyFormatting(value);
+    }
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    parseToQuantityValue(args, parserSpec) {
+        if (typeof args === "string") {
+            /** Parse a quantity value. Default ParserSpec implementation uses ParserSpec.parseToQuantityValue. */
+            const inString = args;
+            if (parserSpec)
+                return parserSpec.parseToQuantityValue(inString);
+            return { ok: false, error: ParseError.InvalidParserSpec };
+        }
+        return this.parseToQuantityValueAsync(args);
+    }
+    async parseToQuantityValueAsync(args) {
+        const { value, valueUnitName, kindOfQuantityName } = args;
+        const formatProps = await IModelApp.formatsProvider.getFormat(kindOfQuantityName);
+        if (!formatProps)
+            return { ok: false, error: ParseError.InvalidParserSpec };
+        const parserSpec = await this.createParserSpec({
+            persistenceUnitName: valueUnitName,
+            formatProps,
+            formatName: kindOfQuantityName,
+        });
+        return parserSpec.parseToQuantityValue(value);
     }
     /**
      * Get a UnitSystemKey from a string that may have been entered via a key-in. Supports different variation of
@@ -633,6 +712,28 @@ export class QuantityFormatter {
     async getConversion(fromUnit, toUnit) {
         return this._unitsProvider.getConversion(fromUnit, toUnit);
     }
+    /**
+     * Creates a [[FormatterSpec]] for a given persistence unit name and format properties, using the [[UnitsProvider]] to resolve the persistence unit.
+     * @beta
+     * @param props - A [[CreateFormattingSpecProps]] interface.
+     */
+    async createFormatterSpec(props) {
+        const { persistenceUnitName, formatProps, formatName } = props;
+        const persistenceUnitProps = await this._unitsProvider.findUnitByName(persistenceUnitName);
+        const format = await Format.createFromJSON(formatName ?? "temp", this._unitsProvider, formatProps);
+        return FormatterSpec.create(`${format.name}_format_spec`, format, this._unitsProvider, persistenceUnitProps);
+    }
+    /**
+     * Creates a [[ParserSpec]] for a given persistence unit name and format properties, using the [[UnitsProvider]] to resolve the persistence unit.
+     * @beta
+     * @param props - A [[CreateFormattingSpecProps]] object.
+     */
+    async createParserSpec(props) {
+        const { persistenceUnitName, formatProps, formatName } = props;
+        const persistenceUnitProps = await this._unitsProvider.findUnitByName(persistenceUnitName);
+        const format = await Format.createFromJSON(formatName ?? "temp", this._unitsProvider, formatProps);
+        return ParserSpec.create(format, this._unitsProvider, persistenceUnitProps);
+    }
 }
 // ========================================================================================================================================
 // Default Data