@adaptabletools/adaptable 14.0.0-canary.0 → 14.0.0-canary.1

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.observableExpressionFunctions = void 0;
+exports.observableExpressionFunctionNames = exports.observableExpressionFunctions = void 0;
 const tslib_1 = require("tslib");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const parseInt_1 = tslib_1.__importDefault(require("lodash/parseInt"));
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 // numeric value(digits) followed by a single 's', 'm' or 'h' letter (case insensitive)
 const TIMEFRAME_REGEX = /^(\d+)(s|m|h)$/i;
 const SYSTEM_MAX_TIMEFRAME_SIZE = 86400000; // 24h
@@ -20,6 +21,7 @@ exports.observableExpressionFunctions = {
         signatures: ['<main_query> WHERE <boolean_query>'],
         examples: ['<main_query> WHERE <boolean_query>', '<main_query> WHERE QUERY("abc")'],
         hasEagerEvaluation: true,
+        category: 'advanced',
     },
     ROW_CHANGE: {
         handler(args, context) {
@@ -52,13 +54,14 @@ exports.observableExpressionFunctions = {
                 }
             }
         },
-        isPredicate: true,
+        returnType: 'boolean',
         description: 'Observes changes with each row in a distinct scope',
         signatures: ['ROW_CHANGE(changeFunction: COUNT|MIN|MAX|NONE, timeframe:TIMEFRAME)'],
         examples: [
             "ROW_CHANGE( COUNT([columnName],2),TIMEFRAME('20s'))",
             "ROW_CHANGE( MAX(COL('columnName')), TIMEFRAME('20s'))",
         ],
+        category: 'observable',
     },
     GRID_CHANGE: {
         handler(args, context) {
@@ -93,13 +96,14 @@ exports.observableExpressionFunctions = {
                 }
             }
         },
-        isPredicate: true,
+        returnType: 'boolean',
         description: 'Observes changes with the entire grid in a single scope',
         signatures: ['GRID_CHANGE(changeFunction: COUNT|MIN|MAX|NONE, timeframe:TIMEFRAME)'],
         examples: [
             "GRID_CHANGE( COUNT([columnName],2),TIMEFRAME('20s'))",
             "GRID_CHANGE( MAX(COL('columnName')), TIMEFRAME('20s'))",
         ],
+        category: 'observable',
     },
     COL: {
         handler(args, context) {
@@ -108,6 +112,7 @@ exports.observableExpressionFunctions = {
         description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
         examples: ['[col1]', "COL('col1')"],
+        category: 'advanced',
     },
     COUNT: {
         handler(args) {
@@ -130,6 +135,7 @@ exports.observableExpressionFunctions = {
             'COUNT(COL(name: string),changeCount: number)',
         ],
         examples: ['COUNT([colName],2)', `COUNT(COL('col1'),10)`],
+        category: 'observable',
     },
     NONE: {
         handler(args) {
@@ -144,6 +150,7 @@ exports.observableExpressionFunctions = {
         description: 'Observes if a column value has NOT changed',
         signatures: ['NONE([colName])', 'NONE(COL(name: string))'],
         examples: ['NONE([colA])', `NONE(COL('col1'))`],
+        category: 'observable',
     },
     MIN: {
         handler(args) {
@@ -158,6 +165,7 @@ exports.observableExpressionFunctions = {
         description: 'Observes if the changed column value is the lowest',
         signatures: ['MIN([colName])', 'MIN(COL(name: string))'],
         examples: ['MIN([colA])', `MIN(COL('col1'))`],
+        category: 'observable',
     },
     MAX: {
         handler(args) {
@@ -172,6 +180,7 @@ exports.observableExpressionFunctions = {
         description: 'Observes if the changed column value is the highest',
         signatures: ['MAX([colName])', 'MAX(COL(name: string))'],
         examples: ['MAX([colA])', `MAX(COL('col1'))`],
+        category: 'observable',
     },
     TIMEFRAME: {
         handler(args, context) {
@@ -210,8 +219,10 @@ exports.observableExpressionFunctions = {
             "TIMEFRAME('%numeric_value%h')",
         ],
         examples: ["TIMEFRAME('20s')", "TIMEFRAME('5m')", "TIMEFRAME('1h')"],
+        category: 'observable',
     },
 };
+exports.observableExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.observableExpressionFunctions);
 // return TRUE if the last(tail) element has the greatest value
 const isLastElementMaxValue = (values) => {
     const [tailValue] = values.slice(-1);
@@ -246,7 +257,7 @@ const getDataChangedInfoStub = (context) => {
         const primaryKeyValue = context.adaptableApi.gridApi.getPrimaryKeyValueForRowNode(rowNode);
         const columnId = (_a = context.adaptableApi.columnApi.getQueryableColumns()[0]) === null || _a === void 0 ? void 0 : _a.columnId;
         const oldValue = context.adaptableApi.gridApi.getCellRawValue(primaryKeyValue, columnId);
-        const column = context.adaptableApi.columnApi.getColumnFromId(columnId);
+        const column = context.adaptableApi.columnApi.getColumnWithColumnId(columnId);
         const newValue = oldValue;
         return {
             changedAt: Date.now(),

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.d.ts

@@ -2,5 +2,6 @@ import { ExpressionFunction } from '../../parser/src/types';
 /**
  * List of all the Scalar Functions available in AdaptableQL
  */
-export declare type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'TODAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'COL' | 'VAR';
+export declare type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'TODAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'CASE' | 'COL' | 'VAR';
 export declare const scalarExpressionFunctions: Record<ScalarFunctionName, ExpressionFunction>;
+export declare const scalarExpressionFunctionNames: ScalarFunctionName[];

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scalarExpressionFunctions = void 0;
+exports.scalarExpressionFunctionNames = exports.scalarExpressionFunctions = void 0;
 const tslib_1 = require("tslib");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const parseISO_1 = tslib_1.__importDefault(require("date-fns/parseISO"));
@@ -19,6 +19,7 @@ const differenceInYears_1 = tslib_1.__importDefault(require("date-fns/difference
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const dateUtils_1 = require("./dateUtils");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 const sanitizeArguments = (values, allowNaN) => {
     return values.filter((value) => value != undefined && value != null && value !== '' && (allowNaN || !isNaN(value)));
 };
@@ -29,6 +30,39 @@ const sanitizeNumericResult = (value) => {
     return value;
 };
 exports.scalarExpressionFunctions = {
+    COL: {
+        handler(args, context) {
+            var _a, _b;
+            const columnId = args[0];
+            const column = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.columnApi.getColumnWithColumnId(columnId);
+            if (!column) {
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `Column name "${columnId}" is not found`);
+            }
+            if (!column.queryable) {
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `Column name "${columnId}" is not queryable`);
+            }
+            return (_b = context.adaptableApi) === null || _b === void 0 ? void 0 : _b.gridApi.getNormalisedValueFromRowNode(context.node, columnId);
+        },
+        description: 'Returns the value of a column',
+        signatures: ['[colName]', 'COL(name: string)'],
+        examples: ['[col1]', 'COL("col1")'],
+        category: 'advanced',
+        returnType: 'any',
+    },
+    VAR: {
+        handler(args, context) {
+            const [functionName, ...optionalArgs] = args;
+            if (StringExtensions_1.default.IsNullOrEmpty(functionName)) {
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('VAR', 'should have a name');
+            }
+            return context.evaluateCustomQueryVariable(functionName, optionalArgs);
+        },
+        description: 'Returns the variable evaluation',
+        signatures: ['VAR(varName)', 'VAR(varName, arg1, arg2)'],
+        examples: ['VAR(CURRENT_USER)', 'VAR(IS_VALID_VALUE, IS_BLANK([col1]), [col2] < [col3])'],
+        category: 'advanced',
+        returnType: 'any',
+    },
     ADD: {
         handler(args) {
             const sanitizedArguments = sanitizeArguments(args, true);
@@ -42,6 +76,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the sum of 2 numbers',
         signatures: ['number + number', 'ADD(a: number, b: number)'],
         examples: ['[col1] + 5', 'ADD([col1], 5)'],
+        category: 'math',
+        returnType: 'number',
     },
     SUB: {
         handler(args) {
@@ -56,6 +92,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the difference of 2 numbers',
         signatures: ['number - number', 'SUB(a: number, b: number)'],
         examples: ['[col1] - 5', 'SUB([col1], 5)'],
+        category: 'math',
+        returnType: 'number',
     },
     MUL: {
         handler(args) {
@@ -65,6 +103,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the product of 2 numbers',
         signatures: ['number * number', 'mul(a: number, b: number)'],
         examples: ['[col1] * 5', 'mul([col1], 5)'],
+        category: 'math',
+        returnType: 'number',
     },
     DIV: {
         handler(args) {
@@ -74,6 +114,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the division of 2 numbers',
         signatures: ['number / number', 'DIV(a: number, b: number)'],
         examples: ['[col1] / 5', 'DIV([col1], 5)'],
+        category: 'math',
+        returnType: 'number',
     },
     MOD: {
         handler(args) {
@@ -83,6 +125,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the modulo of 2 numbers',
         signatures: ['number % number', 'MOD(a: number, b: number)'],
         examples: ['[col1] % 5', 'MOD([col1], 5)'],
+        category: 'math',
+        returnType: 'number',
     },
     POW: {
         handler(args) {
@@ -92,6 +136,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the pow of 2 numbers',
         signatures: ['number ^ number', 'POW(a: number, b: number)'],
         examples: ['[col1] ^ 5', 'POW([col1], 5)'],
+        category: 'math',
+        returnType: 'number',
     },
     IF: {
         handler(args) {
@@ -101,23 +147,46 @@ exports.scalarExpressionFunctions = {
         description: 'Returns one of two statements based on a condition',
         signatures: ['condition ? true_statement : false_statement'],
         examples: ['[col1] > [col2] ? "BIG" : "SMALL"'],
-    },
-    COL: {
-        handler(args, context) {
-            var _a, _b;
-            const columnId = args[0];
-            const column = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.columnApi.getColumnFromId(columnId);
-            if (!column) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `Column name "${columnId}" is not found`);
-            }
-            if (!column.queryable) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `Column name "${columnId}" is not queryable`);
+        category: 'logic',
+        returnType: 'any',
+    },
+    CASE: {
+        handler([expressionValueNode, whenThenListNodes, defaultValueNode], context) {
+            const caseExpressionValue = expressionValueNode != undefined
+                ? // CASE matches the first WHEN statement with the provided expression value
+                    (0, expressionFunctionUtils_1.evaluateExpressionNode)(expressionValueNode, context)
+                : // otherwise it returns the first WHEN statement evaluated to TRUE
+                    true;
+            let matchingCase = null;
+            whenThenListNodes.forEach((whenThenStatement) => {
+                const whenValue = (0, expressionFunctionUtils_1.evaluateExpressionNode)(whenThenStatement.WHEN, context);
+                if (whenValue === caseExpressionValue) {
+                    matchingCase = (0, expressionFunctionUtils_1.evaluateExpressionNode)(whenThenStatement.THEN, context);
+                    return;
+                }
+            });
+            if (!matchingCase && defaultValueNode) {
+                // if provided, return the default CASE
+                matchingCase = (0, expressionFunctionUtils_1.evaluateExpressionNode)(defaultValueNode, context);
             }
-            return (_b = context.adaptableApi) === null || _b === void 0 ? void 0 : _b.gridApi.getRawValueFromRowNode(context.node, columnId);
+            return matchingCase;
         },
-        description: 'Returns the value of a column',
-        signatures: ['[colName]', 'COL(name: string)'],
-        examples: ['[col1]', 'COL("col1")'],
+        isHiddenFromMenu: true,
+        hasEagerEvaluation: true,
+        description: `The syntax of CASE supports 2 variants:
+     1. CASE takes an expression and compares its value with each WHEN clause until one of them is equal, whereupon the corresponding THEN clause is executed.
+     2. Each expression in the WHEN clause is evaluated until one of them is true, whereupon the corresponding THEN clause is executed.
+    If no WHEN clause is satisfied, the ELSE clause is executed if one exists, otherwise NULL is returned`,
+        signatures: [
+            `CASE <expression> [WHEN <expression> THEN <expression>] [ELSE <expression>] END`,
+            `CASE [WHEN <expression> THEN <expression>] [ELSE <expression>] END`,
+        ],
+        examples: [
+            `CASE [day] WHEN 'Saturday' THEN 'weekend' WHEN 'Sunday' THEN 'weekend' ELSE 'workday' END`,
+            `CASE WHEN [price] < 10 THEN 'low price' WHEN [price] < 50 THEN 'medium price' ELSE 'high price' END`,
+        ],
+        category: 'logic',
+        returnType: 'any',
     },
     MIN: {
         handler(args) {
@@ -126,6 +195,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the smallest of inputted numbers',
         signatures: ['MIN(number, number, ...number)'],
         examples: ['MIN([col1], 5)'],
+        category: 'math',
+        returnType: 'number',
     },
     MAX: {
         handler(args) {
@@ -134,6 +205,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the highest of inputted numbers',
         signatures: ['MAX(number, number, ...number)'],
         examples: ['MAX([col1], 5)'],
+        category: 'math',
+        returnType: 'number',
     },
     AVG: {
         handler(args) {
@@ -147,6 +220,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the average of inputted numbers',
         signatures: ['AVG(number, number, ...number)'],
         examples: ['AVG([col1], 5)'],
+        category: 'math',
+        returnType: 'number',
     },
     DATE: {
         handler(args) {
@@ -160,6 +235,8 @@ exports.scalarExpressionFunctions = {
             'DATE("YYYY-MM-DD HH:SS")',
         ],
         examples: ['DATE("20210101")', 'DATE("2021-01-01")', 'DATE("2021-01-01 10:10")'],
+        category: 'dates',
+        returnType: 'date',
     },
     NOW: {
         handler() {
@@ -168,6 +245,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the current date',
         signatures: ['NOW()'],
         examples: ['[col1] > NOW()'],
+        category: 'dates',
+        returnType: 'date',
     },
     TODAY: {
         handler() {
@@ -176,6 +255,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the current day',
         signatures: ['TODAY()'],
         examples: ['[col1] > TODAY()'],
+        category: 'dates',
+        returnType: 'date',
     },
     DAY: {
         handler(args) {
@@ -184,6 +265,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the day from a date',
         signatures: ['DAY(input: date)'],
         examples: ['DAY([col1]) = DAY(NOW())'],
+        category: 'dates',
+        returnType: 'date',
     },
     WEEK: {
         handler(args) {
@@ -192,6 +275,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the week from a date',
         signatures: ['WEEK(input: date)'],
         examples: ['WEEK([col1]) = WEEK(NOW())'],
+        category: 'dates',
+        returnType: 'number',
     },
     MONTH: {
         handler(args) {
@@ -200,6 +285,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the month from a date',
         signatures: ['MONTH(input: date)'],
         examples: ['MONTH([col1]) = MONTH(NOW())'],
+        category: 'dates',
+        returnType: 'number',
     },
     YEAR: {
         handler(args) {
@@ -208,6 +295,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the year from a date',
         signatures: ['YEAR(input: date)'],
         examples: ['YEAR([col1]) = YEAR(NOW())'],
+        category: 'dates',
+        returnType: 'date',
     },
     ADD_DAYS: {
         handler(args) {
@@ -216,6 +305,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns a date based on input data and days to add',
         signatures: ['ADD_DAYS(input: date, days: number)'],
         examples: ['ADD_DAYS(TODAY(), 5)', 'ADD_DAYS([col1], 5)'],
+        category: 'dates',
+        returnType: 'date',
     },
     ADD_WEEKS: {
         handler(args) {
@@ -224,6 +315,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns a date based on input data and weeks to add',
         signatures: ['ADD_WEEKS(input: date, weeks: number)'],
         examples: ['ADD_WEEKS(TODAY(), 5)', 'ADD_WEEKS([col1], 5)'],
+        category: 'dates',
+        returnType: 'date',
     },
     ADD_MONTHS: {
         handler(args) {
@@ -232,6 +325,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns a date based on input data and months to add',
         signatures: ['ADD_MONTHS(input: date, months: number)'],
         examples: ['ADD_MONTHS(TODAY(), 5)', 'ADD_MONTHS([col1], 5)'],
+        category: 'dates',
+        returnType: 'date',
     },
     ADD_YEARS: {
         handler(args) {
@@ -240,6 +335,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns a date based on input data and years to add',
         signatures: ['ADD_YEARS(input: date, years: number)'],
         examples: ['ADD_YEARS(TODAY(), 5)', 'ADD_YEARS([col1], 5)'],
+        category: 'dates',
+        returnType: 'date',
     },
     DIFF_DAYS: {
         handler(args) {
@@ -250,6 +347,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the difference in days between 2 dates',
         signatures: ['DIFF_DAYS(a: date, b: date)'],
         examples: ['DIFF_DAYS([col1], TODAY())'],
+        category: 'dates',
+        returnType: 'number',
     },
     DIFF_WEEKS: {
         handler(args) {
@@ -260,6 +359,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the difference in weeks between 2 dates',
         signatures: ['DIFF_WEEKS(a: date, b: date)'],
         examples: ['DIFF_WEEKS([col1], TODAY())'],
+        category: 'dates',
+        returnType: 'number',
     },
     DIFF_MONTHS: {
         handler(args) {
@@ -270,6 +371,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the difference in months between 2 dates',
         signatures: ['DIFF_MONTHS(a: date, b: date)'],
         examples: ['DIFF_MONTHS([col1], TODAY())'],
+        category: 'dates',
+        returnType: 'number',
     },
     DIFF_YEARS: {
         handler(args) {
@@ -280,6 +383,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the difference in years between 2 dates',
         signatures: ['DIFF_YEARS(a: date, b: date)'],
         examples: ['DIFF_YEARS([col1], TODAY())'],
+        category: 'dates',
+        returnType: 'number',
     },
     LEN: {
         handler(args) {
@@ -288,6 +393,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the length of a string',
         signatures: ['LEN(a: string)'],
         examples: ['LEN([col1])'],
+        category: 'strings',
+        returnType: 'number',
     },
     SUB_STRING: {
         handler(args) {
@@ -296,6 +403,8 @@ exports.scalarExpressionFunctions = {
         description: 'Extracts characters from string, between 2 indices, returning new sub string',
         signatures: ['SUB_STRING(a: string, b: number, c:number)'],
         examples: ['SUB_STRING([col1], 1, 5)'],
+        category: 'strings',
+        returnType: 'string',
     },
     UPPER: {
         handler(args) {
@@ -304,6 +413,8 @@ exports.scalarExpressionFunctions = {
         description: 'Converts a string to Upper Case',
         signatures: ['UPPER(a: string)'],
         examples: ['UPPER([col1])'],
+        category: 'strings',
+        returnType: 'string',
     },
     LOWER: {
         handler(args) {
@@ -312,6 +423,8 @@ exports.scalarExpressionFunctions = {
         description: 'Converts a string to Lower Case',
         signatures: ['LOWER(a: string)'],
         examples: ['LOWER([col1])'],
+        category: 'strings',
+        returnType: 'string',
     },
     REPLACE: {
         handler(args, context) {
@@ -325,6 +438,8 @@ exports.scalarExpressionFunctions = {
         description: 'Searches string for specified value returning new string with replaced values',
         signatures: ['REPLACE(a: string, b: string, c:string)'],
         examples: ['REPLACE([col1], "GBP", "EUR")'],
+        category: 'strings',
+        returnType: 'string',
     },
     COALESCE: {
         handler(args) {
@@ -333,6 +448,8 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the first argument which is not null',
         signatures: ['COALESCE(value, value, ...value)'],
         examples: ['COALESCE([col1], [col2], [col3], 0)'],
+        category: 'strings',
+        returnType: 'string',
     },
     CONCAT: {
         handler(args) {
@@ -341,18 +458,8 @@ exports.scalarExpressionFunctions = {
         description: 'Concatenates multiple strings',
         signatures: ['CONCAT(value1, value2, value3)'],
         examples: ['CONCAT([col1], [col2], [col3]'],
-    },
-    VAR: {
-        handler(args, context) {
-            const [functionName, ...optionalArgs] = args;
-            if (StringExtensions_1.default.IsNullOrEmpty(functionName)) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('VAR', 'should have a name');
-            }
-            return context.evaluateCustomQueryVariable(functionName, optionalArgs);
-        },
-        isPredicate: true,
-        description: 'Returns the variable evaluation',
-        signatures: ['VAR(varName)', 'VAR(varName, arg1, arg2)'],
-        examples: ['VAR(CURRENT_USER)', 'VAR(IS_VALID_VALUE, IS_BLANK([col1]), [col2] < [col3])'],
+        category: 'strings',
+        returnType: 'string',
     },
 };
+exports.scalarExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.scalarExpressionFunctions);

package/src/Utilities/Extensions/ObjectExtensions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns a new object with the property updated.
+ * The property is identified by the path.
+ *
+ * @param obj Object
+ * @param path path to the property
+ * @param value new property value
+ * @returns
+ */
+export declare function setInPath<T>(obj: any, path: string[], value: any): T;

package/src/Utilities/Extensions/ObjectExtensions.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setInPath = void 0;
+/**
+ * Returns a new object with the property updated.
+ * The property is identified by the path.
+ *
+ * @param obj Object
+ * @param path path to the property
+ * @param value new property value
+ * @returns
+ */
+function setInPath(obj, path, value) {
+    var _a;
+    if (path.length === 1) {
+        return Object.assign(Object.assign({}, obj), { [path[0]]: value });
+    }
+    return Object.assign(Object.assign({}, obj), { [path[0]]: setInPath((_a = obj === null || obj === void 0 ? void 0 : obj[path[0]]) !== null && _a !== void 0 ? _a : {}, path.slice(1), value) });
+}
+exports.setInPath = setInPath;

package/src/Utilities/Extensions/StringExtensions.d.ts

@@ -16,6 +16,7 @@ export declare function CapitaliseFirstLetter(str: string): string;
 export declare function Humanize(str: string): string;
 export declare function ReplaceEmptySpacesWithUnderscore(str?: string): string;
 export declare function IsNumeric(str: string): boolean;
+export declare function UnescapeHtmlEntities(str: string): string;
 export declare const StringExtensions: {
     IsNull: typeof IsNull;
     IsNotNull: typeof IsNotNull;
@@ -35,5 +36,6 @@ export declare const StringExtensions: {
     Humanize: typeof Humanize;
     ReplaceEmptySpacesWithUnderscore: typeof ReplaceEmptySpacesWithUnderscore;
     IsNumeric: typeof IsNumeric;
+    UnescapeHtmlEntities: typeof UnescapeHtmlEntities;
 };
 export default StringExtensions;

package/src/Utilities/Extensions/StringExtensions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringExtensions = exports.IsNumeric = exports.ReplaceEmptySpacesWithUnderscore = exports.Humanize = exports.CapitaliseFirstLetter = exports.AbbreviateString = exports.NotIncludes = exports.Includes = exports.ToLowerCase = exports.RemoveTrailingComma = exports.CamelCaseToHumanText = exports.IsNotNullOrEmptyOrWhiteSpace = exports.IsNullOrEmptyOrWhiteSpace = exports.IsNotNullOrEmpty = exports.IsNullOrEmpty = exports.IsNotEmpty = exports.IsEmpty = exports.IsNotNull = exports.IsNull = void 0;
+exports.StringExtensions = exports.UnescapeHtmlEntities = exports.IsNumeric = exports.ReplaceEmptySpacesWithUnderscore = exports.Humanize = exports.CapitaliseFirstLetter = exports.AbbreviateString = exports.NotIncludes = exports.Includes = exports.ToLowerCase = exports.RemoveTrailingComma = exports.CamelCaseToHumanText = exports.IsNotNullOrEmptyOrWhiteSpace = exports.IsNullOrEmptyOrWhiteSpace = exports.IsNotNullOrEmpty = exports.IsNullOrEmpty = exports.IsNotEmpty = exports.IsEmpty = exports.IsNotNull = exports.IsNull = void 0;
 const tslib_1 = require("tslib");
 const startCase_1 = tslib_1.__importDefault(require("lodash/startCase"));
 function IsNull(stringToCheck) {
@@ -88,6 +88,25 @@ function IsNumeric(str) {
     return !isNaN(parseFloat(str));
 }
 exports.IsNumeric = IsNumeric;
+function UnescapeHtmlEntities(str) {
+    if (!str || typeof str !== 'string') {
+        return str;
+    }
+    let preparedStr = str;
+    const map = [
+        { target: /'|'/gi, replacement: "'" },
+        { target: /"|"/gi, replacement: '"' },
+        { target: /&|&/gi, replacement: '&' },
+        { target: /&lt;|&#60;/gi, replacement: '<' },
+        { target: /&gt;|&#62;/gi, replacement: '>' },
+        { target: /&nbsp;|&#160;/gi, replacement: ' ' },
+    ];
+    for (const transform of map) {
+        preparedStr = preparedStr.replace(transform.target, transform.replacement);
+    }
+    return preparedStr;
+}
+exports.UnescapeHtmlEntities = UnescapeHtmlEntities;
 exports.StringExtensions = {
     IsNull,
     IsNotNull,
@@ -107,5 +126,6 @@ exports.StringExtensions = {
     Humanize,
     ReplaceEmptySpacesWithUnderscore,
     IsNumeric,
+    UnescapeHtmlEntities,
 };
 exports.default = exports.StringExtensions;

package/src/Utilities/Extensions/TypeExtensions.d.ts

@@ -73,4 +73,6 @@ export declare type _DeepRequiredObject<T> = {
     [P in keyof T]-?: DeepRequired<NonUndefined<T[P]>>;
 };
 export declare type NonUndefined<A> = A extends undefined ? never : A;
+export declare const getTypedKeys: <T extends string>(input: Record<T, any>) => T[];
+export declare type OneOf<T extends any[]> = T extends [infer Only] ? Only : T extends [infer A, infer B, ...infer Rest] ? OneOf<[XOR<A, B>, ...Rest]> : never;
 export {};

package/src/Utilities/Extensions/TypeExtensions.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypedKeys = void 0;
+const getTypedKeys = (input) => {
+    return Object.keys(input);
+};
+exports.getTypedKeys = getTypedKeys;

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -15,6 +15,7 @@ function assignAdaptableOptions(adaptableOptions) {
     returnedAdaptableOptions.adaptableQLOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions, adaptableOptions.adaptableQLOptions);
     returnedAdaptableOptions.columnOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.columnOptions, adaptableOptions.columnOptions);
     returnedAdaptableOptions.adaptableQLOptions.expressionOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions.expressionOptions, returnedAdaptableOptions.adaptableQLOptions.expressionOptions);
+    returnedAdaptableOptions.adaptableQLOptions.predicateOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions.predicateOptions, returnedAdaptableOptions.adaptableQLOptions.predicateOptions);
     returnedAdaptableOptions.layoutOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.layoutOptions, adaptableOptions.layoutOptions);
     returnedAdaptableOptions.notificationsOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.notificationsOptions, adaptableOptions.notificationsOptions);
     returnedAdaptableOptions.alertOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.alertOptions, adaptableOptions.alertOptions);
@@ -23,7 +24,9 @@ function assignAdaptableOptions(adaptableOptions) {
     returnedAdaptableOptions.dashboardOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dashboardOptions, adaptableOptions.dashboardOptions);
     returnedAdaptableOptions.editOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.editOptions, adaptableOptions.editOptions);
     returnedAdaptableOptions.actionOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.actionOptions, adaptableOptions.actionOptions);
-    returnedAdaptableOptions.actionOptions.actionRowFormOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.actionOptions.actionRowFormOptions, returnedAdaptableOptions.actionOptions.actionRowFormOptions);
+    returnedAdaptableOptions.actionOptions.actionRowButtonOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.actionOptions.actionRowButtonOptions, returnedAdaptableOptions.actionOptions.actionRowButtonOptions);
+    returnedAdaptableOptions.actionOptions.actionRowButtonOptions.actionRowFormOptions =
+        Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.actionOptions.actionRowButtonOptions.actionRowFormOptions, returnedAdaptableOptions.actionOptions.actionRowButtonOptions.actionRowFormOptions);
     returnedAdaptableOptions.containerOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.containerOptions, adaptableOptions.containerOptions);
     returnedAdaptableOptions.generalOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.generalOptions, adaptableOptions.generalOptions);
     returnedAdaptableOptions.searchOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.searchOptions, adaptableOptions.searchOptions);
@@ -36,6 +39,7 @@ function assignAdaptableOptions(adaptableOptions) {
     returnedAdaptableOptions.teamSharingOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.teamSharingOptions, adaptableOptions.teamSharingOptions);
     returnedAdaptableOptions.toolPanelOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.toolPanelOptions, adaptableOptions.toolPanelOptions);
     returnedAdaptableOptions.dataChangeHistoryOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dataChangeHistoryOptions, adaptableOptions.dataChangeHistoryOptions);
+    returnedAdaptableOptions.chartingOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.chartingOptions, adaptableOptions.chartingOptions);
     returnedAdaptableOptions.settingsPanelOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.settingsPanelOptions, adaptableOptions.settingsPanelOptions);
     const { predefinedConfig } = returnedAdaptableOptions;
     if (predefinedConfig) {
@@ -62,7 +66,7 @@ function initPredefinedConfigWithUuids(predefinedConfig) {
 }
 exports.initPredefinedConfigWithUuids = initPredefinedConfigWithUuids;
 function checkValidPrimaryKey(adaptable) {
-    const pkColumn = adaptable.api.columnApi.getColumnFromId(adaptable.adaptableOptions.primaryKey);
+    const pkColumn = adaptable.api.columnApi.getColumnWithColumnId(adaptable.adaptableOptions.primaryKey);
     if (pkColumn == undefined && !adaptable.adaptableOptions.autogeneratePrimaryKey) {
         const errorMessage = `The Primary Key Column '${adaptable.adaptableOptions.primaryKey}' does not exist.  This will affect many functions in Adaptable.`;
         if (adaptable.adaptableOptions.generalOptions.showMissingPrimaryKeyAlert == true) {