Calculated fields

{
    "id": "worksheetB_line8",
    "questionText": "Line 8. Divide the amount on line 7 by $1,000, round any fraction to the nearest whole number enter this number on line 1b of the DE 4. Complete Worksheet C, if needed, otherwise stop here",
    "htmlType": "INPUT",
    "displayType": "DOLLAR",
    "required": {
        "whenRequired": "NEVER"
    },
    "calculation": {
        "formula": "worksheetB_line7 / 1000",
        "roundingMode": "HALF_UP",
        "scale": 0
    },
    "isCalculated": true
}

/*
 *  Converts the calculation object of a given question into an anonymous function
 *  that can be run to return the result.
 *
 *  Calculation object from API:
 *  {
 *    "formula": "( field1 > field2 ) ? field1 - field2 : 0",
 *    "scale": 1,
 *    "roundingMode": "FLOOR"
 *  }
 *
 *  Converted to anonymous function:
 *  function() {
 *      var result = ( 4.5 > 2.0 ) ? 4.5 - 2.0 : 0;
 *      if (isNaN(result) || !isFinite(result)) { result = 0; }
 *      result = Math.floor(result * 10) / 10;
 *      return result;
 *  }
 */
export const processCalculation = (calculationObj, allAnswersForForm) => {
    let processedFormula = "";

    // split formula into individual tokens and get question IDs
    const questionIds = getQuestionIds(calculationObj.formula.split(" "));

    // create variables for question IDs
    questionIds.forEach(questionId => {
        const value = allAnswersForForm[questionId] === undefined 
            ? "null" : (isValueBoolean(allAnswersForForm[questionId]) 
                ? "(String('" + allAnswersForForm[questionId] + "').toLowerCase() === 'true')" : "Number('" + allAnswersForForm[questionId] + "'.split(',').join(''))");
      
        processedFormula += "var " + questionId +  " = " + value + "; ";
    });

    // add calculation formula
    processedFormula += "var result = " + calculationObj.formula + "; ";

    // make sure result is a finite number, otherwise set to 0
    processedFormula += "if (isNaN(result) || !isFinite(result)) { result = 0; } ";

    // process rounding mode and/or scale if necessary
    if (calculationObj.hasOwnProperty("scale") || calculationObj.hasOwnProperty("roundingMode")) {
        processedFormula += handleRoundingAndScale(calculationObj.roundingMode, calculationObj.scale);
    }

    // return result of formula from anonymous function
    processedFormula += "return result;";

    // create and call anonymous function to process, returning result
    const calculationFunction = new Function(processedFormula);
    return calculationFunction();
}

const handleRoundingAndScale = (roundingMode, scale) => {
    if (scale === undefined || isNaN(parseInt(scale)) || parseInt(scale) < 0) {
        scale = 0;
    }
    else {
        scale = parseInt(scale);
    }

    // scale formula: round(value * (10 ^ scale)) / (10 ^ scale)
    const scalingFactor = Math.pow(10, scale);
    let processedFormulaPart = "result = ";
    if (roundingMode !== undefined) {
        if (roundingMode === "CEILING") {
            processedFormulaPart += scale > 0 ? ("Math.ceil(result * " + scalingFactor + ") / " + scalingFactor + "; ") : "Math.ceil(result); ";
        }
        else if (roundingMode === "FLOOR") {
            processedFormulaPart += scale > 0 ? ("Math.floor(result * " + scalingFactor + ") / " + scalingFactor + "; ") : "Math.floor(result); ";
        }
        else {
            processedFormulaPart += scale > 0 ? ("Math.round(result * " + scalingFactor + ") / " + scalingFactor + "; ") : "Math.round(result); ";
        }

        if (scale === 0) {
            // drop any remaining fraction if scale is 0
            processedFormulaPart += "Math.trunc(result); ";
        }
    }
    else {
        // no rounding needed, just set scale
        processedFormulaPart += scale > 0 ? ("Math.floor(result * " + scalingFactor + ") / " + scalingFactor + "; ") : "Math.trunc(result); ";
    }

    return processedFormulaPart;
}

const isSymbol = (token) => {
    switch (token) {
        case "(":    // open parenthesis
        case ")":    // close parenthesis
        case "+":    // addition
        case "-":    // subtraction
        case "*":    // multiplication
        case "/":    // division
        case "?":    // ternary condition operator
        case ":":    // ternary expression operator
        case "<":    // less than
        case ">":    // greater than
        case "<=":   // less than or equal
        case ">=":   // greater than or equal
        case "==":   // equals
        case "!=":   // not equals
        case "|":    // logical OR
        case "||":   // short-circuiting logical OR
        case "&":    // logical AND
        case "&&":   // short-circuiting logical AND
        case "null": // null, none, NaN, etc
            return true;
        default:
            return false;
    }
}

const isValueBoolean = (value) => {
    switch (value) {
        case "true":
        case "false":
            return true;
        default:
            return false;
    }
}

const getQuestionIds = (tokens) => {
    const questionIds = [];
    if (tokens) {
        tokens.forEach((token) => {
            // check if token is a symbol or a digit
            if (!isSymbol(token) && isNaN(token)) {
                questionIds.push(token);
            }
        });
    }

    // remove duplicates and return
    return [ ...new Set(questionIds) ];
}