adaptive-expressions/src/builtinFunctions/string.ts

Common Expression Language

/**
 * @module adaptive-expressions
 */
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */

import { formatLocale as d3formatLocale, format as d3format } from '../../vendors/d3-format';
import { EvaluateExpressionDelegate, ExpressionEvaluator, ValueWithError } from '../expressionEvaluator';
import { ExpressionType } from '../expressionType';
import { FunctionUtils } from '../functionUtils';
import { Options } from '../options';
import { ReturnType } from '../returnType';
import { localeInfo } from '../localeInfo';
import { Expression } from '../expression';
import { InternalFunctionUtils } from '../functionUtils.internal';

/**
 * Return the string version of a value.
 */
export class String extends ExpressionEvaluator {
    /**
     * Initializes a new instance of the [String](xref:adaptive-expressions.String) class.
     */
    constructor() {
        super(ExpressionType.String, String.evaluator(), ReturnType.String, String.validator);
    }

    /**
     * @private
     */
    private static evaluator(): EvaluateExpressionDelegate {
        return FunctionUtils.applyWithOptionsAndError((args: any[], options: Options): ValueWithError => {
            let result: any;
            let error: string;
            let locale = options.locale ? options.locale : Intl.DateTimeFormat().resolvedOptions().locale;
            if (!error) {
                locale = FunctionUtils.determineLocale(args, 2, locale);
            }

            if (!error) {
                if (typeof args[0] === 'string') {
                    result = args[0];
                } else if (FunctionUtils.isNumber(args[0])) {
                    const formatLocale = localeInfo[locale];
                    const tempStrValue = args[0].toString();
                    let precision = 0;
                    if (tempStrValue.includes('.')) {
                        precision = tempStrValue.split('.')[1].length;
                    }

                    const fixedNotation = `,.${precision}f`;
                    if (formatLocale !== undefined) {
                        result = d3formatLocale(formatLocale).format(fixedNotation)(args[0]);
                    } else {
                        result = d3format(fixedNotation)(args[0]);
                    }
                } else if (args[0] instanceof Date) {
                    result = args[0].toLocaleDateString(locale);
                } else if (args[0] instanceof Uint8Array) {
                    result = InternalFunctionUtils.getTextDecoder().decode(args[0]);
                } else {
                    result = InternalFunctionUtils.commonStringify(args[0]);
                }
            }

            return { value: result, error: error };
        });
    }

    /**
     * @private
     */
    private static validator(expr: Expression): void {
        FunctionUtils.validateOrder(expr, [ReturnType.String], ReturnType.Object);
    }
}