@itwin/grouping-mapping-widget 0.3.0 → 0.3.3

package/lib/esm/formula/FormulaOperatorsProvider.js

@@ -0,0 +1,174 @@
+const allOperators = ["+", "-", "*", "%", "**", "/", "`", "~", "!", "@", "#", "$", "^", "&", "=", "[", "]", "{", "}", "\\", "|", ";", ":", "'", "\"", "<", ">", "?", "+=", "-=", "*=", "/=", "%=", "&=", "^=", "|=", "?=", "==", "!=", ">=", "<=", "++", "--", "<<", ">>", "&&", "||", "??", "?.", "**=", "<<=", ">>=", "&&=", "||=", "??=", "===", "!==", ">>>", ">>>="];
+export var OperatorType;
+(function (OperatorType) {
+    OperatorType[OperatorType["UnaryPlus"] = 0] = "UnaryPlus";
+    OperatorType[OperatorType["UnaryNegation"] = 1] = "UnaryNegation";
+    OperatorType[OperatorType["Exponentiation"] = 2] = "Exponentiation";
+    OperatorType[OperatorType["Multiplication"] = 3] = "Multiplication";
+    OperatorType[OperatorType["Division"] = 4] = "Division";
+    OperatorType[OperatorType["Remainder"] = 5] = "Remainder";
+    OperatorType[OperatorType["Addition"] = 6] = "Addition";
+    OperatorType[OperatorType["Subtraction"] = 7] = "Subtraction";
+    OperatorType[OperatorType["LogicalNot"] = 8] = "LogicalNot";
+    OperatorType[OperatorType["LessThan"] = 9] = "LessThan";
+    OperatorType[OperatorType["LessThanOrEqual"] = 10] = "LessThanOrEqual";
+    OperatorType[OperatorType["GreaterThan"] = 11] = "GreaterThan";
+    OperatorType[OperatorType["GreaterThanOrEqual"] = 12] = "GreaterThanOrEqual";
+    OperatorType[OperatorType["Equality"] = 13] = "Equality";
+    OperatorType[OperatorType["Inequality"] = 14] = "Inequality";
+    OperatorType[OperatorType["LogicalAnd"] = 15] = "LogicalAnd";
+    OperatorType[OperatorType["LogicalOr"] = 16] = "LogicalOr";
+})(OperatorType || (OperatorType = {}));
+export var OperatorAssociativity;
+(function (OperatorAssociativity) {
+    OperatorAssociativity[OperatorAssociativity["Left"] = 0] = "Left";
+    OperatorAssociativity[OperatorAssociativity["Right"] = 1] = "Right";
+})(OperatorAssociativity || (OperatorAssociativity = {}));
+export function isOperator(token) {
+    return allOperators.includes(token);
+}
+export function getBinaryOperator(token) {
+    switch (token) {
+        case "**": return OperatorType.Exponentiation;
+        case "*": return OperatorType.Multiplication;
+        case "/": return OperatorType.Division;
+        case "%": return OperatorType.Remainder;
+        case "+": return OperatorType.Addition;
+        case "-": return OperatorType.Subtraction;
+        case "<": return OperatorType.LessThan;
+        case "<=": return OperatorType.LessThanOrEqual;
+        case ">": return OperatorType.GreaterThan;
+        case ">=": return OperatorType.GreaterThanOrEqual;
+        case "==": return OperatorType.Equality;
+        case "!=": return OperatorType.Inequality;
+        case "&&": return OperatorType.LogicalAnd;
+        case "||": return OperatorType.LogicalOr;
+        default: return undefined;
+    }
+}
+export function getUnaryOperator(token) {
+    switch (token) {
+        case "+": return OperatorType.UnaryPlus;
+        case "-": return OperatorType.UnaryNegation;
+        case "!": return OperatorType.LogicalNot;
+        default: return undefined;
+    }
+}
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence
+export function getOperatorPrecedence(op) {
+    switch (op) {
+        case OperatorType.UnaryPlus:
+        case OperatorType.UnaryNegation:
+        case OperatorType.LogicalNot:
+            return 15;
+        case OperatorType.Exponentiation:
+            return 14;
+        case OperatorType.Multiplication:
+        case OperatorType.Division:
+        case OperatorType.Remainder:
+            return 13;
+        case OperatorType.Subtraction:
+        case OperatorType.Addition:
+            return 12;
+        case OperatorType.LessThan:
+        case OperatorType.LessThanOrEqual:
+        case OperatorType.GreaterThan:
+        case OperatorType.GreaterThanOrEqual:
+            return 10;
+        case OperatorType.Equality:
+        case OperatorType.Inequality:
+            return 9;
+        case OperatorType.LogicalAnd:
+            return 5;
+        case OperatorType.LogicalOr:
+            return 4;
+        default: return 1;
+    }
+}
+export function getOperatorAssociativity(op) {
+    switch (op) {
+        case OperatorType.UnaryPlus:
+        case OperatorType.UnaryNegation:
+        case OperatorType.Exponentiation:
+        case OperatorType.LogicalNot:
+            return OperatorAssociativity.Right;
+        case OperatorType.Multiplication:
+        case OperatorType.Division:
+        case OperatorType.Remainder:
+        case OperatorType.Addition:
+        case OperatorType.Subtraction:
+        case OperatorType.LessThan:
+        case OperatorType.LessThanOrEqual:
+        case OperatorType.GreaterThan:
+        case OperatorType.GreaterThanOrEqual:
+        case OperatorType.Equality:
+        case OperatorType.Inequality:
+        case OperatorType.LogicalAnd:
+        case OperatorType.LogicalOr:
+            return OperatorAssociativity.Left;
+        default:
+            return OperatorAssociativity.Left;
+    }
+}
+export function isSupportedOperator(token) {
+    return undefined !== getUnaryOperator(token) || undefined !== getBinaryOperator(token);
+}
+export function getOperatorArgumentCountBounds(token) {
+    switch (token) {
+        case "**": return [2, 2];
+        case "*": return [2, 2];
+        case "/": return [2, 2];
+        case "%": return [2, 2];
+        case "+": return [1, 2];
+        case "-": return [1, 2];
+        case "!": return [1, 1];
+        case "<": return [2, 2];
+        case "<=": return [2, 2];
+        case ">": return [2, 2];
+        case ">=": return [2, 2];
+        case "==": return [2, 2];
+        case "!=": return [2, 2];
+        case "&&": return [2, 2];
+        case "||": return [2, 2];
+        default: return undefined;
+    }
+}
+export function getOperatorReturnType(token, arg1, arg2) {
+    if (!arg2 && !getUnaryOperator(token))
+        return { errorMessage: `Unary operator "${token}" is not supported.` };
+    if (arg2 && !getBinaryOperator(token))
+        return { errorMessage: `Binary operator "${token}" is not supported.` };
+    if ((arg1 === "undefined" || arg2 === "undefined") && (token !== "==" && token !== "!="))
+        return { errorMessage: `${!arg2 ? "Unary" : "Binary"} operator "${token}" does not support null operands.` };
+    switch (token) {
+        case "**":
+        case "*":
+        case "/":
+        case "%":
+            return arg1 === "string" || arg2 === "string" ?
+                { errorMessage: `Binary operator "${token}" does not support string operands.` } :
+                { value: "number" };
+        case "-":
+            return arg1 === "string" || arg2 === "string" ?
+                { errorMessage: `${!arg2 ? "Unary" : "Binary"} operator "${token}" does not support string operands.` } :
+                { value: "number" };
+        case "+":
+            if (!arg2)
+                return { value: arg1 };
+            else
+                return arg1 === "string" || arg2 === "string" ? { value: "string" } : { value: "number" };
+        case "!":
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+        case "==":
+        case "!=":
+        case "&&":
+        case "||":
+            return { value: "boolean" };
+        default:
+            return { errorMessage: `Operator "${token}" is not supported.` };
+    }
+}
+//# sourceMappingURL=FormulaOperatorsProvider.js.map

package/lib/esm/formula/FormulaOperatorsProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaOperatorsProvider.js","sourceRoot":"","sources":["../../../src/formula/FormulaOperatorsProvider.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\nimport type { IResult } from \"./IResult\";\nimport type { DataType, PossibleDataType } from \"./Types\";\n\nconst allOperators = [\"+\", \"-\", \"*\", \"%\", \"**\", \"/\", \"`\", \"~\", \"!\", \"@\", \"#\", \"$\", \"^\", \"&\", \"=\", \"[\", \"]\", \"{\", \"}\", \"\\\\\", \"|\", \";\", \":\", \"'\", \"\\\"\", \"<\", \">\", \"?\", \"+=\", \"-=\", \"*=\", \"/=\", \"%=\", \"&=\", \"^=\", \"|=\", \"?=\", \"==\", \"!=\", \">=\", \"<=\", \"++\", \"--\", \"<<\", \">>\", \"&&\", \"||\", \"??\", \"?.\", \"**=\", \"<<=\", \">>=\", \"&&=\", \"||=\", \"??=\", \"===\", \"!==\", \">>>\", \">>>=\"];\n\nexport enum OperatorType {\n  UnaryPlus,\n  UnaryNegation,\n  Exponentiation,\n  Multiplication,\n  Division,\n  Remainder,\n  Addition,\n  Subtraction,\n  LogicalNot,\n  LessThan,\n  LessThanOrEqual,\n  GreaterThan,\n  GreaterThanOrEqual,\n  Equality,\n  Inequality,\n  LogicalAnd,\n  LogicalOr,\n}\n\nexport enum OperatorAssociativity {\n  Left,\n  Right,\n}\n\nexport function isOperator(token: string): boolean {\n  return allOperators.includes(token);\n}\n\nexport function getBinaryOperator(token: string): OperatorType | undefined {\n  switch (token) {\n    case \"**\": return OperatorType.Exponentiation;\n    case \"*\": return OperatorType.Multiplication;\n    case \"/\": return OperatorType.Division;\n    case \"%\": return OperatorType.Remainder;\n    case \"+\": return OperatorType.Addition;\n    case \"-\": return OperatorType.Subtraction;\n    case \"<\": return OperatorType.LessThan;\n    case \"<=\": return OperatorType.LessThanOrEqual;\n    case \">\": return OperatorType.GreaterThan;\n    case \">=\": return OperatorType.GreaterThanOrEqual;\n    case \"==\": return OperatorType.Equality;\n    case \"!=\": return OperatorType.Inequality;\n    case \"&&\": return OperatorType.LogicalAnd;\n    case \"||\": return OperatorType.LogicalOr;\n    default: return undefined;\n  }\n}\n\nexport function getUnaryOperator(token: string): OperatorType | undefined {\n  switch (token) {\n    case \"+\": return OperatorType.UnaryPlus;\n    case \"-\": return OperatorType.UnaryNegation;\n    case \"!\": return OperatorType.LogicalNot;\n    default: return undefined;\n  }\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence\nexport function getOperatorPrecedence(op: OperatorType | undefined): number {\n  switch (op) {\n    case OperatorType.UnaryPlus:\n    case OperatorType.UnaryNegation:\n    case OperatorType.LogicalNot:\n      return 15;\n    case OperatorType.Exponentiation:\n      return 14;\n    case OperatorType.Multiplication:\n    case OperatorType.Division:\n    case OperatorType.Remainder:\n      return 13;\n    case OperatorType.Subtraction:\n    case OperatorType.Addition:\n      return 12;\n    case OperatorType.LessThan:\n    case OperatorType.LessThanOrEqual:\n    case OperatorType.GreaterThan:\n    case OperatorType.GreaterThanOrEqual:\n      return 10;\n    case OperatorType.Equality:\n    case OperatorType.Inequality:\n      return 9;\n    case OperatorType.LogicalAnd:\n      return 5;\n    case OperatorType.LogicalOr:\n      return 4;\n    default: return 1;\n  }\n}\n\nexport function getOperatorAssociativity(op: OperatorType | undefined): number {\n  switch (op) {\n    case OperatorType.UnaryPlus:\n    case OperatorType.UnaryNegation:\n    case OperatorType.Exponentiation:\n    case OperatorType.LogicalNot:\n      return OperatorAssociativity.Right;\n    case OperatorType.Multiplication:\n    case OperatorType.Division:\n    case OperatorType.Remainder:\n    case OperatorType.Addition:\n    case OperatorType.Subtraction:\n    case OperatorType.LessThan:\n    case OperatorType.LessThanOrEqual:\n    case OperatorType.GreaterThan:\n    case OperatorType.GreaterThanOrEqual:\n    case OperatorType.Equality:\n    case OperatorType.Inequality:\n    case OperatorType.LogicalAnd:\n    case OperatorType.LogicalOr:\n      return OperatorAssociativity.Left;\n    default:\n      return OperatorAssociativity.Left;\n  }\n}\n\nexport function isSupportedOperator(token: string): boolean {\n  return undefined !== getUnaryOperator(token) || undefined !== getBinaryOperator(token);\n}\n\nexport function getOperatorArgumentCountBounds(token: string): [number, number] | undefined {\n  switch (token) {\n    case \"**\": return [2, 2];\n    case \"*\": return [2, 2];\n    case \"/\": return [2, 2];\n    case \"%\": return [2, 2];\n    case \"+\": return [1, 2];\n    case \"-\": return [1, 2];\n    case \"!\": return [1, 1];\n    case \"<\": return [2, 2];\n    case \"<=\": return [2, 2];\n    case \">\": return [2, 2];\n    case \">=\": return [2, 2];\n    case \"==\": return [2, 2];\n    case \"!=\": return [2, 2];\n    case \"&&\": return [2, 2];\n    case \"||\": return [2, 2];\n    default: return undefined;\n  }\n}\n\nexport function getOperatorReturnType(token: string, arg1: PossibleDataType, arg2?: PossibleDataType): IResult<DataType> {\n  if (!arg2 && !getUnaryOperator(token))\n    return { errorMessage: `Unary operator \"${token}\" is not supported.` };\n\n  if (arg2 && !getBinaryOperator(token))\n    return { errorMessage: `Binary operator \"${token}\" is not supported.` };\n\n  if ((arg1 === \"undefined\" || arg2 === \"undefined\") && (token !== \"==\" && token !== \"!=\"))\n    return { errorMessage: `${!arg2 ? \"Unary\" : \"Binary\"} operator \"${token}\" does not support null operands.` };\n\n  switch (token) {\n    case \"**\":\n    case \"*\":\n    case \"/\":\n    case \"%\":\n      return arg1 === \"string\" || arg2 === \"string\" ?\n        { errorMessage: `Binary operator \"${token}\" does not support string operands.` } :\n        { value: \"number\" };\n    case \"-\":\n      return arg1 === \"string\" || arg2 === \"string\" ?\n        { errorMessage: `${!arg2 ? \"Unary\" : \"Binary\"} operator \"${token}\" does not support string operands.` } :\n        { value: \"number\" };\n    case \"+\":\n      if (!arg2)\n        return { value: arg1 as DataType };\n      else\n        return arg1 === \"string\" || arg2 === \"string\" ? { value: \"string\" } : { value: \"number\" };\n    case \"!\":\n    case \"<\":\n    case \"<=\":\n    case \">\":\n    case \">=\":\n    case \"==\":\n    case \"!=\":\n    case \"&&\":\n    case \"||\":\n      return { value: \"boolean\" };\n    default:\n      return { errorMessage: `Operator \"${token}\" is not supported.` };\n  }\n}\n"]}

package/lib/esm/formula/FormulaSplitter.d.ts

@@ -0,0 +1,2 @@
+export declare function splitFormula(formula: string): string[];
+//# sourceMappingURL=FormulaSplitter.d.ts.map

package/lib/esm/formula/FormulaSplitter.js

@@ -0,0 +1,136 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { InputStream } from "./InputStream";
+import { StringBuilder } from "./StringBuilder";
+import { isDecimalSeparator, isDigit, isLetterOrUnderscore, isStringDelimiter, isWhitespace } from "./Utils";
+const fourSymbolCombinations = [">>>="];
+const threeSymbolCombinations = ["**=", "<<=", ">>=", "&&=", "||=", "??=", "===", "!==", ">>>"];
+const twoSymbolCombinations = ["+=", "-=", "*=", "/=", "%=", "&=", "^=", "|=", "?=", "==", "!=", ">=", "<=", "++", "--", "**", "<<", ">>", "&&", "||", "??", "?."];
+const oneSymbolCombinations = ["~", "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "=", "+", "[", "]", "{", "}", "\\", "|", ";", ":", ",", ".", "<", ">", "/", "?"];
+const symbolCombinations = [
+    fourSymbolCombinations,
+    threeSymbolCombinations,
+    twoSymbolCombinations,
+    oneSymbolCombinations,
+];
+function parseScientificNotation(stream) {
+    const notationBuilder = new StringBuilder();
+    const nextChar = stream.next;
+    const afterEChar = stream.peek;
+    if (isDigit(afterEChar) || afterEChar === "+" || afterEChar === "-") {
+        notationBuilder.push(nextChar);
+        notationBuilder.push(stream.next);
+        while (isDigit(stream.peek)) {
+            notationBuilder.push(stream.next);
+        }
+        if (isDecimalSeparator(stream.peek)) {
+            throw new Error("The exponent in scientific notation must be an integer.");
+        }
+    }
+    else {
+        stream.undo;
+    }
+    return notationBuilder.value;
+}
+function parseNumber(stream) {
+    const numberBuilder = new StringBuilder(stream.current);
+    let hasSeparator = isDecimalSeparator(stream.current);
+    while (true) {
+        const peekedChar = stream.peek;
+        if (peekedChar.toLowerCase() === "e") {
+            numberBuilder.push(parseScientificNotation(stream));
+            break;
+        }
+        if (isDecimalSeparator(peekedChar)) {
+            if (hasSeparator) {
+                throw new Error("A number cannot have multiple decimal separators.");
+            }
+            hasSeparator = true;
+            numberBuilder.push(stream.next);
+            continue;
+        }
+        if (isDigit(peekedChar)) {
+            numberBuilder.push(stream.next);
+        }
+        else {
+            break;
+        }
+    }
+    return numberBuilder.value;
+}
+function unescape(char) {
+    switch (char) {
+        case "n": return "\n";
+        case "t": return "\t";
+        default: return char;
+    }
+}
+function parseStringLiteral(stream) {
+    const stringBuilder = new StringBuilder(stream.current);
+    const delimiter = stream.current;
+    while (stream.next !== delimiter) {
+        if (stream.isEOF) {
+            throw new Error(`Missing closing string delimiter (${delimiter}).`);
+        }
+        stringBuilder.push(stream.current === "\\" ? unescape(stream.next) : stream.current);
+    }
+    stringBuilder.push(stream.current);
+    return stringBuilder.value;
+}
+function parseVariable(stream) {
+    const variableBuilder = new StringBuilder(stream.current);
+    while (isLetterOrUnderscore(stream.peek) || isDigit(stream.peek)) {
+        variableBuilder.push(stream.next);
+    }
+    if (isDecimalSeparator(stream.peek)) {
+        throw new Error("Decimal separator in variable.");
+    }
+    return variableBuilder.value;
+}
+function parseSymbolCombination(stream) {
+    const symbolComboBuilder = new StringBuilder(stream.current);
+    while (symbolComboBuilder.length < symbolCombinations.length && oneSymbolCombinations.includes(stream.peek)) {
+        symbolComboBuilder.push(stream.next);
+    }
+    for (let i = symbolCombinations.length - symbolComboBuilder.length; i < symbolCombinations.length - 1; i++) {
+        const symbolCombo = symbolComboBuilder.value;
+        if (symbolCombinations[i].includes(symbolCombo)) {
+            return symbolCombo;
+        }
+        symbolComboBuilder.pop();
+        stream.undo;
+    }
+    return symbolComboBuilder.value;
+}
+function parseFormula(formula) {
+    const tokens = [];
+    const stream = new InputStream(formula);
+    while (!stream.isEOF) {
+        const char = stream.next;
+        if (isWhitespace(char)) {
+            continue;
+        }
+        if (isDigit(char) || isDecimalSeparator(char)) {
+            tokens.push(parseNumber(stream));
+        }
+        else if (isLetterOrUnderscore(char)) {
+            tokens.push(parseVariable(stream));
+        }
+        else if (isStringDelimiter(char)) {
+            tokens.push(parseStringLiteral(stream));
+        }
+        else if (oneSymbolCombinations.includes(char)) {
+            tokens.push(parseSymbolCombination(stream));
+        }
+        else {
+            throw new Error(`Unknown symbol received "${char}".`);
+        }
+    }
+    return tokens;
+}
+export function splitFormula(formula) {
+    return parseFormula(formula);
+}
+//# sourceMappingURL=FormulaSplitter.js.map

package/lib/esm/formula/FormulaSplitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaSplitter.js","sourceRoot":"","sources":["../../../src/formula/FormulaSplitter.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE7G,MAAM,sBAAsB,GAAG,CAAC,MAAM,CAAC,CAAC;AACxC,MAAM,uBAAuB,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAChG,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AACnK,MAAM,qBAAqB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAE5K,MAAM,kBAAkB,GAAe;IACrC,sBAAsB;IACtB,uBAAuB;IACvB,qBAAqB;IACrB,qBAAqB;CACtB,CAAC;AAEF,SAAS,uBAAuB,CAAC,MAAmB;IAClD,MAAM,eAAe,GAAG,IAAI,aAAa,EAAE,CAAC;IAE5C,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC;IAC7B,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC;IAC/B,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,UAAU,KAAK,GAAG,IAAI,UAAU,KAAK,GAAG,EAAE;QACnE,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/B,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAClC,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YAC3B,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;SACnC;QACD,IAAI,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YACnC,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;SAC5E;KACF;SAAM;QACL,MAAM,CAAC,IAAI,CAAC;KACb;IAED,OAAO,eAAe,CAAC,KAAK,CAAC;AAC/B,CAAC;AAED,SAAS,WAAW,CAAC,MAAmB;IACtC,MAAM,aAAa,GAAG,IAAI,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACxD,IAAI,YAAY,GAAG,kBAAkB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAEtD,OAAO,IAAI,EAAE;QACX,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC;QAC/B,IAAI,UAAU,CAAC,WAAW,EAAE,KAAK,GAAG,EAAE;YACpC,aAAa,CAAC,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAC;YACpD,MAAM;SACP;QAED,IAAI,kBAAkB,CAAC,UAAU,CAAC,EAAE;YAClC,IAAI,YAAY,EAAE;gBAChB,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;aACtE;YACD,YAAY,GAAG,IAAI,CAAC;YACpB,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAChC,SAAS;SACV;QAED,IAAI,OAAO,CAAC,UAAU,CAAC,EAAE;YACvB,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;SACjC;aAAM;YACL,MAAM;SACP;KACF;IAED,OAAO,aAAa,CAAC,KAAK,CAAC;AAC7B,CAAC;AAED,SAAS,QAAQ,CAAC,IAAY;IAC5B,QAAQ,IAAI,EAAE;QACZ,KAAK,GAAG,CAAC,CAAC,OAAO,IAAI,CAAC;QACtB,KAAK,GAAG,CAAC,CAAC,OAAO,IAAI,CAAC;QACtB,OAAO,CAAC,CAAC,OAAO,IAAI,CAAC;KACtB;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,MAAmB;IAC7C,MAAM,aAAa,GAAG,IAAI,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACxD,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC;IAEjC,OAAO,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE;QAChC,IAAI,MAAM,CAAC,KAAK,EAAE;YAChB,MAAM,IAAI,KAAK,CAAC,qCAAqC,SAAS,IAAI,CAAC,CAAC;SACrE;QAED,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;KACtF;IAED,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACnC,OAAO,aAAa,CAAC,KAAK,CAAC;AAC7B,CAAC;AAED,SAAS,aAAa,CAAC,MAAmB;IACxC,MAAM,eAAe,GAAG,IAAI,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAE1D,OAAO,oBAAoB,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;QAChE,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;KACnC;IAED,IAAI,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;QACnC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;KACnD;IAED,OAAO,eAAe,CAAC,KAAK,CAAC;AAC/B,CAAC;AAED,SAAS,sBAAsB,CAAC,MAAmB;IACjD,MAAM,kBAAkB,GAAG,IAAI,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7D,OAAO,kBAAkB,CAAC,MAAM,GAAG,kBAAkB,CAAC,MAAM,IAAI,qBAAqB,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;QAC3G,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;KACtC;IAED,KAAK,IAAI,CAAC,GAAG,kBAAkB,CAAC,MAAM,GAAG,kBAAkB,CAAC,MAAM,EAAE,CAAC,GAAG,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;QAC1G,MAAM,WAAW,GAAG,kBAAkB,CAAC,KAAK,CAAC;QAC7C,IAAI,kBAAkB,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;YAC/C,OAAO,WAAW,CAAC;SACpB;QACD,kBAAkB,CAAC,GAAG,EAAE,CAAC;QACzB,MAAM,CAAC,IAAI,CAAC;KACb;IAED,OAAO,kBAAkB,CAAC,KAAK,CAAC;AAClC,CAAC;AAED,SAAS,YAAY,CAAC,OAAe;IACnC,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,MAAM,MAAM,GAAG,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;IACxC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE;QACpB,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACzB,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE;YACtB,SAAS;SACV;QAED,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,IAAI,CAAC,EAAE;YAC7C,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;SAClC;aAAM,IAAI,oBAAoB,CAAC,IAAI,CAAC,EAAE;YACrC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;SACpC;aAAM,IAAI,iBAAiB,CAAC,IAAI,CAAC,EAAE;YAClC,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC;SACzC;aAAM,IAAI,qBAAqB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;YAC/C,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC,CAAC;SAC7C;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,4BAA4B,IAAI,IAAI,CAAC,CAAC;SACvD;KACF;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,OAAe;IAC1C,OAAO,YAAY,CAAC,OAAO,CAAC,CAAC;AAC/B,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\nimport { InputStream } from \"./InputStream\";\nimport { StringBuilder } from \"./StringBuilder\";\nimport { isDecimalSeparator, isDigit, isLetterOrUnderscore, isStringDelimiter, isWhitespace } from \"./Utils\";\n\nconst fourSymbolCombinations = [\">>>=\"];\nconst threeSymbolCombinations = [\"**=\", \"<<=\", \">>=\", \"&&=\", \"||=\", \"??=\", \"===\", \"!==\", \">>>\"];\nconst twoSymbolCombinations = [\"+=\", \"-=\", \"*=\", \"/=\", \"%=\", \"&=\", \"^=\", \"|=\", \"?=\", \"==\", \"!=\", \">=\", \"<=\", \"++\", \"--\", \"**\", \"<<\", \">>\", \"&&\", \"||\", \"??\", \"?.\"];\nconst oneSymbolCombinations = [\"~\", \"!\", \"@\", \"#\", \"$\", \"%\", \"^\", \"&\", \"*\", \"(\", \")\", \"-\", \"=\", \"+\", \"[\", \"]\", \"{\", \"}\", \"\\\\\", \"|\", \";\", \":\", \",\", \".\", \"<\", \">\", \"/\", \"?\"];\n\nconst symbolCombinations: string[][] = [\n  fourSymbolCombinations,\n  threeSymbolCombinations,\n  twoSymbolCombinations,\n  oneSymbolCombinations,\n];\n\nfunction parseScientificNotation(stream: InputStream) {\n  const notationBuilder = new StringBuilder();\n\n  const nextChar = stream.next;\n  const afterEChar = stream.peek;\n  if (isDigit(afterEChar) || afterEChar === \"+\" || afterEChar === \"-\") {\n    notationBuilder.push(nextChar);\n    notationBuilder.push(stream.next);\n    while (isDigit(stream.peek)) {\n      notationBuilder.push(stream.next);\n    }\n    if (isDecimalSeparator(stream.peek)) {\n      throw new Error(\"The exponent in scientific notation must be an integer.\");\n    }\n  } else {\n    stream.undo;\n  }\n\n  return notationBuilder.value;\n}\n\nfunction parseNumber(stream: InputStream): string {\n  const numberBuilder = new StringBuilder(stream.current);\n  let hasSeparator = isDecimalSeparator(stream.current);\n\n  while (true) {\n    const peekedChar = stream.peek;\n    if (peekedChar.toLowerCase() === \"e\") {\n      numberBuilder.push(parseScientificNotation(stream));\n      break;\n    }\n\n    if (isDecimalSeparator(peekedChar)) {\n      if (hasSeparator) {\n        throw new Error(\"A number cannot have multiple decimal separators.\");\n      }\n      hasSeparator = true;\n      numberBuilder.push(stream.next);\n      continue;\n    }\n\n    if (isDigit(peekedChar)) {\n      numberBuilder.push(stream.next);\n    } else {\n      break;\n    }\n  }\n\n  return numberBuilder.value;\n}\n\nfunction unescape(char: string): string {\n  switch (char) {\n    case \"n\": return \"\\n\";\n    case \"t\": return \"\\t\";\n    default: return char;\n  }\n}\n\nfunction parseStringLiteral(stream: InputStream): string {\n  const stringBuilder = new StringBuilder(stream.current);\n  const delimiter = stream.current;\n\n  while (stream.next !== delimiter) {\n    if (stream.isEOF) {\n      throw new Error(`Missing closing string delimiter (${delimiter}).`);\n    }\n\n    stringBuilder.push(stream.current === \"\\\\\" ? unescape(stream.next) : stream.current);\n  }\n\n  stringBuilder.push(stream.current);\n  return stringBuilder.value;\n}\n\nfunction parseVariable(stream: InputStream): string {\n  const variableBuilder = new StringBuilder(stream.current);\n\n  while (isLetterOrUnderscore(stream.peek) || isDigit(stream.peek)) {\n    variableBuilder.push(stream.next);\n  }\n\n  if (isDecimalSeparator(stream.peek)) {\n    throw new Error(\"Decimal separator in variable.\");\n  }\n\n  return variableBuilder.value;\n}\n\nfunction parseSymbolCombination(stream: InputStream): string {\n  const symbolComboBuilder = new StringBuilder(stream.current);\n  while (symbolComboBuilder.length < symbolCombinations.length && oneSymbolCombinations.includes(stream.peek)) {\n    symbolComboBuilder.push(stream.next);\n  }\n\n  for (let i = symbolCombinations.length - symbolComboBuilder.length; i < symbolCombinations.length - 1; i++) {\n    const symbolCombo = symbolComboBuilder.value;\n    if (symbolCombinations[i].includes(symbolCombo)) {\n      return symbolCombo;\n    }\n    symbolComboBuilder.pop();\n    stream.undo;\n  }\n\n  return symbolComboBuilder.value;\n}\n\nfunction parseFormula(formula: string): string[] {\n  const tokens: string[] = [];\n  const stream = new InputStream(formula);\n  while (!stream.isEOF) {\n    const char = stream.next;\n    if (isWhitespace(char)) {\n      continue;\n    }\n\n    if (isDigit(char) || isDecimalSeparator(char)) {\n      tokens.push(parseNumber(stream));\n    } else if (isLetterOrUnderscore(char)) {\n      tokens.push(parseVariable(stream));\n    } else if (isStringDelimiter(char)) {\n      tokens.push(parseStringLiteral(stream));\n    } else if (oneSymbolCombinations.includes(char)) {\n      tokens.push(parseSymbolCombination(stream));\n    } else {\n      throw new Error(`Unknown symbol received \"${char}\".`);\n    }\n  }\n\n  return tokens;\n}\n\nexport function splitFormula(formula: string): string[] {\n  return parseFormula(formula);\n}\n"]}

package/lib/esm/formula/FormulaTokensValidator.d.ts

@@ -0,0 +1,5 @@
+import type { Token } from "./InfixToPostfixConverter";
+import type { Queue } from "./Queue";
+import type { PropertyMap } from "./Types";
+export declare function validateTokens(tokens: Queue<Token>, properties: PropertyMap): string;
+//# sourceMappingURL=FormulaTokensValidator.d.ts.map

package/lib/esm/formula/FormulaTokensValidator.js

@@ -0,0 +1,131 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { getFormulaFunctionReturnType, getFunction } from "./FormulaFunctionProvider";
+import { getOperatorArgumentCountBounds, getOperatorReturnType, isOperator } from "./FormulaOperatorsProvider";
+import { TokenType } from "./InfixToPostfixConverter";
+import { Stack } from "./Stack";
+function isNumericalConstant(name) {
+    return [
+        "e",
+        "ln2",
+        "ln10",
+        "log2e",
+        "log10e",
+        "pi",
+        "sqrt1_2",
+        "sqrt2",
+    ].includes(name.toLowerCase());
+}
+export function validateTokens(tokens, properties) {
+    if (tokens.length === 0)
+        return "Formula cannot be empty.";
+    const argStack = new Stack();
+    while (tokens.length > 0) {
+        const token = tokens.dequeue();
+        switch (token.type) {
+            case TokenType.Number:
+                argStack.push("number");
+                break;
+            case TokenType.String:
+                argStack.push("string");
+                break;
+            case TokenType.Boolean:
+                argStack.push("boolean");
+                break;
+            case TokenType.Null:
+                argStack.push("undefined");
+                break;
+            case TokenType.Variable:
+                const isConstant = isNumericalConstant(token.value);
+                if (isConstant) {
+                    argStack.push("number");
+                }
+                else {
+                    const prop = properties[token.value];
+                    if (!prop)
+                        return `Variable "${token.value}" is not available.`;
+                    argStack.push(prop);
+                }
+                break;
+            case TokenType.Operator:
+                if (!isOperator(token.value))
+                    return `Operator "${token.value}" is not supported.`;
+                const operatorBounds = getOperatorArgumentCountBounds(token.value);
+                if (!operatorBounds)
+                    return `Operator "${token.value}" is not supported.`;
+                if (operatorBounds[0] === 2 && token.argCount === 1)
+                    return `Unary operator "${token.value}" is not supported.`;
+                if (argStack.length < token.argCount) {
+                    return `Too few arguments given for ${token.argCount === 1 ? "unary" : "binary"} operator "${token.value}".`;
+                }
+                const opArgs = argStack.popN(token.argCount).reverse();
+                let operationResult;
+                if (opArgs.length === 1)
+                    operationResult = getOperatorReturnType(token.value, opArgs[0]);
+                else if (opArgs.length === 2)
+                    operationResult = getOperatorReturnType(token.value, opArgs[0], opArgs[1]);
+                else
+                    return `Operator "${token.value}" does not support ${token.argCount} operands.`;
+                if (operationResult.errorMessage)
+                    return operationResult.errorMessage;
+                else
+                    argStack.push(operationResult.value);
+                break;
+            case TokenType.Function:
+                const fnArg = getFunction(token.value);
+                if (!fnArg)
+                    return `Function "${token.value}" is not supported.`;
+                const fnArgBounds = fnArg.argumentCountBounds;
+                if (fnArgBounds[0] === 0 && fnArgBounds[1] === 0 && token.argCount > 0) {
+                    return `Function "${token.value}" does not accept any arguments.`;
+                }
+                else if (fnArgBounds[1] === -1 && token.argCount < fnArgBounds[0]) {
+                    if (fnArgBounds[0] === 1) {
+                        return `Function "${token.value}" requires at least 1 argument.`;
+                    }
+                    else {
+                        if (token.argCount === 1) {
+                            return `Function "${token.value}" requires at least ${fnArgBounds[0]} arguments, but only 1 argument was given.`;
+                        }
+                        else {
+                            return `Function "${token.value}" requires at least ${fnArgBounds[0]} arguments, but only ${token.argCount} arguments were given.`;
+                        }
+                    }
+                }
+                else if (fnArgBounds[0] === fnArgBounds[1] && token.argCount !== fnArgBounds[0]) {
+                    if (fnArgBounds[0] === 1) {
+                        return `Function "${token.value}" requires exactly 1 argument, but ${token.argCount} arguments were given.`;
+                    }
+                    else {
+                        if (token.argCount === 1) {
+                            return `Function "${token.value}" requires exactly ${fnArgBounds[0]} arguments, but 1 argument was given.`;
+                        }
+                        else {
+                            return `Function "${token.value}" requires exactly ${fnArgBounds[0]} arguments, but ${token.argCount} arguments were given.`;
+                        }
+                    }
+                }
+                const fArgs = argStack.popN(token.argCount).reverse();
+                if (fArgs.length < token.argCount) {
+                    return `Too few arguments given for function "${token.value}".`;
+                }
+                const functionResult = getFormulaFunctionReturnType(fnArg, fArgs);
+                if (functionResult.errorMessage)
+                    return `Function "${token.value}" is invalid. ${functionResult.errorMessage}`;
+                else
+                    argStack.push(functionResult.value);
+                break;
+        }
+    }
+    if (argStack.length !== 1) {
+        return "Formula is invalid.";
+    }
+    const resultType = argStack.pop();
+    if (!resultType || resultType === "undefined") {
+        return "Formula cannot always return null.";
+    }
+    return "";
+}
+//# sourceMappingURL=FormulaTokensValidator.js.map

package/lib/esm/formula/FormulaTokensValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaTokensValidator.js","sourceRoot":"","sources":["../../../src/formula/FormulaTokensValidator.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\nimport { getFormulaFunctionReturnType, getFunction } from \"./FormulaFunctionProvider\";\nimport { getOperatorArgumentCountBounds, getOperatorReturnType, isOperator } from \"./FormulaOperatorsProvider\";\nimport type { Token } from \"./InfixToPostfixConverter\";\nimport { TokenType } from \"./InfixToPostfixConverter\";\nimport type { Queue } from \"./Queue\";\nimport { Stack } from \"./Stack\";\nimport type { PossibleDataType, PropertyMap } from \"./Types\";\n\nfunction isNumericalConstant(name: string): boolean {\n  return [\n    \"e\",\n    \"ln2\",\n    \"ln10\",\n    \"log2e\",\n    \"log10e\",\n    \"pi\",\n    \"sqrt1_2\",\n    \"sqrt2\",\n  ].includes(name.toLowerCase());\n}\n\nexport function validateTokens(tokens: Queue<Token>, properties: PropertyMap): string {\n  if (tokens.length === 0)\n    return \"Formula cannot be empty.\";\n\n  const argStack = new Stack<PossibleDataType>();\n\n  while (tokens.length > 0) {\n    const token = tokens.dequeue()!;\n\n    switch (token.type) {\n      case TokenType.Number:\n        argStack.push(\"number\");\n        break;\n      case TokenType.String:\n        argStack.push(\"string\");\n        break;\n      case TokenType.Boolean:\n        argStack.push(\"boolean\");\n        break;\n      case TokenType.Null:\n        argStack.push(\"undefined\");\n        break;\n      case TokenType.Variable:\n        const isConstant = isNumericalConstant(token.value);\n        if (isConstant) {\n          argStack.push(\"number\");\n        } else {\n          const prop = properties[token.value];\n          if (!prop)\n            return `Variable \"${token.value}\" is not available.`;\n          argStack.push(prop);\n        }\n        break;\n      case TokenType.Operator:\n        if (!isOperator(token.value))\n          return `Operator \"${token.value}\" is not supported.`;\n\n        const operatorBounds = getOperatorArgumentCountBounds(token.value);\n        if (!operatorBounds)\n          return `Operator \"${token.value}\" is not supported.`;\n\n        if (operatorBounds[0] === 2 && token.argCount === 1)\n          return `Unary operator \"${token.value}\" is not supported.`;\n\n        if (argStack.length < token.argCount) {\n          return `Too few arguments given for ${token.argCount === 1 ? \"unary\" : \"binary\"} operator \"${token.value}\".`;\n        }\n        const opArgs = argStack.popN(token.argCount).reverse();\n        let operationResult;\n        if (opArgs.length === 1)\n          operationResult = getOperatorReturnType(token.value, opArgs[0]);\n        else if (opArgs.length === 2)\n          operationResult = getOperatorReturnType(token.value, opArgs[0], opArgs[1]);\n        else\n          return `Operator \"${token.value}\" does not support ${token.argCount} operands.`;\n\n        if (operationResult.errorMessage)\n          return operationResult.errorMessage;\n        else\n          argStack.push(operationResult.value!);\n\n        break;\n      case TokenType.Function:\n        const fnArg = getFunction(token.value);\n        if (!fnArg)\n          return `Function \"${token.value}\" is not supported.`;\n\n        const fnArgBounds = fnArg.argumentCountBounds;\n        if (fnArgBounds[0] === 0 && fnArgBounds[1] === 0 && token.argCount > 0) {\n          return `Function \"${token.value}\" does not accept any arguments.`;\n        } else if (fnArgBounds[1] === -1 && token.argCount < fnArgBounds[0]) {\n          if (fnArgBounds[0] === 1) {\n            return `Function \"${token.value}\" requires at least 1 argument.`;\n          } else {\n            if (token.argCount === 1) {\n              return `Function \"${token.value}\" requires at least ${fnArgBounds[0]} arguments, but only 1 argument was given.`;\n            } else {\n              return `Function \"${token.value}\" requires at least ${fnArgBounds[0]} arguments, but only ${token.argCount} arguments were given.`;\n            }\n          }\n        } else if (fnArgBounds[0] === fnArgBounds[1] && token.argCount !== fnArgBounds[0]) {\n          if (fnArgBounds[0] === 1) {\n            return `Function \"${token.value}\" requires exactly 1 argument, but ${token.argCount} arguments were given.`;\n          } else {\n            if (token.argCount === 1) {\n              return `Function \"${token.value}\" requires exactly ${fnArgBounds[0]} arguments, but 1 argument was given.`;\n            } else {\n              return `Function \"${token.value}\" requires exactly ${fnArgBounds[0]} arguments, but ${token.argCount} arguments were given.`;\n            }\n          }\n        }\n\n        const fArgs = argStack.popN(token.argCount).reverse();\n        if (fArgs.length < token.argCount) {\n          return `Too few arguments given for function \"${token.value}\".`;\n        }\n\n        const functionResult = getFormulaFunctionReturnType(fnArg, fArgs);\n        if (functionResult.errorMessage)\n          return `Function \"${token.value}\" is invalid. ${functionResult.errorMessage}`;\n        else\n          argStack.push(functionResult.value!);\n\n        break;\n    }\n  }\n\n  if (argStack.length !== 1) {\n    return \"Formula is invalid.\";\n  }\n\n  const resultType = argStack.pop();\n  if (!resultType || resultType === \"undefined\") {\n    return \"Formula cannot always return null.\";\n  }\n\n  return \"\";\n}\n\n"]}

package/lib/esm/formula/FormulaValidator.d.ts

@@ -0,0 +1,3 @@
+import type { PropertyMap } from "./Types";
+export declare function validateFormula(formula: string, properties: PropertyMap): string;
+//# sourceMappingURL=FormulaValidator.d.ts.map

package/lib/esm/formula/FormulaValidator.js

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { splitFormula } from "./FormulaSplitter";
+import { validateTokens } from "./FormulaTokensValidator";
+import { convertInfixToPostfix } from "./InfixToPostfixConverter";
+import { ParenthesisState, validateParenthesis } from "./ParenthesisValidator";
+export function validateFormula(formula, properties) {
+    var _a;
+    const parenthesisState = validateParenthesis(formula);
+    if (ParenthesisState.NotClosed === parenthesisState) {
+        return "Opened but not closed parenthesis found.";
+    }
+    else if (ParenthesisState.NotOpened === parenthesisState) {
+        return "Closed but not opened parenthesis found.";
+    }
+    let infixFormulaTokens;
+    try {
+        infixFormulaTokens = splitFormula(formula);
+    }
+    catch (ex) {
+        return ex.message;
+    }
+    const postfixFormulaTokens = convertInfixToPostfix(infixFormulaTokens);
+    if (undefined === postfixFormulaTokens.value) {
+        return (_a = postfixFormulaTokens.errorMessage) !== null && _a !== void 0 ? _a : "Unknown error";
+    }
+    return validateTokens(postfixFormulaTokens.value, properties);
+}
+//# sourceMappingURL=FormulaValidator.js.map

package/lib/esm/formula/FormulaValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormulaValidator.js","sourceRoot":"","sources":["../../../src/formula/FormulaValidator.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAC/F,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAG/E,MAAM,UAAU,eAAe,CAAC,OAAe,EAAE,UAAuB;;IACtE,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACtD,IAAI,gBAAgB,CAAC,SAAS,KAAK,gBAAgB,EAAE;QACnD,OAAO,0CAA0C,CAAC;KACnD;SAAM,IAAI,gBAAgB,CAAC,SAAS,KAAK,gBAAgB,EAAE;QAC1D,OAAO,0CAA0C,CAAC;KACnD;IAED,IAAI,kBAAkB,CAAC;IACvB,IAAI;QACF,kBAAkB,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;KAC5C;IAAC,OAAO,EAAE,EAAE;QACX,OAAQ,EAAY,CAAC,OAAO,CAAC;KAC9B;IAED,MAAM,oBAAoB,GAAG,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;IAEvE,IAAI,SAAS,KAAK,oBAAoB,CAAC,KAAK,EAAE;QAC5C,OAAO,MAAA,oBAAoB,CAAC,YAAY,mCAAI,eAAe,CAAC;KAC7D;IAED,OAAO,cAAc,CAAC,oBAAoB,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;AAChE,CAAC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\nimport { splitFormula } from \"./FormulaSplitter\";\nimport { validateTokens } from \"./FormulaTokensValidator\";\nimport { convertInfixToPostfix } from \"./InfixToPostfixConverter\";\nimport { ParenthesisState, validateParenthesis } from \"./ParenthesisValidator\";\nimport type { PropertyMap } from \"./Types\";\n\nexport function validateFormula(formula: string, properties: PropertyMap): string {\n  const parenthesisState = validateParenthesis(formula);\n  if (ParenthesisState.NotClosed === parenthesisState) {\n    return \"Opened but not closed parenthesis found.\";\n  } else if (ParenthesisState.NotOpened === parenthesisState) {\n    return \"Closed but not opened parenthesis found.\";\n  }\n\n  let infixFormulaTokens;\n  try {\n    infixFormulaTokens = splitFormula(formula);\n  } catch (ex) {\n    return (ex as Error).message;\n  }\n\n  const postfixFormulaTokens = convertInfixToPostfix(infixFormulaTokens);\n\n  if (undefined === postfixFormulaTokens.value) {\n    return postfixFormulaTokens.errorMessage ?? \"Unknown error\";\n  }\n\n  return validateTokens(postfixFormulaTokens.value, properties);\n}\n"]}

package/lib/esm/formula/IResult.d.ts

@@ -0,0 +1,5 @@
+export interface IResult<T> {
+    value?: T;
+    errorMessage?: string;
+}
+//# sourceMappingURL=IResult.d.ts.map

package/lib/esm/formula/IResult.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IResult.js.map

package/lib/esm/formula/IResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IResult.js","sourceRoot":"","sources":["../../../src/formula/IResult.ts"],"names":[],"mappings":"","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\nexport interface IResult<T> {\n  value?: T;\n  errorMessage?: string;\n}\n"]}

package/lib/esm/formula/InfixToPostfixConverter.d.ts

@@ -0,0 +1,18 @@
+import type { IResult } from "./IResult";
+import { Queue } from "./Queue";
+export declare enum TokenType {
+    Number = 0,
+    Function = 1,
+    Operator = 2,
+    Variable = 3,
+    String = 4,
+    Boolean = 5,
+    Null = 6
+}
+export interface Token {
+    value: string;
+    type: TokenType;
+    argCount: number;
+}
+export declare function convertInfixToPostfix(infix: string[]): IResult<Queue<Token>>;
+//# sourceMappingURL=InfixToPostfixConverter.d.ts.map