@adaptabletools/adaptable 13.1.1 → 14.0.0-canary.1

package/src/Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions.js

@@ -28,6 +28,7 @@ exports.aggregatedBooleanExpressionFunctions = {
         signatures: ['<main_query> WHERE <boolean_query>'],
         examples: ['<main_query> WHERE <boolean_query>', '<main_query> WHERE QUERY("abc")'],
         hasEagerEvaluation: true,
+        category: 'operator',
     },
     SUM: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions['SUM'],
     MIN: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions['MIN'],
@@ -41,6 +42,7 @@ exports.aggregatedBooleanExpressionFunctions = {
         description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
         examples: ['[col1]', "COL('col1')"],
+        category: 'advanced',
     },
     EQ: {
         handler(args, context) {
@@ -55,6 +57,7 @@ exports.aggregatedBooleanExpressionFunctions = {
             `EQ(a: SUM(), b: '%number%(K|M|B)')`,
         ],
         examples: [`SUM([col1]) = '5M'`, 'EQ( SUM([col1]), 250000)'],
+        category: 'comparison',
     },
     NEQ: {
         handler(args, context) {
@@ -69,6 +72,7 @@ exports.aggregatedBooleanExpressionFunctions = {
             `NEQ(a: SUM(), b: '%number%(K|M|B)')`,
         ],
         examples: [`SUM([col1]) != '5M'`, 'NEQ( SUM([col1]), 250000)'],
+        category: 'comparison',
     },
     LT: {
         handler(args, context) {
@@ -83,6 +87,7 @@ exports.aggregatedBooleanExpressionFunctions = {
             `LT(a: SUM(), b: '%number%(K|M|B)')`,
         ],
         examples: [`SUM([col1]) < '5M'`, 'LT( SUM([col1]), 250000)'],
+        category: 'comparison',
     },
     LTE: {
         handler(args, context) {
@@ -97,6 +102,7 @@ exports.aggregatedBooleanExpressionFunctions = {
             `LTE(a: SUM(), b: '%number%(K|M|B)')`,
         ],
         examples: [`SUM([col1]) <= '5M'`, 'LTE( SUM([col1]), 250000)'],
+        category: 'comparison',
     },
     GT: {
         handler(args, context) {
@@ -111,6 +117,7 @@ exports.aggregatedBooleanExpressionFunctions = {
             `GT(a: SUM(), b: '%number%(K|M|B)')`,
         ],
         examples: [`SUM([col1]) > '5M'`, 'GT( SUM([col1]), 250000)'],
+        category: 'comparison',
     },
     GTE: {
         handler(args, context) {
@@ -125,6 +132,7 @@ exports.aggregatedBooleanExpressionFunctions = {
             `GTE(a: SUM(), b: '%number%(K|M|B)')`,
         ],
         examples: [`SUM([col1]) >= '5M'`, 'GTE( SUM([col1]), 250000)'],
+        category: 'comparison',
     },
 };
 const buildBooleanAggregationParameter = (args, context, comparisonOperator, conditionFn) => {

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -55,6 +55,7 @@ exports.aggregatedScalarExpressionFunctions = {
             'CUMUL( MIN([colNameA]), OVER( [colNameB] ))',
             'CUMUL( MAX([colNameA]), OVER( [colNameB] ))',
         ],
+        category: 'cumulative',
     },
     SUM: {
         handler(args, context) {
@@ -98,6 +99,7 @@ exports.aggregatedScalarExpressionFunctions = {
             'SUM( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
         ],
         examples: ['SUM([colA])', 'SUM([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
     },
     PERCENTAGE: {
         handler(args, context) {
@@ -164,6 +166,7 @@ exports.aggregatedScalarExpressionFunctions = {
             'PERCENTAGE( [colNameA], SUM ( [colNameB] ))',
             'PERCENTAGE( [colNameA], SUM ( [colNameB], GROUP_BY( [colNameC] )))',
         ],
+        category: 'aggregation',
     },
     AVG: {
         handler(args, context) {
@@ -237,6 +240,7 @@ exports.aggregatedScalarExpressionFunctions = {
             'AVG( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
         ],
         examples: ['AVG([colA])', 'AVG([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
     },
     MIN: {
         handler(args, context) {
@@ -286,6 +290,7 @@ exports.aggregatedScalarExpressionFunctions = {
             'MIN( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
         ],
         examples: ['MIN([colA])', 'MIN([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
     },
     MAX: {
         handler(args, context) {
@@ -335,6 +340,7 @@ exports.aggregatedScalarExpressionFunctions = {
             'MAX( COL(nameA: string), GROUP_BY( COL(nameB: string)))',
         ],
         examples: ['MIN([colA])', 'MIN([colA], GROUP_BY([colB]))'],
+        category: 'aggregation',
     },
     QUANT: {
         handler(args, context) {
@@ -466,6 +472,7 @@ exports.aggregatedScalarExpressionFunctions = {
             `QUANT( COL('col1'), 100))`,
             'QUANT( [col1], 4, GROUP_BY([col2]) )',
         ],
+        category: 'aggregation',
     },
     OVER: {
         handler(args, context) {
@@ -481,6 +488,7 @@ exports.aggregatedScalarExpressionFunctions = {
         description: 'Defines an accumulative dimension (order) for the enclosing cumulative aggregation',
         signatures: ['OVER( [colName] )', 'OVER( COL(name: string))'],
         examples: ['OVER( [colName] )', `OVER( COL('colName'))`],
+        category: 'cumulative',
     },
     WEIGHT: {
         handler(args, context) {
@@ -496,6 +504,7 @@ exports.aggregatedScalarExpressionFunctions = {
         description: 'Defines a weight for the enclosing AVG(Average) aggregation',
         signatures: ['WEIGHT( [colName] )', 'WEIGHT( COL(name: string))'],
         examples: ['WEIGHT( [colName] )', `WEIGHT( COL('colName'))`],
+        category: 'aggregation',
     },
     GROUP_BY: {
         handler(args, context) {
@@ -510,6 +519,7 @@ exports.aggregatedScalarExpressionFunctions = {
         description: 'Groups an aggregation operation within the rows that have the same value in the specified column',
         signatures: ['GROUP_BY( [colName] )', 'GROUP_BY( COL(name: string))'],
         examples: ['GROUP_BY( [colName] )', `GROUP_BY( COL('colName'))`],
+        category: 'advanced',
     },
     COL: {
         handler(args, context) {
@@ -518,6 +528,7 @@ exports.aggregatedScalarExpressionFunctions = {
         description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
         examples: ['[col1]', 'COL("col1")'],
+        category: 'advanced',
     },
 };
 const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, context) => {

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.js

@@ -11,35 +11,72 @@ const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluati
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 exports.booleanExpressionFunctions = {
-    OR: {
-        handler(args) {
-            return Boolean(args[0] || args[1]);
+    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;
         },
-        isHiddenFromMenu: true,
-        isPredicate: true,
-        description: 'Returns true if either statements is true',
-        signatures: ['statement OR statement'],
-        examples: ['[col1] > 5 OR [col2] > 10'],
+        category: 'advanced',
+        description: 'Returns the evaluation result of the Named Query with the given name',
+        signatures: ['QUERY("anyNamedQuery")'],
+        examples: ['QUERY("anyNamedQuery")'],
+        returnType: 'boolean',
     },
     AND: {
         handler(args) {
             return Boolean(args[0] && args[1]);
         },
         isHiddenFromMenu: true,
-        isPredicate: true,
+        category: 'logic',
         description: 'Returns true if both statements is true',
         signatures: ['statement AND statement'],
         examples: ['[col1] > 5 AND [col2] > 10'],
+        returnType: 'boolean',
+    },
+    OR: {
+        handler(args) {
+            return Boolean(args[0] || args[1]);
+        },
+        isHiddenFromMenu: true,
+        category: 'logic',
+        description: 'Returns true if either statements is true',
+        signatures: ['statement OR statement'],
+        examples: ['[col1] > 5 OR [col2] > 10'],
+        returnType: 'boolean',
     },
     NOT: {
         handler(args) {
             return Boolean(!args[0]);
         },
         isHiddenFromMenu: true,
-        isPredicate: true,
+        category: 'logic',
         description: 'Returns the negation of a statement',
         signatures: ['!statement'],
         examples: ['!([col1] > 5 AND [col2] > 10)'],
+        returnType: 'boolean',
     },
     EQ: {
         handler(args, context) {
@@ -53,10 +90,11 @@ exports.booleanExpressionFunctions = {
             return args[0] == args[1];
         },
         isHiddenFromMenu: true,
-        isPredicate: true,
+        category: 'comparison',
         description: 'Returns true if the 2 inputs are equal',
         signatures: ['value = value', 'EQ(a: value, b: value)'],
         examples: ['[col1] = 5', 'EQ([col1], 5)'],
+        returnType: 'boolean',
     },
     NEQ: {
         handler(args, context) {
@@ -70,10 +108,11 @@ exports.booleanExpressionFunctions = {
             return args[0] != args[1];
         },
         isHiddenFromMenu: true,
-        isPredicate: true,
+        category: 'comparison',
         description: 'Returns true if the 2 inputs are NOT equal',
         signatures: ['value != value', 'NEQ(a: value, b: value)'],
         examples: ['[col1] != 5', 'NEQ([col1], 5)'],
+        returnType: 'boolean',
     },
     LT: {
         handler(args, context) {
@@ -87,7 +126,7 @@ exports.booleanExpressionFunctions = {
             return args[0] < args[1];
         },
         isHiddenFromMenu: true,
-        isPredicate: true,
+        category: 'comparison',
         description: 'Returns true if the 1st input is less than 2nd input',
         signatures: [
             'number < number',
@@ -96,6 +135,7 @@ exports.booleanExpressionFunctions = {
             'LT(a: date, b: date)',
         ],
         examples: ['[col1] < 5', 'LT([col1], 5)'],
+        returnType: 'boolean',
     },
     LTE: {
         handler(args, context) {
@@ -109,7 +149,7 @@ exports.booleanExpressionFunctions = {
             return args[0] <= args[1];
         },
         isHiddenFromMenu: true,
-        isPredicate: true,
+        category: 'comparison',
         description: 'Returns true if 1st input is less than or equals 2nd input',
         signatures: [
             'number <= number',
@@ -118,6 +158,7 @@ exports.booleanExpressionFunctions = {
             'LTE(a: date, b: date)',
         ],
         examples: ['[col1] <= 5', 'LTE([col1], 5)'],
+        returnType: 'boolean',
     },
     GT: {
         handler(args, context) {
@@ -131,7 +172,7 @@ exports.booleanExpressionFunctions = {
             return args[0] > args[1];
         },
         isHiddenFromMenu: true,
-        isPredicate: true,
+        category: 'comparison',
         description: 'Returns true if the 1st input is greater than 2nd input',
         signatures: [
             'number > number',
@@ -140,6 +181,7 @@ exports.booleanExpressionFunctions = {
             'GT(a: date, b: date)',
         ],
         examples: ['[col1] > 5', 'GT([col1], 5)'],
+        returnType: 'boolean',
     },
     GTE: {
         handler(args, context) {
@@ -153,7 +195,7 @@ exports.booleanExpressionFunctions = {
             return args[0] >= args[1];
         },
         isHiddenFromMenu: true,
-        isPredicate: true,
+        category: 'comparison',
         description: 'Returns true if 1st input is greater than or equals 2nd input',
         signatures: [
             'number >= number',
@@ -162,6 +204,7 @@ exports.booleanExpressionFunctions = {
             'GTE(a: date, b: date)',
         ],
         examples: ['[col1] >= 5', 'GTE([col1], 5)'],
+        returnType: 'boolean',
     },
     BETWEEN: {
         handler([input, lower, upper]) {
@@ -169,58 +212,64 @@ exports.booleanExpressionFunctions = {
                 throw new ExpressionEvaluationError_1.ExpressionEvaluationError('BETWEEN', 'arg 1 should be a number');
             return input >= lower && input <= upper;
         },
-        isPredicate: true,
+        category: 'comparison',
         description: 'Returns true if 1st input is between 2nd and 3rd inputs',
         signatures: ['BETWEEN(input: number, lower: number, upper: number)'],
         examples: ['BETWEEN(5, [col1], [col2])'],
+        returnType: 'boolean',
     },
     IN: {
         handler([needle, haystack]) {
             return haystack.includes(needle);
         },
-        isPredicate: true,
+        category: 'comparison',
         description: 'Returns true if any input value is in the inputted column',
         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] === '';
         },
-        isPredicate: true,
+        category: 'comparison',
         description: 'Returns true is input value is empty',
         signatures: ['IS_BLANK(input: any)'],
         examples: ['IS_BLANK([col1])'],
+        returnType: 'boolean',
     },
     CONTAINS: {
         handler(args, context) {
             const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
             return first.indexOf(second) !== -1;
         },
-        isPredicate: true,
+        category: 'strings',
         description: 'Returns true if 1st input contains 2nd input',
         signatures: ['CONTAINS(a: string, b: string)'],
         examples: ['CONTAINS([col1], "S")'],
+        returnType: 'boolean',
     },
     STARTS_WITH: {
         handler(args, context) {
             const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
             return first.startsWith(second);
         },
-        isPredicate: true,
+        category: 'strings',
         description: 'Returns true if 1st input starts with the 2nd input',
         signatures: ['STARTS_WITH(a: string, b: string)'],
         examples: ['STARTS_WITH([col1], "S")'],
+        returnType: 'boolean',
     },
     ENDS_WITH: {
         handler(args, context) {
             const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
             return first.endsWith(second);
         },
-        isPredicate: true,
+        category: 'strings',
         description: 'Returns true if 1st input ends with the 2nd input',
         signatures: ['ENDS_WITH(a: string, b: string)'],
         examples: ['ENDS_WITH([col1], "S")'],
+        returnType: 'boolean',
     },
     ANY_CONTAINS: {
         handler(args, context) {
@@ -233,65 +282,11 @@ exports.booleanExpressionFunctions = {
                 return columnValue.indexOf(searchTerm) !== -1;
             });
         },
-        isPredicate: true,
+        category: 'strings',
         description: 'Returns true if any Column contains input',
         signatures: ['ANY_CONTAINS(value)'],
         examples: ['ANY_CONTAINS("abc")'],
-    },
-    /*
-    ANY_SEARCHABLE_CONTAINS: {
-      handler(args, context) {
-        const searchTerm = getStringValue(context, String(args[0]));
-        return context.api?.columnApi
-          .getVisibleColumns()
-          .filter((c) => !c.isExcludedFromQuickSearch)
-          .some((column) => {
-            const value = context.api?.gridApi.getDisplayValueFromRowNode(
-              context.node,
-              column.columnId
-            );
-            const columnValue = getStringValue(context, String(value));
-            return columnValue.indexOf(searchTerm) !== -1;
-          });
-      },
-      isPredicate: true,
-      description: 'Returns true if any Searchable Column contains input',
-      signatures: ['ANY_SEARCHABLE_CONTAINS(value)'],
-      examples: ['ANY_SEARCHABLE_CONTAINS("abc")'],
-    },
-  */
-    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;
-        },
-        isPredicate: true,
-        description: 'Returns the evaluation result of the Named Query with the given name',
-        signatures: ['QUERY("anyNamedQuery")'],
-        examples: ['QUERY("anyNamedQuery")'],
+        returnType: 'boolean',
     },
 };
 exports.booleanExpressionFunctionsNames = (0, TypeExtensions_1.getTypedKeys)(exports.booleanExpressionFunctions);

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

@@ -13,7 +13,9 @@ export declare const getStringValues: (context: ExpressionContext, ...stringArgu
 export declare const getStringValue: (context: ExpressionContext, stringArgument: string) => string;
 export declare const isTextSearchCaseInsensitive: (context: ExpressionContext) => boolean;
 export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<CellDataChangedInfo>;
-export declare const handleWhereFunction: (args: any[], context: ExpressionContext) => any;
+export declare const handleWhereFunction: (args: ExpressionNode[], context: ExpressionContext) => any;
+export declare type ExpressionNode = any;
+export declare const evaluateExpressionNode: (expressionNode: ExpressionNode, context: ExpressionContext, filterFn?: (item: any) => boolean) => any;
 export declare const extractColumnParameter: (consumingFunctionName: string, args: BaseParameter[]) => ColumnParameter;
 export declare const extractColumnParameters: (consumingFunctionName: string, args: BaseParameter[]) => ColumnParameter[];
 export declare const extractParameter: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T["type"], allowedOperands: T["name"][], args: BaseParameter[], config?: {

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateColumnType = exports.getNumericValue = exports.handleColumnFunction = exports.extractParameters = exports.extractParameter = exports.extractColumnParameters = exports.extractColumnParameter = exports.handleWhereFunction = exports.getDataChangeLog$ = exports.isTextSearchCaseInsensitive = exports.getStringValue = exports.getStringValues = void 0;
+exports.validateColumnType = exports.getNumericValue = exports.handleColumnFunction = exports.extractParameters = exports.extractParameter = exports.extractColumnParameters = exports.extractColumnParameter = exports.evaluateExpressionNode = exports.handleWhereFunction = exports.getDataChangeLog$ = exports.isTextSearchCaseInsensitive = exports.getStringValue = exports.getStringValues = void 0;
 const tslib_1 = require("tslib");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
@@ -47,7 +47,11 @@ const handleWhereFunction = (args, context) => {
         });
     };
     // observableExpressionResult
-    return (0, evaluator_1.evaluateNode)(reactiveExpressionNode, {
+    return (0, exports.evaluateExpressionNode)(reactiveExpressionNode, context, filterFn);
+};
+exports.handleWhereFunction = handleWhereFunction;
+const evaluateExpressionNode = (expressionNode, context, filterFn = context.filterFn) => {
+    return (0, evaluator_1.evaluateNode)(expressionNode, {
         node: context.node,
         adaptableApi: context.adaptableApi,
         functions: context.functions,
@@ -55,7 +59,7 @@ const handleWhereFunction = (args, context) => {
         evaluateCustomQueryVariable: context.adaptableApi.internalApi.getQueryLanguageService().evaluateCustomQueryVariable,
     });
 };
-exports.handleWhereFunction = handleWhereFunction;
+exports.evaluateExpressionNode = evaluateExpressionNode;
 const extractColumnParameter = (consumingFunctionName, args) => {
     return (0, exports.extractParameter)(consumingFunctionName, 'config', ['COL'], args);
 };
@@ -109,14 +113,14 @@ const getNumericValue = (input) => {
 };
 exports.getNumericValue = getNumericValue;
 const validateColumnType = (columnId, validColumnTypes, consumingFunction, api) => {
-    const columnType = api.columnApi.getColumnDataTypeFromColumnId(columnId);
+    const columnType = api.columnApi.getColumnDataTypeForColumnId(columnId);
     if (!validColumnTypes.some((validType) => validType === columnType)) {
         throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunction, `expects a column of type ${validColumnTypes.join(' or ')}`);
     }
 };
 exports.validateColumnType = validateColumnType;
 const validateColumnId = (columnId, api) => {
-    const column = api.columnApi.getColumnFromId(columnId);
+    const column = api.columnApi.getColumnWithColumnId(columnId);
     if (!column) {
         throw new ExpressionEvaluationError_1.ExpressionEvaluationError('', `Column name "${columnId}" is not found`);
     }

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -21,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) {
@@ -53,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) {
@@ -94,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) {
@@ -109,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) {
@@ -131,6 +135,7 @@ exports.observableExpressionFunctions = {
             'COUNT(COL(name: string),changeCount: number)',
         ],
         examples: ['COUNT([colName],2)', `COUNT(COL('col1'),10)`],
+        category: 'observable',
     },
     NONE: {
         handler(args) {
@@ -145,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) {
@@ -159,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) {
@@ -173,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) {
@@ -211,6 +219,7 @@ exports.observableExpressionFunctions = {
             "TIMEFRAME('%numeric_value%h')",
         ],
         examples: ["TIMEFRAME('20s')", "TIMEFRAME('5m')", "TIMEFRAME('1h')"],
+        category: 'observable',
     },
 };
 exports.observableExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.observableExpressionFunctions);
@@ -248,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,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' | '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[];