@fw-components/formula-editor 2.0.7-formula-editor.22 → 2.0.7-formula-editor.23

package/dist/formula-editor/src/suggestion-menu.js

@@ -12,7 +12,7 @@ let SuggestionMenu = class SuggestionMenu extends LitElement {
         super(...arguments);
         this.recommendations = [];
         this.onClickRecommendation = (recommendation) => { };
-        this._selectedRecommendationIndex = 0;
+        this._selectedRecommendationIndex = -1;
     }
     scrollToSelectedRecommendation(index) {
         const listItem = this.suggestionList?.querySelectorAll("li")[index];

package/dist/formula-editor/src/utils/constants.js

@@ -1,4 +1,5 @@
 export const mathematicalOperators = new Set(["^", "+", "-", "*", "/"]);
+export const unaryOperators = ["+", "-"];
 export const operatorPrecedence = {
     "^": 3,
     "/": 2,

package/dist/formula-editor/src/utils/parser.js

@@ -3,14 +3,19 @@ import { Recommender } from "./recommendor.js";
 import { Stack } from "./stack.js";
 import { Queue } from "./queue.js";
 import { Expectation } from "../types";
-import { mathematicalOperators, operatorPrecedence } from "./constants.js";
+import { mathematicalOperators, operatorPrecedence, unaryOperators } from "./constants.js";
 export class Parser {
     constructor(variables, minSuggestionLen) {
         this.variables = variables;
         this._recommender = new Recommender(Array.from(this.variables.keys()), minSuggestionLen);
     }
+    getFormulaTokens(formulaString) {
+        if (!formulaString?.length)
+            return [];
+        return formulaString.match(/'[^']*'|\d+|[A-Za-z_][A-Za-z0-9_]*|[-+(),*^/:?\s]/g);
+    }
     parseInput(formula, prevCurPos = null, recommendation = null) {
-        const tokens = formula.match(/'[^']*'|\d+|[A-Za-z_][A-Za-z0-9_]*|[-+(),*^/:?\s]/g);
+        const tokens = this.getFormulaTokens(formula);
         const parentheses = new Stack();
         let expectation = Expectation.VARIABLE;
         let currentPosition = 0;
@@ -80,7 +85,7 @@ export class Parser {
                  * No error for Unary `+` and `-` as they might represent a positive or negative number respectively
                  */
                 else if (expectation === Expectation.VARIABLE && !isNumber && !isSpace && token != "("
-                    && !((token === "-" || token === "+") && (!parsedString.trim() || previousToken === "(" || mathematicalOperators.has(previousToken)))) {
+                    && !((unaryOperators.includes(token)) && (!parsedString.trim() || previousToken === "(" || mathematicalOperators.has(previousToken)))) {
                     parseOutput.errorString = `Expected variable/number at position ${currentPosition}`;
                     expectation = Expectation.UNDEFINED;
                 }
@@ -150,20 +155,16 @@ export class Parser {
         return parseOutput;
     }
     buildRPN(formula) {
-        if (this.parseInput(formula).errorString) {
+        if (this.parseInput(formula).errorString)
             return null;
-        }
-        const tokens = formula
-            .match(/'[^']*'|\d+|[A-Za-z_][A-Za-z0-9_]*|[-+(),*^/:?\s]/g)
-            ?.filter((el) => !/\s+/.test(el) && el !== "");
-        // Handling the special case of unary `-` and `+`.
+        const tokens = this.getFormulaTokens(formula)?.filter((el) => !/\s+/.test(el) && el !== "");
         let previousToken = "";
         let carriedToken = null;
         const parsedTokens = [];
         let currentTokens = "";
+        // Check if variables include unary operators `-` and `+`.
         for (const token of tokens) {
-            if ((token === "+" || token === "-") &&
-                (!currentTokens.trim() || previousToken === "(" || mathematicalOperators.has(previousToken))) {
+            if ((unaryOperators.includes(token)) && (!currentTokens.trim() || previousToken === "(" || mathematicalOperators.has(previousToken))) {
                 carriedToken = token;
             }
             else if (carriedToken) {
@@ -192,9 +193,7 @@ export class Parser {
                 operatorStack.pop();
             }
             else if (mathematicalOperators.has(token)) {
-                while (mathematicalOperators.has(operatorStack.top()) &&
-                    operatorPrecedence[token] <=
-                        operatorPrecedence[operatorStack.top()]) {
+                while (mathematicalOperators.has(operatorStack.top()) && operatorPrecedence[token] <= operatorPrecedence[operatorStack.top()]) {
                     outputQueue.enqueue(operatorStack.pop());
                 }
                 operatorStack.push(token);
@@ -210,87 +209,67 @@ export class Parser {
     }
     addParentheses(formula) {
         const rpn = this.buildRPN(formula);
-        if (!rpn) {
+        if (!rpn)
             return null;
-        }
         const lexedRPN = [];
         while (!rpn.isEmpty()) {
             lexedRPN.push(rpn.dequeue());
         }
-        // Stores the operators that we encounter in the RPN
-        let operatorStack = new Stack();
-        // Stores the `results`, which are essentially individual groups
-        // of tokens showing a meaningful value.
-        let resultStack = new Stack();
+        const operatorStack = new Stack();
+        const resultStack = new Stack();
         lexedRPN.forEach((symbol) => {
-            let parsedLeftExpression, parsedRightExpression;
-            // If we encounter a number or a variable in the RPN, it is itself
-            // a calculated entity (say a result in itself), needs no modification
-            // and can be directly put into the result stack.
-            if (((symbol[0] === "+" || symbol[0] === "-") && this.variables.has(symbol.substring(1))) ||
+            let parsedLeftExpression;
+            let parsedRightExpression;
+            // check if the symbol is a number or variable or unaryOperatorPreceded Variable
+            if (((unaryOperators.includes(symbol[0])) && this.variables.has(symbol.substring(1))) ||
                 this.variables.has(symbol) ||
                 (!isNaN(parseFloat(symbol)) && isFinite(parseFloat(symbol)))) {
                 resultStack.push(symbol);
                 operatorStack.push(null);
             }
-            // If it is not a number/variable then it is an operator. We will
-            // take out previous operators from the `operatorStack`, compare
-            // them with the current one, adds brackets accordingly to the `results`
-            // around it, and then finally add it to the `operatorStack` for
-            // future reference.
+            // If symbol is an operator, check operatorStack, adds brackets accordingly to the result and add it to operatorStack
             else if (Object.keys(operatorPrecedence).includes(symbol)) {
-                let [rightExpression, leftExpression, operatorA, operatorB] = [
+                const [rightExpression, leftExpression, operatorA, operatorB] = [
                     resultStack.pop(),
                     resultStack.pop(),
                     operatorStack.pop(),
                     operatorStack.pop(),
                 ];
-                // The conditions that govern when to show a parenthesis.
-                if (operatorPrecedence[operatorB] <=
-                    operatorPrecedence[symbol] ||
-                    (operatorPrecedence[operatorB] ===
-                        operatorPrecedence[symbol] &&
-                        ["/", "-"].includes(symbol))) {
+                if ((operatorPrecedence[operatorB] <= operatorPrecedence[symbol]) ||
+                    (operatorPrecedence[operatorB] === operatorPrecedence[symbol] && ["/", "-"].includes(symbol))) {
                     parsedLeftExpression = `(${leftExpression})`;
                 }
                 else {
                     parsedLeftExpression = leftExpression;
                 }
-                if (operatorPrecedence[operatorA] <=
-                    operatorPrecedence[symbol] ||
-                    (operatorPrecedence[operatorA] ===
-                        operatorPrecedence[symbol] &&
-                        ["/", "-"].includes(symbol))) {
+                if (operatorPrecedence[operatorA] <= operatorPrecedence[symbol] ||
+                    (operatorPrecedence[operatorA] === operatorPrecedence[symbol] && ["/", "-"].includes(symbol))) {
                     parsedRightExpression = `(${rightExpression})`;
                 }
                 else {
                     parsedRightExpression = rightExpression;
                 }
-                // The bracket included expression is now itself a `result`
                 resultStack.push(`${parsedLeftExpression} ${symbol} ${parsedRightExpression}`);
                 operatorStack.push(symbol);
             }
             else
                 throw `${symbol} is not a recognized symbol`;
         });
-        if (!resultStack.isEmpty()) {
-            return resultStack.pop();
-        }
-        else
+        if (resultStack.isEmpty())
             throw `${lexedRPN} is not a correct RPN`;
+        return resultStack.pop();
     }
     calculate(formula) {
-        let rpn = this.buildRPN(formula);
-        let calculationResult = {
+        const formulaRPN = this.buildRPN(formula);
+        const calculationResult = {
             result: undefined,
             errorString: null,
         };
-        if (!rpn) {
+        if (!formulaRPN)
             return calculationResult;
-        }
-        let calcStack = new Stack();
-        while (!rpn.isEmpty()) {
-            const frontItem = rpn.dequeue();
+        const calcStack = new Stack();
+        while (!formulaRPN.isEmpty()) {
+            const frontItem = formulaRPN.dequeue();
             if (!mathematicalOperators.has(frontItem)) {
                 const [sign, variableKey] = /^[+-]/.test(frontItem) ? [frontItem[0], frontItem.slice(1)] : ["", frontItem];
                 const operandValue = Number.parseFloat(this.variables.get(variableKey)?.toString() ?? variableKey);
@@ -298,9 +277,9 @@ export class Parser {
                 calcStack.push(Big(number));
             }
             else {
-                let operator = frontItem;
-                let numB = calcStack.pop();
-                let numA = calcStack.pop();
+                const operator = frontItem;
+                const numB = calcStack.pop();
+                const numA = calcStack.pop();
                 try {
                     switch (operator) {
                         case "+":
@@ -319,8 +298,6 @@ export class Parser {
                             }
                             calcStack.push(Big(numA).div(Big(numB)));
                             break;
-                        // Big.js doesn't support exponentiating a Big to a Big, which
-                        // is obvious due to performance overheads. Use this case with care.
                         case "^":
                             calcStack.push(Big(numA).pow(parseFloat(Big(numB).toString())));
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fw-components/formula-editor",
-  "version": "2.0.7-formula-editor.22",
+  "version": "2.0.7-formula-editor.23",
   "description": "A WYSIWYG type formula editor",
   "main": "dist/formula-editor/src/formula-editor.js",
   "exports": {
@@ -31,5 +31,5 @@
     "@types/big.js": "^6.1.6",
     "es-dev-server": "^2.1.0"
   },
-  "gitHead": "daf2f4613926ce2aaef670decf920e336e5b4781"
+  "gitHead": "aabc3f2d04b0d5e9fc5dfdbc5773407d35b15a18"
 }