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

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.aggregatedScalarExpressionFunctions = exports.aggregatedExpressionFunctions = exports.cumulativeAggregatedExpressionFunctions = void 0;
+exports.aggregatedScalarExpressionFunctionNames = exports.aggregatedScalarExpressionFunctions = exports.aggregatedExpressionFunctions = exports.cumulativeAggregatedExpressionFunctions = void 0;
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 exports.cumulativeAggregatedExpressionFunctions = [
     'CUMUL',
     'OVER',
@@ -31,6 +32,14 @@ exports.aggregatedScalarExpressionFunctions = {
         handler(args, context) {
             const aggregationParameter = (0, expressionFunctionUtils_1.extractParameter)('CUMUL', 'aggregationScalar', ['SUM', 'PERCENTAGE', 'AVG', 'MIN', 'MAX'], args);
             const overColumnParameter = (0, expressionFunctionUtils_1.extractParameter)('CUMUL', 'operand', ['OVER'], args);
+            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('MAX', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            if (!!groupByParameter) {
+                // ensure the GROUP_BY is NOT on the CUMUL function
+                // it should be on the AGGREGATION function
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('GROUP_BY', `should be passed as an argument to the '${aggregationParameter.name}' aggregation function!`);
+            }
             const cumulationExpressionEvaluation = mapAggregationToCumulation(aggregationParameter, overColumnParameter, context);
             const result = {
                 name: 'CUMUL',
@@ -46,6 +55,7 @@ exports.aggregatedScalarExpressionFunctions = {
             'CUMUL( MIN([colNameA]), OVER( [colNameB] ))',
             'CUMUL( MAX([colNameA]), OVER( [colNameB] ))',
         ],
+        category: 'cumulative',
     },
     SUM: {
         handler(args, context) {
@@ -72,7 +82,6 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
-                columnDependencies: [sumColumnName],
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -90,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) {
@@ -134,7 +144,6 @@ exports.aggregatedScalarExpressionFunctions = {
                         100);
                 },
                 rowFilterFn: context.filterFn,
-                columnDependencies: [...new Set([percentageColumnName, sumAggregationColumnName])],
             };
             addGroupByParams(groupByColumnNames, aggregationExpressionEvaluation);
             const result = {
@@ -157,6 +166,7 @@ exports.aggregatedScalarExpressionFunctions = {
             'PERCENTAGE( [colNameA], SUM ( [colNameB] ))',
             'PERCENTAGE( [colNameA], SUM ( [colNameB], GROUP_BY( [colNameC] )))',
         ],
+        category: 'aggregation',
     },
     AVG: {
         handler(args, context) {
@@ -208,7 +218,6 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
-                columnDependencies: [avgColumnName],
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             if (weightParameter) {
@@ -231,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) {
@@ -263,7 +273,6 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
-                columnDependencies: [minColumnName],
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -281,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) {
@@ -313,7 +323,6 @@ exports.aggregatedScalarExpressionFunctions = {
                     },
                 },
                 rowFilterFn: context.filterFn,
-                columnDependencies: [maxColumnName],
             };
             addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
@@ -331,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) {
@@ -442,7 +452,6 @@ exports.aggregatedScalarExpressionFunctions = {
                     }
                     return rowBucketMap[rowValue];
                 },
-                columnDependencies: [quantileColumnName],
             };
             addGroupByParams(groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value, aggregationExpressionEvaluation);
             const result = {
@@ -463,6 +472,7 @@ exports.aggregatedScalarExpressionFunctions = {
             `QUANT( COL('col1'), 100))`,
             'QUANT( [col1], 4, GROUP_BY([col2]) )',
         ],
+        category: 'aggregation',
     },
     OVER: {
         handler(args, context) {
@@ -478,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) {
@@ -493,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) {
@@ -507,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) {
@@ -515,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) => {
@@ -642,20 +656,17 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
             groupBy: aggregationEvaluation.aggregationParams.groupBy,
         },
         rowValueGetter,
-        columnDependencies: [
-            ...new Set([...aggregationEvaluation.columnDependencies, overColumnParameter.value]),
-        ],
         rowFilterFn: aggregationEvaluation.rowFilterFn,
     };
     return cumulationExpressionEvaluation;
 };
+exports.aggregatedScalarExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.aggregatedScalarExpressionFunctions);
 // !! mutates expressionEvaluation
 const addGroupByParams = (groupByColumnNames, expressionEvaluation) => {
     if (groupByColumnNames === null || groupByColumnNames === void 0 ? void 0 : groupByColumnNames.length) {
         expressionEvaluation.aggregationParams.groupBy = groupByColumnNames.map((columnName) => ({
             field: columnName,
         }));
-        expressionEvaluation.columnDependencies.push(...groupByColumnNames);
     }
 };
 const isUndefinedValue = (input) => {

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

@@ -4,3 +4,4 @@ import { ExpressionFunction } from '../../parser/src/types';
  */
 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 const booleanExpressionFunctions: Record<BooleanFunctionName, ExpressionFunction>;
+export declare const booleanExpressionFunctionsNames: BooleanFunctionName[];

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.booleanExpressionFunctions = void 0;
+exports.booleanExpressionFunctionsNames = exports.booleanExpressionFunctions = void 0;
 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"));
@@ -9,36 +9,74 @@ const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/String
 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 = {
-    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) {
@@ -52,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) {
@@ -69,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) {
@@ -86,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',
@@ -95,6 +135,7 @@ exports.booleanExpressionFunctions = {
             'LT(a: date, b: date)',
         ],
         examples: ['[col1] < 5', 'LT([col1], 5)'],
+        returnType: 'boolean',
     },
     LTE: {
         handler(args, context) {
@@ -108,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',
@@ -117,6 +158,7 @@ exports.booleanExpressionFunctions = {
             'LTE(a: date, b: date)',
         ],
         examples: ['[col1] <= 5', 'LTE([col1], 5)'],
+        returnType: 'boolean',
     },
     GT: {
         handler(args, context) {
@@ -130,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',
@@ -139,6 +181,7 @@ exports.booleanExpressionFunctions = {
             'GT(a: date, b: date)',
         ],
         examples: ['[col1] > 5', 'GT([col1], 5)'],
+        returnType: 'boolean',
     },
     GTE: {
         handler(args, context) {
@@ -152,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',
@@ -161,6 +204,7 @@ exports.booleanExpressionFunctions = {
             'GTE(a: date, b: date)',
         ],
         examples: ['[col1] >= 5', 'GTE([col1], 5)'],
+        returnType: 'boolean',
     },
     BETWEEN: {
         handler([input, lower, upper]) {
@@ -168,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) {
@@ -232,64 +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.d.ts

@@ -2,8 +2,6 @@ import { ExpressionFunction } from '../../parser/src/types';
 /**
  * List of all the Observable Functions available in AdaptableQL
  */
-export declare type ObservableFunctionName = 'WHERE' | 'COL' | 'TIMEFRAME' | ObservableFunction | ChangeFunction;
-declare type ObservableFunction = 'ROW_CHANGE' | 'GRID_CHANGE';
-declare type ChangeFunction = 'MAX' | 'MIN' | 'NONE' | 'COUNT';
+export declare type ObservableFunctionName = 'WHERE' | 'COL' | 'TIMEFRAME' | 'ROW_CHANGE' | 'GRID_CHANGE' | 'MAX' | 'MIN' | 'NONE' | 'COUNT';
 export declare const observableExpressionFunctions: Record<ObservableFunctionName, ExpressionFunction>;
-export {};
+export declare const observableExpressionFunctionNames: ObservableFunctionName[];