@adaptabletools/adaptable 16.2.3 → 17.0.0-canary.0

package/src/Utilities/Emitter.js

@@ -1,6 +1,4 @@
-"use strict";
 /** based on emittery npm package, which is MIT */
-Object.defineProperty(exports, "__esModule", { value: true });
 const anyMap = new WeakMap();
 const eventsMap = new WeakMap();
 const triggeredMap = new WeakMap();
@@ -243,4 +241,4 @@ class Emittery {
     }
 }
 const allEmitteryMethods = Object.getOwnPropertyNames(Emittery.prototype).filter((v) => v !== 'constructor');
-exports.default = Emittery;
+export default Emittery;

package/src/Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.aggregatedBooleanExpressionFunctionNames = exports.aggregatedBooleanExpressionFunctions = void 0;
-const tslib_1 = require("tslib");
-const parseInt_1 = tslib_1.__importDefault(require("lodash/parseInt"));
-const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
-const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
-const aggregatedScalarExpressionFunctions_1 = require("./aggregatedScalarExpressionFunctions");
-const TypeExtensions_1 = require("../Extensions/TypeExtensions");
+import parseInt from 'lodash/parseInt';
+import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
+import { handleColumnFunction, handleWhereFunction, } from './expressionFunctionUtils';
+import { aggregatedScalarExpressionFunctions, } from './aggregatedScalarExpressionFunctions';
+import { getTypedKeys } from '../Extensions/TypeExtensions';
 const SUPPORTED_AGGREGATION_FNS = ['SUM', 'MIN', 'MAX', 'AVG', 'COUNT'];
 const aggregationScalarOperandMap = {
     SUM: ['string', 'number'],
@@ -19,10 +15,10 @@ const aggregationScalarOperandMap = {
 // 1. block containing a numeric value (any digits) (required)
 // 2. block containing a single 'K', 'M' or 'B' letter (optional) (case insensitive)
 const CRITERIA_REGEX = /^(?:\s*)(\d+)(K|M|B)?$/i;
-exports.aggregatedBooleanExpressionFunctions = {
+export const aggregatedBooleanExpressionFunctions = {
     WHERE: {
         handler(args, context) {
-            return (0, expressionFunctionUtils_1.handleWhereFunction)(args, context);
+            return handleWhereFunction(args, context);
         },
         isHiddenFromMenu: true,
         description: 'Splits 2 composed queries, allowing for a main query(lhs) to have a where clause query(rhs) defined',
@@ -31,13 +27,13 @@ exports.aggregatedBooleanExpressionFunctions = {
         hasEagerEvaluation: true,
         category: 'conditional',
     },
-    SUM: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions['SUM'],
-    MIN: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions['MIN'],
-    MAX: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions['MAX'],
-    AVG: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions['AVG'],
-    WEIGHT: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions['WEIGHT'],
-    COUNT: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions['COUNT'],
-    GROUP_BY: aggregatedScalarExpressionFunctions_1.aggregatedScalarExpressionFunctions['GROUP_BY'],
+    SUM: aggregatedScalarExpressionFunctions['SUM'],
+    MIN: aggregatedScalarExpressionFunctions['MIN'],
+    MAX: aggregatedScalarExpressionFunctions['MAX'],
+    AVG: aggregatedScalarExpressionFunctions['AVG'],
+    WEIGHT: aggregatedScalarExpressionFunctions['WEIGHT'],
+    COUNT: aggregatedScalarExpressionFunctions['COUNT'],
+    GROUP_BY: aggregatedScalarExpressionFunctions['GROUP_BY'],
     EQ: {
         handler(args, context) {
             return buildBooleanAggregationParameter(args, context, '=', (aggregatedValue, conditionValue) => aggregatedValue === conditionValue);
@@ -130,7 +126,7 @@ exports.aggregatedBooleanExpressionFunctions = {
     },
     COL: {
         handler(args, context) {
-            return (0, expressionFunctionUtils_1.handleColumnFunction)(args, context);
+            return handleColumnFunction(args, context);
         },
         description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
@@ -156,14 +152,14 @@ const extractScalarAggregationOperand = (consumingFunctionName, argument) => {
     if (result == undefined ||
         result.type !== 'aggregationScalar' ||
         !SUPPORTED_AGGREGATION_FNS.includes(result.name)) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `comparison operator expects as a left-hand operand an aggregation function of type '${SUPPORTED_AGGREGATION_FNS.join(' | ')}'`);
+        throw new ExpressionEvaluationError(consumingFunctionName, `comparison operator expects as a left-hand operand an aggregation function of type '${SUPPORTED_AGGREGATION_FNS.join(' | ')}'`);
     }
     return result;
 };
 const extractScalarOperand = (consumingFunctionName, value, allowedTypes) => {
     var _a;
     if (value == undefined || !allowedTypes.find((allowedType) => typeof value === allowedType)) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `comparison operator expects as a right-hand operand a scalar value of type '${allowedTypes.join(' | ')}'`);
+        throw new ExpressionEvaluationError(consumingFunctionName, `comparison operator expects as a right-hand operand a scalar value of type '${allowedTypes.join(' | ')}'`);
     }
     if (typeof value === 'number') {
         return value;
@@ -174,7 +170,7 @@ const extractScalarOperand = (consumingFunctionName, value, allowedTypes) => {
     const numericString = matchingResult === null || matchingResult === void 0 ? void 0 : matchingResult[1];
     const largeNumberUnit = (_a = matchingResult === null || matchingResult === void 0 ? void 0 : matchingResult[2]) !== null && _a !== void 0 ? _a : 'number';
     if (!numericString) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError('Numeric abbreviation', `"${stringValue}" is invalid, expecting a number with a suffix for thousands(K), millions(M) or billions(B)"`);
+        throw new ExpressionEvaluationError('Numeric abbreviation', `"${stringValue}" is invalid, expecting a number with a suffix for thousands(K), millions(M) or billions(B)"`);
     }
     // unit -> number
     const numberUnitRatios = {
@@ -184,6 +180,6 @@ const extractScalarOperand = (consumingFunctionName, value, allowedTypes) => {
         b: 1000000000,
     };
     // numeric value
-    return (0, parseInt_1.default)(numericString) * numberUnitRatios[largeNumberUnit.toLowerCase()];
+    return parseInt(numericString) * numberUnitRatios[largeNumberUnit.toLowerCase()];
 };
-exports.aggregatedBooleanExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.aggregatedBooleanExpressionFunctions);
+export const aggregatedBooleanExpressionFunctionNames = getTypedKeys(aggregatedBooleanExpressionFunctions);

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.aggregatedScalarExpressionFunctionNames = exports.aggregatedScalarExpressionFunctions = exports.quantileAggregatedExpressionFunctions = exports.cumulativeAggregatedExpressionFunctions = exports.aggregatedExpressionFunctions = void 0;
-const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
-const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
-const TypeExtensions_1 = require("../Extensions/TypeExtensions");
-exports.aggregatedExpressionFunctions = [
+import { extractColumnParameter, extractColumnParameters, extractParameter, getNumericValue, handleColumnFunction, validateColumnType, } from './expressionFunctionUtils';
+import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
+import { getTypedKeys } from '../Extensions/TypeExtensions';
+export const aggregatedExpressionFunctions = [
     'SUM',
     'PERCENTAGE',
     'MIN',
@@ -15,7 +12,7 @@ exports.aggregatedExpressionFunctions = [
     'COL',
     'GROUP_BY',
 ];
-exports.cumulativeAggregatedExpressionFunctions = [
+export const cumulativeAggregatedExpressionFunctions = [
     'CUMUL',
     'OVER',
     'SUM',
@@ -27,25 +24,25 @@ exports.cumulativeAggregatedExpressionFunctions = [
     'COL',
     'GROUP_BY',
 ];
-exports.quantileAggregatedExpressionFunctions = [
+export const quantileAggregatedExpressionFunctions = [
     'QUANT',
     'QUARTILE',
     'PERCENTILE',
     'COL',
     'GROUP_BY',
 ];
-exports.aggregatedScalarExpressionFunctions = {
+export const aggregatedScalarExpressionFunctions = {
     CUMUL: {
         handler(args, context) {
-            const aggregationParameter = (0, expressionFunctionUtils_1.extractParameter)('CUMUL', 'aggregationScalar', ['SUM', 'PERCENTAGE', 'AVG', 'MIN', 'MAX', 'COUNT'], args);
-            const overColumnParameter = (0, expressionFunctionUtils_1.extractParameter)('CUMUL', 'operand', ['OVER'], args);
-            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('MAX', 'operand', ['GROUP_BY'], args, {
+            const aggregationParameter = extractParameter('CUMUL', 'aggregationScalar', ['SUM', 'PERCENTAGE', 'AVG', 'MIN', 'MAX', 'COUNT'], args);
+            const overColumnParameter = extractParameter('CUMUL', 'operand', ['OVER'], args);
+            const groupByParameter = 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!`);
+                throw new ExpressionEvaluationError('GROUP_BY', `should be passed as an argument to the '${aggregationParameter.name}' aggregation function!`);
             }
             const cumulationExpressionEvaluation = mapAggregationToCumulation(aggregationParameter, overColumnParameter, context);
             const result = {
@@ -66,10 +63,10 @@ exports.aggregatedScalarExpressionFunctions = {
     },
     SUM: {
         handler(args, context) {
-            const sumColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('SUM', args);
+            const sumColumnParameter = extractColumnParameter('SUM', args);
             const sumColumnName = sumColumnParameter.value;
-            (0, expressionFunctionUtils_1.validateColumnType)(sumColumnName, ['Number'], 'SUM', context.adaptableApi);
-            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('SUM', 'operand', ['GROUP_BY'], args, {
+            validateColumnType(sumColumnName, ['Number'], 'SUM', context.adaptableApi);
+            const groupByParameter = extractParameter('SUM', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
             const aggregationExpressionEvaluation = {
@@ -83,7 +80,7 @@ exports.aggregatedScalarExpressionFunctions = {
                                 if (isUndefinedValue(rowValue)) {
                                     return totalSum;
                                 }
-                                return totalSum + (0, expressionFunctionUtils_1.getNumericValue)(rowValue);
+                                return totalSum + getNumericValue(rowValue);
                             },
                         },
                     },
@@ -111,17 +108,17 @@ exports.aggregatedScalarExpressionFunctions = {
     PERCENTAGE: {
         handler(args, context) {
             var _a;
-            const percentageColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('PERCENTAGE', args);
+            const percentageColumnParameter = extractColumnParameter('PERCENTAGE', args);
             const percentageColumnName = percentageColumnParameter.value;
-            (0, expressionFunctionUtils_1.validateColumnType)(percentageColumnName, ['Number'], 'PERCENTAGE', context.adaptableApi);
-            const sumOperand = (0, expressionFunctionUtils_1.extractParameter)('PERCENTAGE', 'aggregationScalar', ['SUM'], args, {
+            validateColumnType(percentageColumnName, ['Number'], 'PERCENTAGE', context.adaptableApi);
+            const sumOperand = extractParameter('PERCENTAGE', 'aggregationScalar', ['SUM'], args, {
                 isOptional: true,
             });
-            const groupByOperand = (0, expressionFunctionUtils_1.extractParameter)('PERCENTAGE', 'operand', ['GROUP_BY'], args, {
+            const groupByOperand = extractParameter('PERCENTAGE', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
             if (sumOperand && groupByOperand) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('PERCENTAGE', `expects either a SUM or a GROUP_BY argument`);
+                throw new ExpressionEvaluationError('PERCENTAGE', `expects either a SUM or a GROUP_BY argument`);
             }
             const sumAggregationColumnName = sumOperand
                 ? sumOperand.value.aggregationParams.reducers['SUM'].field
@@ -140,13 +137,13 @@ exports.aggregatedScalarExpressionFunctions = {
                                 if (isUndefinedValue(rowValue)) {
                                     return totalSum;
                                 }
-                                return totalSum + (0, expressionFunctionUtils_1.getNumericValue)(rowValue);
+                                return totalSum + getNumericValue(rowValue);
                             },
                         },
                     },
                 },
                 rowValueGetter: (rowNode, aggregationValue) => {
-                    return (((0, expressionFunctionUtils_1.getNumericValue)(context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, percentageColumnName)) /
+                    return ((getNumericValue(context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, percentageColumnName)) /
                         aggregationValue) *
                         100);
                 },
@@ -177,13 +174,13 @@ exports.aggregatedScalarExpressionFunctions = {
     },
     AVG: {
         handler(args, context) {
-            const avgColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('AVG', args);
+            const avgColumnParameter = extractColumnParameter('AVG', args);
             const avgColumnName = avgColumnParameter.value;
-            (0, expressionFunctionUtils_1.validateColumnType)(avgColumnName, ['Number'], 'AVG', context.adaptableApi);
-            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('AVG', 'operand', ['GROUP_BY'], args, {
+            validateColumnType(avgColumnName, ['Number'], 'AVG', context.adaptableApi);
+            const groupByParameter = extractParameter('AVG', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
-            const weightParameter = (0, expressionFunctionUtils_1.extractParameter)('AVG', 'operand', ['WEIGHT'], args, {
+            const weightParameter = extractParameter('AVG', 'operand', ['WEIGHT'], args, {
                 isOptional: true,
             });
             const aggregationExpressionEvaluation = {
@@ -201,10 +198,10 @@ exports.aggregatedScalarExpressionFunctions = {
                                 if (isUndefinedValue(rowValue)) {
                                     return aggregatedValue;
                                 }
-                                const numericRowValue = (0, expressionFunctionUtils_1.getNumericValue)(rowValue);
+                                const numericRowValue = getNumericValue(rowValue);
                                 if (weightParameter) {
                                     // weighted average
-                                    const weightValue = (_a = (0, expressionFunctionUtils_1.getNumericValue)(context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, weightParameter.value))) !== null && _a !== void 0 ? _a : 0;
+                                    const weightValue = (_a = getNumericValue(context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, weightParameter.value))) !== null && _a !== void 0 ? _a : 0;
                                     aggregatedValue.sumOfValues =
                                         aggregatedValue.sumOfValues + numericRowValue * weightValue;
                                     aggregatedValue.numberOfValues = aggregatedValue.numberOfValues + weightValue;
@@ -251,10 +248,10 @@ exports.aggregatedScalarExpressionFunctions = {
     },
     MIN: {
         handler(args, context) {
-            const minColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('MIN', args);
+            const minColumnParameter = extractColumnParameter('MIN', args);
             const minColumnName = minColumnParameter.value;
-            (0, expressionFunctionUtils_1.validateColumnType)(minColumnName, ['Number'], 'MIN', context.adaptableApi);
-            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('MIN', 'operand', ['GROUP_BY'], args, {
+            validateColumnType(minColumnName, ['Number'], 'MIN', context.adaptableApi);
+            const groupByParameter = extractParameter('MIN', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
             const aggregationExpressionEvaluation = {
@@ -268,7 +265,7 @@ exports.aggregatedScalarExpressionFunctions = {
                                 if (isUndefinedValue(rowValue)) {
                                     return minValue;
                                 }
-                                const numericRowValue = (0, expressionFunctionUtils_1.getNumericValue)(rowValue);
+                                const numericRowValue = getNumericValue(rowValue);
                                 return numericRowValue < minValue ? numericRowValue : minValue;
                             },
                             done: (minValue) => {
@@ -301,10 +298,10 @@ exports.aggregatedScalarExpressionFunctions = {
     },
     MAX: {
         handler(args, context) {
-            const maxColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('MAX', args);
+            const maxColumnParameter = extractColumnParameter('MAX', args);
             const maxColumnName = maxColumnParameter.value;
-            (0, expressionFunctionUtils_1.validateColumnType)(maxColumnName, ['Number'], 'MAX', context.adaptableApi);
-            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('MAX', 'operand', ['GROUP_BY'], args, {
+            validateColumnType(maxColumnName, ['Number'], 'MAX', context.adaptableApi);
+            const groupByParameter = extractParameter('MAX', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
             const aggregationExpressionEvaluation = {
@@ -318,7 +315,7 @@ exports.aggregatedScalarExpressionFunctions = {
                                 if (isUndefinedValue(rowValue)) {
                                     return maxValue;
                                 }
-                                const numericRowValue = (0, expressionFunctionUtils_1.getNumericValue)(rowValue);
+                                const numericRowValue = getNumericValue(rowValue);
                                 return numericRowValue > maxValue ? numericRowValue : maxValue;
                             },
                             done: (maxValue) => {
@@ -352,15 +349,15 @@ exports.aggregatedScalarExpressionFunctions = {
     QUANT: {
         handler(args, context) {
             var _a, _b, _c;
-            const quantileColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('QUANT', args);
+            const quantileColumnParameter = extractColumnParameter('QUANT', args);
             const quantileColumnName = quantileColumnParameter.value;
-            (0, expressionFunctionUtils_1.validateColumnType)(quantileColumnName, ['Number'], 'QUANT', context.adaptableApi);
+            validateColumnType(quantileColumnName, ['Number'], 'QUANT', context.adaptableApi);
             const qNumberCandidates = args.filter((arg) => typeof arg === 'number');
             if (qNumberCandidates.length !== 1) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('QUANT', 'expects a single positive numeric argument as q-quantile');
+                throw new ExpressionEvaluationError('QUANT', 'expects a single positive numeric argument as q-quantile');
             }
             const qNumber = qNumberCandidates[0];
-            const groupByOperand = (0, expressionFunctionUtils_1.extractParameter)('QUANT', 'operand', ['GROUP_BY'], args, {
+            const groupByOperand = extractParameter('QUANT', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
             const groupByColumnNames = groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value;
@@ -485,7 +482,7 @@ exports.aggregatedScalarExpressionFunctions = {
     QUARTILE: {
         handler(args, context) {
             const quartileArgs = [...args, 4];
-            return exports.aggregatedScalarExpressionFunctions.QUANT.handler(quartileArgs, context);
+            return aggregatedScalarExpressionFunctions.QUANT.handler(quartileArgs, context);
         },
         description: 'Calculates the Quartiles of the given group and displays which quartile the given value is in',
         signatures: ['QUARTILE( [colName])', 'QUARTILE( [colName1], GROUP_BY([colName2]) )'],
@@ -495,7 +492,7 @@ exports.aggregatedScalarExpressionFunctions = {
     PERCENTILE: {
         handler(args, context) {
             const quartileArgs = [...args, 100];
-            return exports.aggregatedScalarExpressionFunctions.QUANT.handler(quartileArgs, context);
+            return aggregatedScalarExpressionFunctions.QUANT.handler(quartileArgs, context);
         },
         description: 'Calculates the Percentile of the given group and displays which percentile the given value is in',
         signatures: ['PERCENTILE( [colName])', 'PERCENTILE( [colName1], GROUP_BY([colName2]) )'],
@@ -504,9 +501,9 @@ exports.aggregatedScalarExpressionFunctions = {
     },
     COUNT: {
         handler(args, context) {
-            const countColumnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('COUNT', args);
+            const countColumnParameter = extractColumnParameter('COUNT', args);
             const countColumnName = countColumnParameter.value;
-            const groupByParameter = (0, expressionFunctionUtils_1.extractParameter)('COUNT', 'operand', ['GROUP_BY'], args, {
+            const groupByParameter = extractParameter('COUNT', 'operand', ['GROUP_BY'], args, {
                 isOptional: true,
             });
             const aggregationExpressionEvaluation = {
@@ -547,8 +544,8 @@ exports.aggregatedScalarExpressionFunctions = {
     },
     OVER: {
         handler(args, context) {
-            const columnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('OVER', args);
-            (0, expressionFunctionUtils_1.validateColumnType)(columnParameter.value, ['Number', 'Date'], 'OVER', context.adaptableApi);
+            const columnParameter = extractColumnParameter('OVER', args);
+            validateColumnType(columnParameter.value, ['Number', 'Date'], 'OVER', context.adaptableApi);
             const result = {
                 type: 'operand',
                 name: 'OVER',
@@ -563,8 +560,8 @@ exports.aggregatedScalarExpressionFunctions = {
     },
     WEIGHT: {
         handler(args, context) {
-            const columnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('WEIGHT', args);
-            (0, expressionFunctionUtils_1.validateColumnType)(columnParameter.value, ['Number'], 'WEIGHT', context.adaptableApi);
+            const columnParameter = extractColumnParameter('WEIGHT', args);
+            validateColumnType(columnParameter.value, ['Number'], 'WEIGHT', context.adaptableApi);
             const result = {
                 type: 'operand',
                 name: 'WEIGHT',
@@ -583,7 +580,7 @@ exports.aggregatedScalarExpressionFunctions = {
     },
     GROUP_BY: {
         handler(args, context) {
-            const columnParameters = (0, expressionFunctionUtils_1.extractColumnParameters)('GROUP_BY', args);
+            const columnParameters = extractColumnParameters('GROUP_BY', args);
             const result = {
                 type: 'operand',
                 name: 'GROUP_BY',
@@ -598,7 +595,7 @@ exports.aggregatedScalarExpressionFunctions = {
     },
     COL: {
         handler(args, context) {
-            return (0, expressionFunctionUtils_1.handleColumnFunction)(args, context);
+            return handleColumnFunction(args, context);
         },
         description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
@@ -751,7 +748,7 @@ const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, c
     };
     return cumulationExpressionEvaluation;
 };
-exports.aggregatedScalarExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.aggregatedScalarExpressionFunctions);
+export const aggregatedScalarExpressionFunctionNames = getTypedKeys(aggregatedScalarExpressionFunctions);
 // !! mutates expressionEvaluation
 const addGroupByParams = (groupByColumnNames, expressionEvaluation) => {
     if (groupByColumnNames === null || groupByColumnNames === void 0 ? void 0 : groupByColumnNames.length) {

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

@@ -5,3 +5,4 @@ import { ExpressionFunction } from '../../parser/src/types';
 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[];
+export declare const isBooleanAdaptableQlFunction: (functionName: string) => functionName is BooleanFunctionName;