[PORT] Pass Locale info from Activity to Adaptive-Expression and support locale in formatNumber prebuilt functions

libraries/adaptive-expressions/package.json

@@ -31,7 +31,8 @@
     "lodash": "^4.17.19",
     "lru-cache": "^5.1.1",
     "moment": "^2.25.1",
-    "moment-timezone": "^0.5.28"
+    "moment-timezone": "^0.5.28",
+    "d3-format":"^1.4.4"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.7.12",

libraries/adaptive-expressions/src/builtinFunctions/formatNumber.ts

@@ -6,11 +6,14 @@
  * Licensed under the MIT License.
  */
 
+import { formatLocale as d3formatLocale, format as d3format } from 'd3-format';
 import { Expression } from '../expression';
 import { EvaluateExpressionDelegate, ExpressionEvaluator } from '../expressionEvaluator';
 import { ExpressionType } from '../expressionType';
 import { FunctionUtils } from '../functionUtils';
 import { ReturnType } from '../returnType';
+import { Options } from '../options';
+import { localeInfo } from '../localeInfo';
 
 /**
  * Format number into required decimal numbers.
@@ -27,35 +30,40 @@ export class FormatNumber extends ExpressionEvaluator {
      * @private
      */
     private static evaluator(): EvaluateExpressionDelegate {
-        return FunctionUtils.applyWithError((args: any[]): any => {
-            let value: any = null;
+        return FunctionUtils.applyWithOptionsAndError((args: unknown[], options: Options): {
+            value: unknown;
+            error: string;
+        } => {
+            let value: unknown = null;
             let error: string;
             const number = args[0];
             const precision = args[1];
-            const locale = args.length > 2 ? args[2] : 'en-us';
+            let locale = options.locale;
+            locale = FunctionUtils.determineLocale(args, 3, locale);
             if (typeof number !== 'number') {
                 error = `formatNumber first argument ${number} must be a number`;
             } else if (typeof precision !== 'number') {
                 error = `formatNumber second argument ${precision} must be a number`;
             } else if (locale && typeof locale !== 'string') {
                 error = `formatNubmer third argument ${locale} is not a valid locale`;
             } else {
-                // NOTE: Nodes toLocaleString and Intl do not work to localize unless a special version of node is used.
-                // TODO: In R10 we should try another package.  Numeral and d3-format have the basics, but no locale specific.
-                // Numbro has locales, but is optimized for the browser.
-                value = number.toLocaleString(locale, {
-                    minimumFractionDigits: precision,
-                    maximumFractionDigits: precision,
-                });
+                const fixedNotation = `,.${precision}f`;
+                const roundedNumber = this.roundToPrecision(number, precision);
+                const formatLocale = localeInfo[locale];
+                if (formatLocale !== undefined) {
+                    value = d3formatLocale(formatLocale).format(fixedNotation)(roundedNumber);
+                } else {
+                    value = d3format(fixedNotation)(roundedNumber);
+                }
             }
 
             return { value, error };
         });
     }
 
-    /**
-     * @private
-     */
+    private static roundToPrecision = (num: number, digits: number): number =>
+        Math.round(num * Math.pow(10, digits)) / Math.pow(10, digits);
+
     private static validator(expr: Expression): void {
         FunctionUtils.validateOrder(expr, [ReturnType.String], ReturnType.Number, ReturnType.Number);
     }

libraries/adaptive-expressions/src/functionUtils.ts

@@ -501,6 +501,33 @@ export class FunctionUtils {
         };
     }
 
+    /**
+     * Generate an expression delegate that applies function after verifying all children.
+     * @param func Function to apply.
+     * @param verify Function to check each arg for validity.
+     * @returns Delegate for evaluating an expression.
+     */
+    public static applyWithOptionsAndError(
+        func: (arg0: unknown[], options: Options) => { value: unknown; error: string },
+        verify?: VerifyExpression
+    ): EvaluateExpressionDelegate {
+        return (expression: Expression, state: MemoryInterface, options: Options): ValueWithError => {
+            let value: unknown;
+            let error: string;
+            let args: unknown[];
+            ({ args, error } = FunctionUtils.evaluateChildren(expression, state, options, verify));
+            if (!error) {
+                try {
+                    ({ value, error } = func(args, options));
+                } catch (e) {
+                    error = e.message;
+                }
+            }
+
+            return { value, error };
+        };
+    }
+
     /**
      * Generate an expression delegate that applies function on the accumulated value after verifying all children.
      * @param func Function to apply.
@@ -551,6 +578,20 @@ export class FunctionUtils {
         }, verify);
     }
 
+    /**
+     *
+     * @param args An array of arguments.
+     * @param locale A locale string
+     * @param maxArgsLength The max length of a given function.
+     */
+    public static determineLocale(args: unknown[], maxArgsLength: number, locale = 'en-us'): string {
+        if (args.length === maxArgsLength && typeof args[maxArgsLength - 1] === 'string') {
+            locale = args[maxArgsLength - 1] as string;
+        }
+
+        return locale;
+    }
+
     /**
      * Timestamp formatter, convert C# datetime to moment js format.
      * @param formatter C# datetime format

libraries/adaptive-expressions/src/index.ts

@@ -33,4 +33,5 @@ export {
 } from './builtinFunctions';
 export * from './functionUtils';
 export * from './returnType';
+export * from './localeInfo';
 export * from './triggerTrees';