@adaptabletools/adaptable 14.0.0-canary.3 → 14.0.1-canary.0

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

@@ -2,6 +2,6 @@ import { ExpressionFunction } from '../../parser/src/types';
 /**
  * List of all the Boolean Functions available in AdaptableQL
  */
-export declare type BooleanFunctionName = 'EQ' | 'NEQ' | 'GT' | 'LT' | 'GTE' | 'LTE' | 'AND' | 'OR' | 'NOT' | 'BETWEEN' | 'IN' | 'IS_BLANK' | 'CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'ANY_CONTAINS' | 'QUERY';
+export declare type BooleanFunctionName = 'EQ' | 'NEQ' | 'GT' | 'LT' | 'GTE' | 'LTE' | 'AND' | 'OR' | 'NOT' | 'BETWEEN' | 'IN' | 'CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'ANY_CONTAINS' | 'TRUE' | 'FALSE';
 export declare const booleanExpressionFunctions: Record<BooleanFunctionName, ExpressionFunction>;
 export declare const booleanExpressionFunctionsNames: BooleanFunctionName[];

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.js

@@ -5,53 +5,37 @@ const tslib_1 = require("tslib");
 const isAfter_1 = tslib_1.__importDefault(require("date-fns/isAfter"));
 const isBefore_1 = tslib_1.__importDefault(require("date-fns/isBefore"));
 const isEqual_1 = tslib_1.__importDefault(require("date-fns/isEqual"));
-const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
-const src_1 = require("../../parser/src");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 exports.booleanExpressionFunctions = {
-    QUERY: {
-        handler(args, context) {
-            var _a, _b;
-            const namedQueryName = args[0];
-            if (StringExtensions_1.default.IsNullOrEmpty(namedQueryName)) {
-                return false;
-            }
-            const namedQuery = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.queryApi.getNamedQueryByName(namedQueryName);
-            if (!namedQuery) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('QUERY', `Named Query with name ${namedQueryName} not found!`);
-            }
-            // add query to call stack
-            if (!context.namedQueryCallStack) {
-                context.namedQueryCallStack = [];
-            }
-            context.namedQueryCallStack.push(namedQueryName);
-            //check if this Named Query is not already evaluated, in which case this would lead to an infinite evaluation cycle
-            const firstIndex = context.namedQueryCallStack.indexOf(namedQueryName);
-            const lastIndex = context.namedQueryCallStack.lastIndexOf(namedQueryName);
-            if (firstIndex !== lastIndex) {
-                const cycle = context.namedQueryCallStack.slice(firstIndex, lastIndex + 1);
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError(`${namedQueryName}`, ` contains a circular reference: ${cycle.join('  ->  ')}`);
-            }
-            const queryEvaluationResult = (0, src_1.evaluate)(namedQuery.BooleanExpression, context);
-            // remove query name from callstack
-            (_b = context.namedQueryCallStack) === null || _b === void 0 ? void 0 : _b.pop();
-            return queryEvaluationResult;
+    TRUE: {
+        handler: () => {
+            return true;
         },
-        category: 'advanced',
-        description: 'Returns the evaluation result of the Named Query with the given name',
-        signatures: ['QUERY("anyNamedQuery")'],
-        examples: ['QUERY("anyNamedQuery")'],
+        description: 'Returns the boolean value TRUE',
+        category: 'logical',
         returnType: 'boolean',
+        signatures: ['TRUE'],
+        examples: ['TRUE'],
+    },
+    FALSE: {
+        handler: () => {
+            return false;
+        },
+        description: 'Returns the boolean value FALSE',
+        category: 'logical',
+        returnType: 'boolean',
+        signatures: ['FALSE'],
+        examples: ['FALSE'],
     },
     AND: {
         handler(args) {
             return Boolean(args[0] && args[1]);
         },
         isHiddenFromMenu: true,
-        category: 'logic',
-        description: 'Returns true if both statements is true',
+        category: 'logical',
+        description: 'Returns true if both statements are true',
         signatures: ['statement AND statement'],
         examples: ['[col1] > 5 AND [col2] > 10'],
         returnType: 'boolean',
@@ -61,8 +45,8 @@ exports.booleanExpressionFunctions = {
             return Boolean(args[0] || args[1]);
         },
         isHiddenFromMenu: true,
-        category: 'logic',
-        description: 'Returns true if either statements is true',
+        category: 'logical',
+        description: 'Returns true if either statement is true',
         signatures: ['statement OR statement'],
         examples: ['[col1] > 5 OR [col2] > 10'],
         returnType: 'boolean',
@@ -72,7 +56,7 @@ exports.booleanExpressionFunctions = {
             return Boolean(!args[0]);
         },
         isHiddenFromMenu: true,
-        category: 'logic',
+        category: 'logical',
         description: 'Returns the negation of a statement',
         signatures: ['!statement'],
         examples: ['!([col1] > 5 AND [col2] > 10)'],
@@ -91,7 +75,7 @@ exports.booleanExpressionFunctions = {
         },
         isHiddenFromMenu: true,
         category: 'comparison',
-        description: 'Returns true if the 2 inputs are equal',
+        description: 'Returns true if the 2 (input) values are equal',
         signatures: ['value = value', 'EQ(a: value, b: value)'],
         examples: ['[col1] = 5', 'EQ([col1], 5)'],
         returnType: 'boolean',
@@ -109,7 +93,7 @@ exports.booleanExpressionFunctions = {
         },
         isHiddenFromMenu: true,
         category: 'comparison',
-        description: 'Returns true if the 2 inputs are NOT equal',
+        description: 'Returns true if the 2 (input) values are NOT equal',
         signatures: ['value != value', 'NEQ(a: value, b: value)'],
         examples: ['[col1] != 5', 'NEQ([col1], 5)'],
         returnType: 'boolean',
@@ -223,19 +207,9 @@ exports.booleanExpressionFunctions = {
             return haystack.includes(needle);
         },
         category: 'comparison',
-        description: 'Returns true if any input value is in the inputted column',
+        description: 'Returns true if the left-hand side value is a constituent element of the right-hand side sequence',
         signatures: ['values IN (value, value, ...value)'],
-        examples: ['[col1] IN (5, 10, 17)'],
-        returnType: 'boolean',
-    },
-    IS_BLANK: {
-        handler(args) {
-            return args[0] === undefined || args[0] === null || args[0] === '';
-        },
-        category: 'comparison',
-        description: 'Returns true is input value is empty',
-        signatures: ['IS_BLANK(input: any)'],
-        examples: ['IS_BLANK([col1])'],
+        examples: ['[col1] IN (5, 10, AVG([col2],[col3]))'],
         returnType: 'boolean',
     },
     CONTAINS: {

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -17,11 +17,11 @@ exports.observableExpressionFunctions = {
             return (0, expressionFunctionUtils_1.handleWhereFunction)(args, context);
         },
         isHiddenFromMenu: true,
-        description: 'Splits 2 composed queries, allowing for a main query(lhs) to have a where clause query(rhs) defined',
+        description: 'Limits the rows against which the Observable expression will be evaluated',
         signatures: ['<main_query> WHERE <boolean_query>'],
         examples: ['<main_query> WHERE <boolean_query>', '<main_query> WHERE QUERY("abc")'],
         hasEagerEvaluation: true,
-        category: 'advanced',
+        category: 'conditional',
     },
     ROW_CHANGE: {
         handler(args, context) {
@@ -112,7 +112,7 @@ exports.observableExpressionFunctions = {
         description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
         examples: ['[col1]', "COL('col1')"],
-        category: 'advanced',
+        category: 'special',
     },
     COUNT: {
         handler(args) {
@@ -129,13 +129,13 @@ exports.observableExpressionFunctions = {
             };
             return result;
         },
-        description: 'Observes if a column value has changed a given number of times',
+        description: 'Observes if a column value has changed a given number of times.\nValid only as an operand for an observable function.',
         signatures: [
             'COUNT([colName],changeCount: number)',
             'COUNT(COL(name: string),changeCount: number)',
         ],
         examples: ['COUNT([colName],2)', `COUNT(COL('col1'),10)`],
-        category: 'observable',
+        category: 'operand',
     },
     NONE: {
         handler(args) {
@@ -147,10 +147,10 @@ exports.observableExpressionFunctions = {
             };
             return result;
         },
-        description: 'Observes if a column value has NOT changed',
+        description: 'Observes if a column value has NOT changed.\nValid only as an operand for an observable function.',
         signatures: ['NONE([colName])', 'NONE(COL(name: string))'],
         examples: ['NONE([colA])', `NONE(COL('col1'))`],
-        category: 'observable',
+        category: 'operand',
     },
     MIN: {
         handler(args) {
@@ -162,10 +162,10 @@ exports.observableExpressionFunctions = {
             };
             return result;
         },
-        description: 'Observes if the changed column value is the lowest',
+        description: 'Observes if the changed column value is the lowest.\nValid only as an operand for an observable function.',
         signatures: ['MIN([colName])', 'MIN(COL(name: string))'],
         examples: ['MIN([colA])', `MIN(COL('col1'))`],
-        category: 'observable',
+        category: 'operand',
     },
     MAX: {
         handler(args) {
@@ -177,10 +177,10 @@ exports.observableExpressionFunctions = {
             };
             return result;
         },
-        description: 'Observes if the changed column value is the highest',
+        description: 'Observes if the changed column value is the highest.\nValid only as an operand for an observable function.',
         signatures: ['MAX([colName])', 'MAX(COL(name: string))'],
         examples: ['MAX([colA])', `MAX(COL('col1'))`],
-        category: 'observable',
+        category: 'operand',
     },
     TIMEFRAME: {
         handler(args, context) {
@@ -212,14 +212,14 @@ exports.observableExpressionFunctions = {
             };
             return result;
         },
-        description: 'Limits the monitoring operators to a trailing timeframe defined in seconds, minutes or hours',
+        description: 'Limits the monitoring operators to a trailing timeframe defined in seconds, minutes or hours.\nValid only as an operand for an observable function.',
         signatures: [
             "TIMEFRAME('%numeric_value%s')",
             "TIMEFRAME('%numeric_value%m')",
             "TIMEFRAME('%numeric_value%h')",
         ],
         examples: ["TIMEFRAME('20s')", "TIMEFRAME('5m')", "TIMEFRAME('1h')"],
-        category: 'observable',
+        category: 'operand',
     },
 };
 exports.observableExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.observableExpressionFunctions);

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

@@ -2,6 +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' | 'CASE' | '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' | 'TO_ARRAY' | 'QUERY' | 'IS_BLANK';
 export declare const scalarExpressionFunctions: Record<ScalarFunctionName, ExpressionFunction>;
 export declare const scalarExpressionFunctionNames: ScalarFunctionName[];

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -20,6 +20,7 @@ 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 src_1 = require("../../parser/src");
 const sanitizeArguments = (values, allowNaN) => {
     return values.filter((value) => value != undefined && value != null && value !== '' && (allowNaN || !isNaN(value)));
 };
@@ -30,6 +31,20 @@ const sanitizeNumericResult = (value) => {
     return value;
 };
 exports.scalarExpressionFunctions = {
+    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: 'special',
+        returnType: 'any',
+    },
     COL: {
         handler(args, context) {
             var _a, _b;
@@ -43,26 +58,79 @@ exports.scalarExpressionFunctions = {
             }
             return (_b = context.adaptableApi) === null || _b === void 0 ? void 0 : _b.gridApi.getNormalisedValueFromRowNode(context.node, columnId);
         },
-        description: 'Returns the value of a column',
+        description: 'Returns the value of a Column',
         signatures: ['[colName]', 'COL(name: string)'],
         examples: ['[col1]', 'COL("col1")'],
-        category: 'advanced',
+        category: 'special',
         returnType: 'any',
     },
-    VAR: {
+    QUERY: {
         handler(args, context) {
-            const [functionName, ...optionalArgs] = args;
-            if (StringExtensions_1.default.IsNullOrEmpty(functionName)) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('VAR', 'should have a name');
+            var _a, _b;
+            const namedQueryName = args[0];
+            if (StringExtensions_1.default.IsNullOrEmpty(namedQueryName)) {
+                return false;
             }
-            return context.evaluateCustomQueryVariable(functionName, optionalArgs);
+            const namedQuery = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.queryApi.getNamedQueryByName(namedQueryName);
+            if (!namedQuery) {
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('QUERY', `Named Query with name ${namedQueryName} not found!`);
+            }
+            // add query to call stack
+            if (!context.namedQueryCallStack) {
+                context.namedQueryCallStack = [];
+            }
+            context.namedQueryCallStack.push(namedQueryName);
+            //check if this Named Query is not already evaluated, in which case this would lead to an infinite evaluation cycle
+            const firstIndex = context.namedQueryCallStack.indexOf(namedQueryName);
+            const lastIndex = context.namedQueryCallStack.lastIndexOf(namedQueryName);
+            if (firstIndex !== lastIndex) {
+                const cycle = context.namedQueryCallStack.slice(firstIndex, lastIndex + 1);
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError(`${namedQueryName}`, ` contains a circular reference: ${cycle.join('  ->  ')}`);
+            }
+            const queryEvaluationResult = (0, src_1.evaluate)(namedQuery.BooleanExpression, context);
+            // remove query name from callstack
+            (_b = context.namedQueryCallStack) === null || _b === void 0 ? void 0 : _b.pop();
+            return queryEvaluationResult;
+        },
+        category: 'special',
+        description: 'Returns the evaluation result of the Named Query with the given name',
+        signatures: ['QUERY("anyNamedQuery")'],
+        examples: ['QUERY("anyNamedQuery")'],
+        returnType: 'boolean',
+    },
+    TO_ARRAY: {
+        handler(args) {
+            if (!(args === null || args === void 0 ? void 0 : args.length)) {
+                return [];
+            }
+            return [...args];
         },
-        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',
+        description: 'Creates an array containing all given parameters (which can be scalar values or expressions)',
+        signatures: ['TO_ARRAY(value1, expression1, value2)'],
+        examples: [`TO_ARRAY([col1], AVG([col2],[col3]), QUERY("maxValue"))`],
+        category: 'special',
         returnType: 'any',
     },
+    COALESCE: {
+        handler(args) {
+            return args.find((arg) => !(arg === null || arg === undefined));
+        },
+        description: 'Returns the first argument which is not null',
+        signatures: ['COALESCE(value, value, ...value)'],
+        examples: ['COALESCE([col1], [col2], [col3], 0)'],
+        category: 'special',
+        returnType: 'string',
+    },
+    IS_BLANK: {
+        handler(args) {
+            return args[0] === undefined || args[0] === null || args[0] === '';
+        },
+        category: 'special',
+        description: 'Returns true is input value is undefined, null or an empty string',
+        signatures: ['IS_BLANK(input: any)'],
+        examples: ['IS_BLANK([col1])'],
+        returnType: 'boolean',
+    },
     ADD: {
         handler(args) {
             const sanitizedArguments = sanitizeArguments(args, true);
@@ -76,7 +144,7 @@ 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',
+        category: 'maths',
         returnType: 'number',
     },
     SUB: {
@@ -92,7 +160,7 @@ 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',
+        category: 'maths',
         returnType: 'number',
     },
     MUL: {
@@ -103,7 +171,7 @@ 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',
+        category: 'maths',
         returnType: 'number',
     },
     DIV: {
@@ -114,7 +182,7 @@ 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',
+        category: 'maths',
         returnType: 'number',
     },
     MOD: {
@@ -125,7 +193,7 @@ 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',
+        category: 'maths',
         returnType: 'number',
     },
     POW: {
@@ -136,7 +204,7 @@ 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',
+        category: 'maths',
         returnType: 'number',
     },
     IF: {
@@ -144,10 +212,10 @@ exports.scalarExpressionFunctions = {
             return args[0] ? args[1] : args[2];
         },
         isHiddenFromMenu: true,
-        description: 'Returns one of two statements based on a condition',
-        signatures: ['condition ? true_statement : false_statement'],
+        description: 'Evaluates a condition expression and returns the result of one of the two expressions, depending on whether the condition expression evaluates to true or false',
+        signatures: ['condition_expr ? true_statement : false_statement'],
         examples: ['[col1] > [col2] ? "BIG" : "SMALL"'],
-        category: 'logic',
+        category: 'conditional',
         returnType: 'any',
     },
     CASE: {
@@ -157,19 +225,18 @@ exports.scalarExpressionFunctions = {
                     (0, expressionFunctionUtils_1.evaluateExpressionNode)(expressionValueNode, context)
                 : // otherwise it returns the first WHEN statement evaluated to TRUE
                     true;
-            let matchingCase = null;
-            whenThenListNodes.forEach((whenThenStatement) => {
+            const matchingWhen = whenThenListNodes.find((whenThenStatement) => {
                 const whenValue = (0, expressionFunctionUtils_1.evaluateExpressionNode)(whenThenStatement.WHEN, context);
-                if (whenValue === caseExpressionValue) {
-                    matchingCase = (0, expressionFunctionUtils_1.evaluateExpressionNode)(whenThenStatement.THEN, context);
-                    return;
-                }
+                return whenValue === caseExpressionValue;
             });
-            if (!matchingCase && defaultValueNode) {
-                // if provided, return the default CASE
-                matchingCase = (0, expressionFunctionUtils_1.evaluateExpressionNode)(defaultValueNode, context);
+            if (!matchingWhen) {
+                if (defaultValueNode) {
+                    return (0, expressionFunctionUtils_1.evaluateExpressionNode)(defaultValueNode, context);
+                }
+                return;
             }
-            return matchingCase;
+            const matchingThen = (0, expressionFunctionUtils_1.evaluateExpressionNode)(matchingWhen.THEN, context);
+            return matchingThen;
         },
         isHiddenFromMenu: true,
         hasEagerEvaluation: true,
@@ -185,7 +252,7 @@ exports.scalarExpressionFunctions = {
             `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',
+        category: 'conditional',
         returnType: 'any',
     },
     MIN: {
@@ -195,7 +262,7 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the smallest of inputted numbers',
         signatures: ['MIN(number, number, ...number)'],
         examples: ['MIN([col1], 5)'],
-        category: 'math',
+        category: 'maths',
         returnType: 'number',
     },
     MAX: {
@@ -205,7 +272,7 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the highest of inputted numbers',
         signatures: ['MAX(number, number, ...number)'],
         examples: ['MAX([col1], 5)'],
-        category: 'math',
+        category: 'maths',
         returnType: 'number',
     },
     AVG: {
@@ -220,7 +287,7 @@ exports.scalarExpressionFunctions = {
         description: 'Returns the average of inputted numbers',
         signatures: ['AVG(number, number, ...number)'],
         examples: ['AVG([col1], 5)'],
-        category: 'math',
+        category: 'maths',
         returnType: 'number',
     },
     DATE: {
@@ -441,16 +508,6 @@ exports.scalarExpressionFunctions = {
         category: 'strings',
         returnType: 'string',
     },
-    COALESCE: {
-        handler(args) {
-            return args.find((arg) => !(arg === null || arg === undefined));
-        },
-        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) {
             return args.join(' ');

package/src/Utilities/ObjectFactory.js

@@ -293,8 +293,8 @@ function CreateEmptyFreeTextColumn() {
         DefaultValue: GeneralConstants_1.EMPTY_STRING,
         FreeTextStoredValues: [],
         TextEditor: 'Inline',
-        DataType: 'String',
         FreeTextColumnSettings: {
+            DataType: 'String',
             Filterable: false,
             Resizable: false,
             Groupable: false,

package/src/View/Components/Popups/AdaptablePopupConfirmation.js

@@ -53,7 +53,7 @@ const AdaptablePopupConfirmation = (props) => {
                 React.createElement(rebass_1.Box, { pl: 2 },
                     React.createElement(CheckBox_1.CheckBox, { checked: disableDeleteConfirmation, onChange: () => {
                             setDisableDeleteConfirmation(!disableDeleteConfirmation);
-                        } }, "Do not show this again.")),
+                        } }, "Do not show this again")),
                 props.showInputBox && (React.createElement(rebass_1.Box, { padding: 2, "data-name": "body" },
                     React.createElement("p", null, "Please enter a comment to confirm"),
                     React.createElement(Input_1.default, { marginTop: 2, width: '100%', value: promptText, type: "string", placeholder: "Enter text", onChange: (e) => changeContent(e) }))),

package/src/View/Dashboard/CustomToolbarWrapper.js

@@ -43,9 +43,15 @@ const CustomToolbarWrapper = (props) => {
         if (props.customToolbar.frameworkComponent) {
             adaptableApi.internalApi.createFrameworkComponent(element, props.customToolbar.frameworkComponent, 'toolbar');
         }
+        const destroyUnsubscribe = adaptableApi.eventApi.on('AdaptableDestroy', () => {
+            var _a;
+            (_a = adaptableApi === null || adaptableApi === void 0 ? void 0 : adaptableApi.internalApi) === null || _a === void 0 ? void 0 : _a.destroyFrameworkComponent(element, props.customToolbar.frameworkComponent, 'toolbar');
+        });
         return () => {
+            var _a;
+            destroyUnsubscribe();
             if (props.customToolbar.frameworkComponent) {
-                adaptableApi.internalApi.destroyFrameworkComponent(element, props.customToolbar.frameworkComponent, 'toolbar');
+                (_a = adaptableApi === null || adaptableApi === void 0 ? void 0 : adaptableApi.internalApi) === null || _a === void 0 ? void 0 : _a.destroyFrameworkComponent(element, props.customToolbar.frameworkComponent, 'toolbar');
             }
         };
     }, []);

package/src/View/FreeTextColumn/Wizard/FreeTextColumnSettingsWizardSection.js

@@ -34,7 +34,7 @@ const renderFreeTextColumnSummary = (data) => {
             React.createElement(Tag_1.Tag, null, (_a = data.FriendlyName) !== null && _a !== void 0 ? _a : data.ColumnId))) : null,
         React.createElement(rebass_1.Box, { mt: 3 },
             "Data Type: ",
-            React.createElement(Tag_1.Tag, null, data.DataType)),
+            React.createElement(Tag_1.Tag, null, data.FreeTextColumnSettings.DataType)),
         data.DefaultValue !== undefined ? (React.createElement(rebass_1.Box, { mt: 3 },
             "Default Value: ",
             React.createElement(Tag_1.Tag, null, data.DefaultValue))) : null,
@@ -53,7 +53,7 @@ const isValidFreeTextColumn = (data, api) => {
     if (hasAlreadyExistingId) {
         return 'A Column already exists with that id';
     }
-    if (!data.DataType) {
+    if (!data.FreeTextColumnSettings.DataType) {
         return 'No data type specified for column';
     }
     return true;
@@ -93,14 +93,16 @@ const FreeTextColumnSettingsWizardSection = (props) => {
     const handleDefaultValueChange = (event) => {
         let e = event.target;
         let DefaultValue = e.value;
-        if (data.DataType === 'Date') {
+        if (data.FreeTextColumnSettings.DataType === 'Date') {
             DefaultValue = (0, FormatHelper_1.DateFormatter)(DefaultValue, {
                 Pattern,
             });
         }
         props.onChange(Object.assign(Object.assign({}, data), { DefaultValue }));
     };
-    const handleSpecialColumnSettingsChange = (settings) => {
+    const handleSpecialColumnSettingsChange = (
+    //  settings: SpecialColumnSettings
+    settings) => {
         props.onChange(Object.assign(Object.assign({}, data), { FreeTextColumnSettings: Object.assign(Object.assign({}, data === null || data === void 0 ? void 0 : data.FreeTextColumnSettings), settings) }));
     };
     return (React.createElement(React.Fragment, null,
@@ -119,22 +121,28 @@ const FreeTextColumnSettingsWizardSection = (props) => {
                         whiteSpace: 'normal',
                         overflow: 'hidden',
                         maxWidth: 'inherit',
-                    }, placeholder: "Select Data Type", showClearButton: !!data.DataType, onClear: () => handleDataTypeChange(null), columns: ['label'], items: options.map((item) => ({
+                    }, placeholder: "Select Data Type", showClearButton: !!data.FreeTextColumnSettings.DataType, onClear: () => handleDataTypeChange(null), columns: ['label'], items: options.map((item) => ({
                         value: item.value,
                         label: item.label,
                         onClick: () => handleDataTypeChange(item.value),
-                    })) }, data.DataType ? data.DataType : 'Select Data Type')),
-            React.createElement(FormLayout_1.FormRow, { label: "Default Value" }, data.DataType === 'Boolean' ? (React.createElement(CheckBox_1.CheckBox, { "data-name": "column-default-value-checkbox", checked: !!data.DefaultValue, onChange: (DefaultValue) => {
+                    })) }, data.FreeTextColumnSettings.DataType
+                    ? data.FreeTextColumnSettings.DataType
+                    : 'Select Data Type')),
+            React.createElement(FormLayout_1.FormRow, { label: "Default Value" }, data.FreeTextColumnSettings.DataType === 'Boolean' ? (React.createElement(CheckBox_1.CheckBox, { "data-name": "column-default-value-checkbox", checked: !!data.DefaultValue, onChange: (DefaultValue) => {
                     props.onChange(Object.assign(Object.assign({}, data), { DefaultValue }));
-                } })) : (React.createElement(AdaptableInput_1.default, { "data-name": "column-default-value", value: data.DataType === 'Date' && data.DefaultValue
+                } })) : (React.createElement(AdaptableInput_1.default, { "data-name": "column-default-value", value: data.FreeTextColumnSettings.DataType === 'Date' && data.DefaultValue
                     ? (0, DateHelper_1.parseToISO)(data.DefaultValue, Pattern) || ''
-                    : data.DefaultValue || '', style: { width: '100%', maxWidth: 500 }, type: data.DataType === 'Number' ? 'number' : data.DataType === 'Date' ? 'date' : 'text', placeholder: "Default Column Value (not required)", onChange: (e) => handleDefaultValueChange(e) }))),
+                    : data.DefaultValue || '', style: { width: '100%', maxWidth: 500 }, type: data.FreeTextColumnSettings.DataType === 'Number'
+                    ? 'number'
+                    : data.FreeTextColumnSettings.DataType === 'Date'
+                        ? 'date'
+                        : 'text', placeholder: "Default Column Value (not required)", onChange: (e) => handleDefaultValueChange(e) }))),
             React.createElement(FormLayout_1.FormRow, { label: "Header Tooltip" },
                 React.createElement(Input_1.default, { "data-name": "header-tooltip", type: "text", style: { width: '100%', maxWidth: 500 }, value: ((_a = data.FreeTextColumnSettings) === null || _a === void 0 ? void 0 : _a.HeaderToolTip) || '', onChange: (e) => handleSpecialColumnSettingsChange({
                         HeaderToolTip: e.target.value,
                     }) })),
             ' ',
-            data.DataType == 'String' && (React.createElement(FormLayout_1.FormRow, { label: "Editor Type" },
+            data.FreeTextColumnSettings.DataType == 'String' && (React.createElement(FormLayout_1.FormRow, { label: "Editor Type" },
                 React.createElement(Radio_1.default, { "data-name": "inline-editor", value: "Inline", checked: data.TextEditor == 'Inline', onChange: (_, e) => onDynamicSelectChanged(e), marginRight: 2 }, "Inline Editor"),
                 React.createElement(Radio_1.default, { "data-name": "large-editor", value: "Large", checked: data.TextEditor == 'Large', onChange: (_, e) => onDynamicSelectChanged(e) }, "Large Editor")))),
         ErrorMessage ? (React.createElement(ErrorBox_1.default, { mt: 2, mb: 2 }, ErrorMessage)) : null,

package/src/agGrid/Adaptable.d.ts

@@ -250,7 +250,6 @@ export declare class Adaptable implements IAdaptable {
     private getColDefsForSpecialColumns;
     getColDefsForFreeTextColumns(): ColDef<any>[];
     setupColumnValueGetter({ col }: ColumnSetupInfo): void;
-    setupColumnAggFunc({ col }: ColumnSetupInfo): void;
     private getColDefsForRowEditColumns;
     getColDefsForActionColumns(): ColDef<any>[];
     updateColDefsForSpecialColumns(): void;