@itwin/core-quantity 4.8.0-dev.4 → 4.8.0-dev.40

package/lib/cjs/Parser.js

@@ -22,18 +22,35 @@ var ParseError;
     ParseError[ParseError["UnknownUnit"] = 4] = "UnknownUnit";
     ParseError[ParseError["UnableToConvertParseTokensToQuantity"] = 5] = "UnableToConvertParseTokensToQuantity";
     ParseError[ParseError["InvalidParserSpec"] = 6] = "InvalidParserSpec";
+    ParseError[ParseError["MathematicOperationFoundButIsNotAllowed"] = 7] = "MathematicOperationFoundButIsNotAllowed";
 })(ParseError || (exports.ParseError = ParseError = {}));
+var Operator;
+(function (Operator) {
+    Operator["addition"] = "+";
+    Operator["subtraction"] = "-";
+})(Operator || (Operator = {}));
+function isOperator(char) {
+    if (typeof char === "number") {
+        // Convert the charcode to string.
+        char = String.fromCharCode(char);
+    }
+    return Object.values(Operator).includes(char);
+}
 /** A ParseToken holds either a numeric or string token extracted from a string that represents a quantity value.
  * @beta
  */
 class ParseToken {
     constructor(value) {
-        if (typeof value === "string")
+        this.isOperator = false;
+        if (typeof value === "string") {
             this.value = value.trim();
-        else
+            this.isOperator = isOperator(this.value);
+        }
+        else {
             this.value = value;
+        }
     }
-    get isString() { return typeof this.value === "string"; }
+    get isString() { return !this.isOperator && typeof this.value === "string"; }
     get isNumber() { return typeof this.value === "number"; }
 }
 /** A ScientificToken holds an index and string representing the exponent.
@@ -140,6 +157,7 @@ class Parser {
         let processingNumber = false;
         let wipToken = "";
         let signToken = "";
+        let isStationSeparatorAdded = false;
         let uomSeparatorToIgnore = 0;
         let fractionDashCode = 0;
         const skipCodes = [format.thousandSeparator.charCodeAt(0)];
@@ -225,9 +243,17 @@ class Parser {
                             }
                         }
                     }
-                    // ignore any codes in skipCodes
-                    if (skipCodes.findIndex((ref) => ref === charCode) !== -1)
+                    if (format.type === FormatEnums_1.FormatType.Station && charCode === format.stationSeparator.charCodeAt(0)) {
+                        if (!isStationSeparatorAdded) {
+                            isStationSeparatorAdded = true;
+                            continue;
+                        }
+                        isStationSeparatorAdded = false;
+                    }
+                    else if (skipCodes.findIndex((ref) => ref === charCode) !== -1) {
+                        // ignore any codes in skipCodes
                         continue;
+                    }
                     if (signToken.length > 0) {
                         wipToken = signToken + wipToken;
                         signToken = "";
@@ -235,12 +261,24 @@ class Parser {
                     tokens.push(new ParseToken(parseFloat(wipToken)));
                     wipToken = (i < str.length) ? str[i] : "";
                     processingNumber = false;
+                    if (wipToken.length === 1 && isOperator(wipToken)) {
+                        tokens.push(new ParseToken(wipToken)); // Push operator token.
+                        wipToken = "";
+                    }
                 }
                 else {
                     // not processing a number
-                    if ((charCode === Constants_1.QuantityConstants.CHAR_PLUS || charCode === Constants_1.QuantityConstants.CHAR_MINUS)) {
-                        if (0 === tokens.length) // sign token only needed for left most value
-                            signToken = str[i];
+                    if (isOperator(charCode)) {
+                        if (wipToken.length > 0) {
+                            // There is a token is progress, process it now, before adding the new operator token.
+                            tokens.push(new ParseToken(wipToken));
+                            wipToken = "";
+                        }
+                        tokens.push(new ParseToken(str[i])); // Push an Operator Token in the list.
+                        continue;
+                    }
+                    if (wipToken.length === 0 && charCode === Constants_1.QuantityConstants.CHAR_SPACE) {
+                        // Dont add space when the wip token is empty.
                         continue;
                     }
                     wipToken = wipToken.concat(str[i]);
@@ -261,6 +299,17 @@ class Parser {
         }
         return tokens;
     }
+    static isMathematicOperation(tokens) {
+        if (tokens.length > 1) {
+            // The loop starts at one because the first token can be a operator without it being maths. Ex: "-5FT"
+            for (let i = 1; i < tokens.length; i++) {
+                if (tokens[i].isOperator)
+                    // Operator found, it's a math operation.
+                    return true;
+            }
+        }
+        return false;
+    }
     static async lookupUnitByLabel(unitLabel, format, unitsProvider, altUnitLabelsProvider) {
         const defaultUnit = format.units && format.units.length > 0 ? format.units[0][0] : undefined;
         const labelToFind = unitLabel.toLowerCase();
@@ -285,69 +334,53 @@ class Parser {
             foundUnit = await unitsProvider.findUnit(unitLabel, defaultUnit ? defaultUnit.phenomenon : undefined);
         return foundUnit;
     }
-    static async createQuantityFromParseTokens(tokens, format, unitsProvider, altUnitLabelsProvider) {
-        let defaultUnit = format.units && format.units.length > 0 ? format.units[0][0] : undefined;
-        // common case where single value is supplied
-        if (tokens.length === 1) {
-            if (tokens[0].isNumber) {
-                return new Quantity_1.Quantity(defaultUnit, tokens[0].value);
+    /**
+     * Get the output unit and all the conversion specs required to parse a given list of tokens.
+     */
+    static async getRequiredUnitsConversionsToParseTokens(tokens, format, unitsProvider, altUnitLabelsProvider) {
+        let outUnit = (format.units && format.units.length > 0 ? format.units[0][0] : undefined);
+        const unitConversions = [];
+        const uniqueUnitLabels = [...new Set(tokens.filter((token) => token.isString).map((token) => token.value))];
+        for (const label of uniqueUnitLabels) {
+            const unitProps = await this.lookupUnitByLabel(label, format, unitsProvider, altUnitLabelsProvider);
+            if (!outUnit) {
+                // No default unit, assume that the first unit found is the desired output unit.
+                outUnit = unitProps;
             }
-            else {
-                const unit = await this.lookupUnitByLabel(tokens[0].value, format, unitsProvider, altUnitLabelsProvider);
-                return new Quantity_1.Quantity(unit);
+            let spec = unitConversions.find((specB) => specB.name === unitProps.name);
+            if (spec) {
+                // Already in the list, just add the label.
+                spec.parseLabels?.push(label.toLocaleLowerCase());
             }
-        }
-        // common case where single value and single label are supplied
-        if (tokens.length === 2) {
-            // unit specification comes before value (like currency)
-            if (tokens[1].isNumber && tokens[0].isString) {
-                tokens = [tokens[1], tokens[0]];
-            }
-            if (tokens[0].isNumber && tokens[1].isString) {
-                const unit = await this.lookupUnitByLabel(tokens[1].value, format, unitsProvider, altUnitLabelsProvider);
-                if (undefined === defaultUnit)
-                    defaultUnit = unit;
-                if (defaultUnit && defaultUnit.name === unit.name) {
-                    return new Quantity_1.Quantity(defaultUnit, tokens[0].value);
-                }
-                else if (defaultUnit) {
-                    const conversion = await unitsProvider.getConversion(unit, defaultUnit);
-                    const mag = ((tokens[0].value * conversion.factor)) + conversion.offset;
-                    return new Quantity_1.Quantity(defaultUnit, mag);
+            else {
+                // Add new conversion to the list.
+                const conversion = await unitsProvider.getConversion(unitProps, outUnit);
+                if (conversion) {
+                    spec = {
+                        conversion,
+                        label: unitProps.label,
+                        system: unitProps.system,
+                        name: unitProps.name,
+                        parseLabels: [label.toLocaleLowerCase()],
+                    };
+                    unitConversions.push(spec);
                 }
             }
         }
-        // common case where there are multiple value/label pairs
-        if (tokens.length % 2 === 0) {
-            let mag = 0.0;
-            for (let i = 0; i < tokens.length; i = i + 2) {
-                if (tokens[i].isNumber && tokens[i + 1].isString) {
-                    const value = tokens[i].value;
-                    const unit = await this.lookupUnitByLabel(tokens[i + 1].value, format, unitsProvider, altUnitLabelsProvider);
-                    if (undefined === defaultUnit)
-                        defaultUnit = unit;
-                    if (0 === i) {
-                        if (defaultUnit.name === unit.name)
-                            mag = value;
-                        else {
-                            const conversion = await unitsProvider.getConversion(unit, defaultUnit);
-                            mag = ((value * conversion.factor)) + conversion.offset;
-                        }
-                    }
-                    else {
-                        if (defaultUnit) {
-                            const conversion = await unitsProvider.getConversion(unit, defaultUnit);
-                            if (mag < 0.0)
-                                mag = mag - ((value * conversion.factor)) + conversion.offset;
-                            else
-                                mag = mag + ((value * conversion.factor)) + conversion.offset;
-                        }
-                    }
-                }
+        return { outUnit, specs: unitConversions };
+    }
+    /**
+     * Get the units information asynchronously, then convert the tokens into quantity using the synchronous tokens -> value.
+     */
+    static async createQuantityFromParseTokens(tokens, format, unitsProvider, altUnitLabelsProvider) {
+        const unitConversionInfos = await this.getRequiredUnitsConversionsToParseTokens(tokens, format, unitsProvider, altUnitLabelsProvider);
+        if (unitConversionInfos.outUnit) {
+            const value = Parser.getQuantityValueFromParseTokens(tokens, format, unitConversionInfos.specs, await unitsProvider.getConversion(unitConversionInfos.outUnit, unitConversionInfos.outUnit));
+            if (value.ok) {
+                return new Quantity_1.Quantity(unitConversionInfos.outUnit, value.value);
             }
-            return new Quantity_1.Quantity(defaultUnit, mag);
         }
-        return new Quantity_1.Quantity(defaultUnit);
+        return new Quantity_1.Quantity();
     }
     /** Async method to generate a Quantity given a string that represents a quantity value and likely a unit label.
      *  @param inString A string that contains text represent a quantity.
@@ -356,7 +389,7 @@ class Parser {
      */
     static async parseIntoQuantity(inString, format, unitsProvider, altUnitLabelsProvider) {
         const tokens = Parser.parseQuantitySpecification(inString, format);
-        if (tokens.length === 0)
+        if (tokens.length === 0 || (!format.allowMathematicOperations && Parser.isMathematicOperation(tokens)))
             return new Quantity_1.Quantity();
         return Parser.createQuantityFromParseTokens(tokens, format, unitsProvider, altUnitLabelsProvider);
     }
@@ -399,75 +432,106 @@ class Parser {
         }
         return undefined;
     }
-    static getQuantityValueFromParseTokens(tokens, format, unitsConversions) {
-        const defaultUnit = format.units && format.units.length > 0 ? format.units[0][0] : undefined;
-        // common case where single value is supplied
-        if (tokens.length === 1) {
-            if (tokens[0].isNumber) {
-                if (defaultUnit) {
-                    const conversion = Parser.tryFindUnitConversion(defaultUnit.label, unitsConversions, defaultUnit);
-                    if (conversion) {
-                        const value = tokens[0].value * conversion.factor + conversion.offset;
-                        return { ok: true, value };
-                    }
-                }
-                else {
-                    // if no conversion or no defaultUnit, just return parsed number
-                    return { ok: true, value: tokens[0].value };
-                }
+    /**
+     * Get what the unit conversion is for a unitless value.
+     */
+    static getDefaultUnitConversion(tokens, unitsConversions, defaultUnit) {
+        let unitConversion = defaultUnit ? Parser.tryFindUnitConversion(defaultUnit.label, unitsConversions, defaultUnit) : undefined;
+        if (!unitConversion) {
+            // No default unit conversion, take the first valid unit.
+            const uniqueUnitLabels = [...new Set(tokens.filter((token) => token.isString).map((token) => token.value))];
+            for (const label of uniqueUnitLabels) {
+                unitConversion = Parser.tryFindUnitConversion(label, unitsConversions, defaultUnit);
+                if (unitConversion !== undefined)
+                    return unitConversion;
+            }
+        }
+        return unitConversion;
+    }
+    // Get the next token pair to parse into a quantity.
+    static getNextTokenPair(index, tokens) {
+        if (index >= tokens.length)
+            return;
+        // 6 possible combination of token pair.
+        // Stringified to ease comparison later.
+        const validCombinations = [
+            JSON.stringify(["string"]), // ['FT']
+            JSON.stringify(["string", "number"]), // ['$', 5] unit specification comes before value (like currency)
+            JSON.stringify(["number"]), // [5]
+            JSON.stringify(["number", "string"]), // [5, 'FT']
+            JSON.stringify(["operator", "number"]), // ['-', 5]
+            JSON.stringify(["operator", "number", "string"]), // ['-', 5, 'FT']
+        ];
+        // Push up to 3 tokens in the list, if the length allows it.
+        const maxNbrTokensInThePair = Math.min(tokens.length - index, 3);
+        const tokenPair = tokens.slice(index, index + maxNbrTokensInThePair);
+        const currentCombination = tokenPair.map((token) => token.isOperator ? "operator" : (token.isNumber ? "number" : "string"));
+        // Check if the token pair is valid. If not, try again by removing the last token util empty.
+        // Ex: ['5', 'FT', '7'] invalid => ['5', 'FT'] valid returned
+        for (let i = currentCombination.length - 1; i >= 0; i--) {
+            if (validCombinations.includes(JSON.stringify(currentCombination))) {
+                break;
             }
             else {
-                // only the unit label was specified so assume magnitude of 1
-                const conversion = Parser.tryFindUnitConversion(tokens[0].value, unitsConversions, defaultUnit);
-                if (undefined !== conversion)
-                    return { ok: true, value: conversion.factor + conversion.offset };
-                else
-                    return { ok: false, error: ParseError.NoValueOrUnitFoundInString };
+                currentCombination.pop();
+                tokenPair.pop();
             }
         }
-        // common case where single value and single label are supplied
-        if (tokens.length === 2) {
+        return tokenPair.length > 0 ? tokenPair : undefined;
+    }
+    /**
+     * Accumulate the given list of tokens into a single quantity value. Formatting the tokens along the way.
+     */
+    static getQuantityValueFromParseTokens(tokens, format, unitsConversions, defaultUnitConversion) {
+        const defaultUnit = format.units && format.units.length > 0 ? format.units[0][0] : undefined;
+        defaultUnitConversion = defaultUnitConversion ? defaultUnitConversion : Parser.getDefaultUnitConversion(tokens, unitsConversions, defaultUnit);
+        let tokenPair;
+        let increment = 1;
+        let mag = 0.0;
+        // The sign is saved outside from the loop for cases like this. '-1m 50cm 10mm + 2m 30cm 40mm' => -1.51m + 2.34m
+        let sign = 1;
+        for (let i = 0; i < tokens.length; i = i + increment) {
+            tokenPair = this.getNextTokenPair(i, tokens);
+            if (!tokenPair || tokenPair.length === 0) {
+                return { ok: false, error: ParseError.UnableToConvertParseTokensToQuantity };
+            }
+            increment = tokenPair.length;
+            // Keep the sign so its applied to the next tokens.
+            if (tokenPair[0].isOperator) {
+                sign = tokenPair[0].value === Operator.addition ? 1 : -1;
+                tokenPair.shift();
+            }
             // unit specification comes before value (like currency)
-            if (tokens[1].isNumber && tokens[0].isString) {
-                tokens = [tokens[1], tokens[0]];
+            if (tokenPair.length === 2 && tokenPair[0].isString) {
+                // Invert it so the currency sign comes second.
+                tokenPair = [tokenPair[1], tokenPair[0]];
             }
-            if (tokens[0].isNumber && tokens[1].isString) {
-                let conversion = Parser.tryFindUnitConversion(tokens[1].value, unitsConversions, defaultUnit);
-                // if no conversion, ignore value in second token. If we have defaultUnit, use it.
-                if (!conversion && defaultUnit) {
-                    conversion = Parser.tryFindUnitConversion(defaultUnit.label, unitsConversions, defaultUnit);
+            if (tokenPair[0].isNumber) {
+                let value = sign * tokenPair[0].value;
+                let conversion;
+                if (tokenPair.length === 2 && tokenPair[1].isString) {
+                    conversion = Parser.tryFindUnitConversion(tokenPair[1].value, unitsConversions, defaultUnit);
                 }
+                conversion = conversion ? conversion : defaultUnitConversion;
                 if (conversion) {
-                    const value = tokens[0].value * conversion.factor + conversion.offset;
-                    return { ok: true, value };
+                    value = (value * conversion.factor) + conversion.offset;
                 }
-                // if no conversion, just return parsed number and ignore value in second token
-                return { ok: true, value: tokens[0].value };
+                mag = mag + value;
             }
-        }
-        // common case where there are multiple value/label pairs
-        if (tokens.length % 2 === 0) {
-            let mag = 0.0;
-            for (let i = 0; i < tokens.length; i = i + 2) {
-                if (tokens[i].isNumber && tokens[i + 1].isString) {
-                    const value = tokens[i].value;
-                    const conversion = Parser.tryFindUnitConversion(tokens[i + 1].value, unitsConversions, defaultUnit);
-                    if (conversion) {
-                        if (mag < 0.0)
-                            mag = mag - ((value * conversion.factor)) + conversion.offset;
-                        else
-                            mag = mag + ((value * conversion.factor)) + conversion.offset;
-                    }
+            else {
+                // only the unit label was specified so assume magnitude of 0
+                const conversion = Parser.tryFindUnitConversion(tokenPair[0].value, unitsConversions, defaultUnit);
+                if (conversion === undefined) {
+                    // Unknown unit label
+                    return { ok: false, error: ParseError.NoValueOrUnitFoundInString };
                 }
             }
-            return { ok: true, value: mag };
         }
-        return { ok: false, error: ParseError.UnableToConvertParseTokensToQuantity };
+        return { ok: true, value: mag };
     }
     /** Method to generate a Quantity given a string that represents a quantity value.
      *  @param inString A string that contains text represent a quantity.
      *  @param parserSpec unit label if not explicitly defined by user. Must have matching entry in supplied array of unitsConversions.
-     *  @param defaultValue default value to return if parsing is un successful
      */
     static parseQuantityString(inString, parserSpec) {
         return Parser.parseToQuantityValue(inString, parserSpec.format, parserSpec.unitConversions);
@@ -493,6 +557,9 @@ class Parser {
         const tokens = Parser.parseQuantitySpecification(inString, format);
         if (tokens.length === 0)
             return { ok: false, error: ParseError.UnableToGenerateParseTokens };
+        if (!format.allowMathematicOperations && Parser.isMathematicOperation(tokens)) {
+            return { ok: false, error: ParseError.MathematicOperationFoundButIsNotAllowed };
+        }
         if (Parser._log) {
             // eslint-disable-next-line no-console
             console.log(`Parse tokens`);