Amendment of FormulaEvaluation and CustomFormatting classes to reduce use of 'any'

Amendment to CustomFormatting class type annotations

Author: Tom German

src/common/utilities/CustomFormatting.ts

@@ -4,6 +4,8 @@ import { FormulaEvaluation } from "./FormulaEvaluation";
 import { ASTNode, Context } from "./FormulaEvaluation.types";
 import { ICustomFormattingExpressionNode, ICustomFormattingNode } from "./ICustomFormatting";
 
+type CustomFormatResult = string | number | boolean | JSX.Element | ICustomFormattingNode;
+
 /**
  * A class that provides helper methods for custom formatting
  * See: https://learn.microsoft.com/en-us/sharepoint/dev/declarative-customization/formatting-syntax-reference
@@ -47,15 +49,15 @@ export default class CustomFormattingHelper {
      * @param context A context object containing values / variables to be used in the evaluation
      * @returns 
      */
-    private evaluateCustomFormatContent = (content: ICustomFormattingExpressionNode | ICustomFormattingNode | string | number | boolean, context: Context): JSX.Element | string | number | boolean => {
+    private evaluateCustomFormatContent = (content: ICustomFormattingExpressionNode | ICustomFormattingNode | string | number | boolean, context: Context): CustomFormatResult => {
 
         // If content is a string or number, it is a literal value and should be returned as-is
         if ((typeof content === "string" && content.charAt(0) !== "=") || typeof content === "number") return content;
 
         // If content is a string beginning with '=' it is a formula/expression, and should be evaluated
         if (typeof content === "string" && content.charAt(0) === "=") {
             const result = this._formulaEvaluator.evaluate(content.substring(1), context);
-            return result;
+            return result as CustomFormatResult;
         }
 
         // If content is an object, it is either further custom formatting described by an ICustomFormattingNode,
@@ -74,9 +76,9 @@ export default class CustomFormattingHelper {
                 const astNode = this.convertCustomFormatExpressionNodes(content as ICustomFormattingExpressionNode);
                 const result = this._formulaEvaluator.evaluateASTNode(astNode, context);
                 if (typeof result === "object" && Object.prototype.hasOwnProperty.call(result, "elmType")) {
-                    return this.renderCustomFormatContent(result, context);
+                    return this.renderCustomFormatContent(result as ICustomFormattingNode, context);
                 }
-                return result;
+                return result as CustomFormatResult;
 
             }
         } 
@@ -94,7 +96,7 @@ export default class CustomFormattingHelper {
 
             // Custom formatting nodes / elements may have a txtContent property, which represents the inner
             // content of a HTML element. This can be a string literal, or another expression to be evaluated:
-            let textContent: JSX.Element | string | number | boolean | undefined;
+            let textContent: CustomFormatResult | undefined;
             if (node.txtContent) {
                 textContent = this.evaluateCustomFormatContent(node.txtContent, context);
             }
@@ -135,7 +137,7 @@ export default class CustomFormattingHelper {
             }
 
             // Custom formatting nodes / elements may have children. These are likely to be further custom formatting
-            let children: (JSX.Element | string | number | boolean | undefined)[] = [];
+            let children: (CustomFormatResult)[] = [];
 
             // If the node has an iconName property, we'll render an Icon component as the first child.
             // SharePoint uses CSS to apply the icon in a ::before rule, but we can't count on the global selector for iconName

src/common/utilities/FormulaEvaluation.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { IContext } from "../Interfaces";
 import { ASTNode, ArrayLiteralNode, ArrayNodeValue, Context, Token, TokenType, ValidFuncNames } from "./FormulaEvaluation.types";
 
@@ -31,7 +30,7 @@ export class FormulaEvaluation {
     }
 
     /** Evaluates a formula expression and returns the result, with optional context object for variables */
-    public evaluate(expression: string, context: Context = {}): any {
+    public evaluate(expression: string, context: Context = {}): boolean | string | number | ArrayNodeValue | object {
         context.me = this._meEmail;
         context.today = new Date();
         const tokens: Token[] = this.tokenize(expression, context);
@@ -240,7 +239,8 @@ export class FormulaEvaluation {
         return stack[0] as ASTNode;
     }
 
-    public evaluateASTNode(node: ASTNode | ArrayLiteralNode | ArrayNodeValue | string | number, context: Context = {}): any {
+    public evaluateASTNode(node: ASTNode | ArrayLiteralNode | ArrayNodeValue | string | number, context: Context = {}): 
+        boolean | number | string | ArrayNodeValue | object {
 
         if (!node) return 0;
 
@@ -293,34 +293,40 @@ export class FormulaEvaluation {
         // OPERATOR nodes have their OPERANDS evaluated recursively, with the operator applied to the results
         if (node.type === "OPERATOR" && operatorTypes.includes(node.value as string) && node.operands) {
 
-            const leftValue = this.evaluateASTNode(node.operands[0], context);
-            const rightValue = this.evaluateASTNode(node.operands[1], context);
+            const leftValue = this.evaluateASTNode(node.operands[0], context) as string | number;
+            const rightValue = this.evaluateASTNode(node.operands[1], context) as string | number;
+
+            // These operators are valid for both string and number operands
+            switch (node.value) {
+                case "==": return leftValue === rightValue ? 1 : 0;
+                case "!=": return leftValue !== rightValue ? 1 : 0;
+                case "<>": return leftValue !== rightValue ? 1 : 0;
+                case ">": return leftValue > rightValue ? 1 : 0;
+                case "<": return leftValue < rightValue ? 1 : 0;
+                case ">=": return leftValue >= rightValue ? 1 : 0;
+                case "<=": return leftValue <= rightValue ? 1 : 0;
+                case "&&": return (leftValue !== 0 && rightValue !== 0) ? 1 : 0;
+                case "||": return (leftValue !== 0 || rightValue !== 0) ? 1 : 0;
+            }
 
             if (typeof leftValue === "string" || typeof rightValue === "string") {
-                // Throw an error if the operator is not valid for strings
-                if (["-", "*", "/"].includes(node.value as string)) {
-                    throw new Error(`Invalid operation ${node.value} with string operand.`);
-                }
                 // Concatenate strings if either operand is a string
                 if (node.value === "+") {
-                    return (leftValue || "").toString() + (rightValue || "").toString();
+                    const concatString: string = (leftValue || "").toString() + (rightValue || "").toString();
+                    return concatString;
+                } else {
+                    // Throw an error if the operator is not valid for strings
+                    throw new Error(`Invalid operation ${node.value} with string operand.`);
                 }
             }
 
+            // Both operands will be numbers at this point
             switch (node.value) {
                 case "+": return leftValue + rightValue;
                 case "-": return leftValue - rightValue;
                 case "*": return leftValue * rightValue;
                 case "/": return leftValue / rightValue;
-                case "==": return leftValue === rightValue ? 1 : 0;
-                case "!=": return leftValue !== rightValue ? 1 : 0;
-                case "<>": return leftValue !== rightValue ? 1 : 0;
-                case ">": return leftValue > rightValue ? 1 : 0;
-                case "<": return leftValue < rightValue ? 1 : 0;
-                case ">=": return leftValue >= rightValue ? 1 : 0;
-                case "<=": return leftValue <= rightValue ? 1 : 0;
-                case "&&": return (leftValue !== 0 && rightValue !== 0) ? 1 : 0;
-                case "||": return (leftValue !== 0 || rightValue !== 0) ? 1 : 0;
+                
                 case "%": return leftValue % rightValue;
                 case "&": return leftValue & rightValue;
                 case "|": return leftValue | rightValue;
@@ -330,7 +336,10 @@ export class FormulaEvaluation {
         // Evaluation of function nodes is handled here:
 
         if (node.type === "FUNCTION" && node.operands) {
-            const funcArgs = node.operands.map(arg => this.evaluateASTNode(arg, context));
+
+            // Evaluate operands recursively - casting to any here to allow for any type of operand
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const funcArgs = node.operands.map(arg => this.evaluateASTNode(arg, context)) as any[];
 
             switch (node.value) {