@adaptabletools/adaptable 17.0.0-canary.0 → 17.0.0-canary.10

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.js

@@ -1,10 +1,15 @@
-import isAfter from 'date-fns/isAfter';
-import isBefore from 'date-fns/isBefore';
-import isEqual from 'date-fns/isEqual';
-import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
-import { getStringValue, getStringValues } from './expressionFunctionUtils';
-import { getTypedKeys } from '../Extensions/TypeExtensions';
-export const booleanExpressionFunctions = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBooleanAdaptableQlFunction = 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"));
+const isEqual_1 = tslib_1.__importDefault(require("date-fns/isEqual"));
+const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
+const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
+const dateUtils_1 = require("./dateUtils");
+exports.booleanExpressionFunctions = {
     TRUE: {
         handler: () => {
             return true;
@@ -64,10 +69,10 @@ export const booleanExpressionFunctions = {
     EQ: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return isEqual(args[0], args[1]);
+                return (0, isEqual_1.default)(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
+                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
                 return first == second;
             }
             return args[0] == args[1];
@@ -88,10 +93,10 @@ export const booleanExpressionFunctions = {
     NEQ: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return !isEqual(args[0], args[1]);
+                return !(0, isEqual_1.default)(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
+                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
                 return first != second;
             }
             return args[0] != args[1];
@@ -112,10 +117,10 @@ export const booleanExpressionFunctions = {
     LT: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return isBefore(args[0], args[1]);
+                return (0, isBefore_1.default)(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
+                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
                 return first < second;
             }
             return args[0] < args[1];
@@ -134,16 +139,15 @@ export const booleanExpressionFunctions = {
         inputs: [
             ['number', 'number'],
             ['date', 'date'],
-            ['text', 'text'],
         ],
     },
     LTE: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return isBefore(args[0], args[1]) || isEqual(args[0], args[1]);
+                return (0, isBefore_1.default)(args[0], args[1]) || (0, isEqual_1.default)(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
+                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
                 return first <= second;
             }
             return args[0] <= args[1];
@@ -162,16 +166,15 @@ export const booleanExpressionFunctions = {
         inputs: [
             ['number', 'number'],
             ['date', 'date'],
-            ['text', 'text'],
         ],
     },
     GT: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return isAfter(args[0], args[1]);
+                return (0, isAfter_1.default)(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
+                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
                 return first > second;
             }
             return args[0] > args[1];
@@ -190,16 +193,15 @@ export const booleanExpressionFunctions = {
         inputs: [
             ['number', 'number'],
             ['date', 'date'],
-            ['text', 'text'],
         ],
     },
     GTE: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return isAfter(args[0], args[1]) || isEqual(args[0], args[1]);
+                return (0, isAfter_1.default)(args[0], args[1]) || (0, isEqual_1.default)(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
+                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
                 return first >= second;
             }
             return args[0] >= args[1];
@@ -218,19 +220,18 @@ export const booleanExpressionFunctions = {
         inputs: [
             ['number', 'number'],
             ['date', 'date'],
-            ['text', 'text'],
         ],
     },
     BETWEEN: {
         handler([input, lower, upper]) {
             if (typeof input !== 'number')
-                throw new ExpressionEvaluationError('BETWEEN', 'arg 1 should be a number');
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('BETWEEN', 'arg 1 should be a number');
             return input >= lower && input <= upper;
         },
         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])'],
+        examples: ['BETWEEN([col1], 10, 30)'],
         returnType: 'boolean',
         inputs: ['number', 'number', 'number'],
     },
@@ -243,10 +244,16 @@ export const booleanExpressionFunctions = {
         signatures: ['values IN (value, value, ...value)'],
         examples: ['[col1] IN (5, 10, AVG([col2],[col3]))'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number[]'],
+            // Date is currently not supported in select
+            // ['date', 'date[]'],
+            ['text', 'text[]'],
+        ],
     },
     CONTAINS: {
         handler(args, context) {
-            const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
+            const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
             return first.indexOf(second) !== -1;
         },
         category: 'strings',
@@ -258,7 +265,7 @@ export const booleanExpressionFunctions = {
     },
     STARTS_WITH: {
         handler(args, context) {
-            const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
+            const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
             return first.startsWith(second);
         },
         category: 'strings',
@@ -270,7 +277,7 @@ export const booleanExpressionFunctions = {
     },
     ENDS_WITH: {
         handler(args, context) {
-            const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
+            const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
             return first.endsWith(second);
         },
         category: 'strings',
@@ -283,11 +290,11 @@ export const booleanExpressionFunctions = {
     ANY_CONTAINS: {
         handler(args, context) {
             var _a;
-            const searchTerm = getStringValue(context, String(args[0]));
+            const searchTerm = (0, expressionFunctionUtils_1.getStringValue)(context, String(args[0]));
             return (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.columnApi.getColumns().some((column) => {
                 var _a;
                 const value = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.gridApi.getDisplayValueFromRowNode(context.node, column.columnId);
-                const columnValue = getStringValue(context, String(value));
+                const columnValue = (0, expressionFunctionUtils_1.getStringValue)(context, String(value));
                 return columnValue.indexOf(searchTerm) !== -1;
             });
         },
@@ -297,8 +304,62 @@ export const booleanExpressionFunctions = {
         examples: ['ANY_CONTAINS("abc")'],
         returnType: 'boolean',
     },
+    IS_NUMERIC: {
+        handler(args) {
+            return !isNaN(Number(args[0]));
+        },
+        isHiddenFromMenu: false,
+        description: 'Returns true if input is numeric',
+        signatures: ['IS_NUMERIC(a: number)'],
+        examples: ['IS_NUMERIC([columnName])'],
+        category: 'maths',
+        returnType: 'boolean',
+        inputs: ['number'],
+    },
+    REGEX: {
+        handler(args) {
+            // dont need context as here we always want case insenstivity in the Regex
+            const firstInput = String(args[0]);
+            const regex = String(args[1]);
+            return RegExp(regex).test(firstInput);
+        },
+        isHiddenFromMenu: false,
+        description: 'Returns true if Regular Expression matches',
+        signatures: ['REGEX(a: string, b: pattern)'],
+        examples: ['REGEX([col1], "[A-Z]+")'],
+        inputs: ['text', 'text'],
+        category: 'strings',
+        returnType: 'boolean',
+    },
+    IS_HOLIDAY: {
+        handler(args, context) {
+            const dateToCheck = (0, dateUtils_1.normalizeDateParam)(args[0]);
+            return context.adaptableApi.calendarApi.isHoliday(dateToCheck);
+        },
+        isHiddenFromMenu: false,
+        description: 'Returns true if input date is a Holiday',
+        signatures: ['IS_HOLIDAY(a: date)'],
+        examples: ['IS_HOLIDAY([columnName])'],
+        category: 'dates',
+        returnType: 'boolean',
+        inputs: ['date'],
+    },
+    IS_WORKDAY: {
+        handler(args, context) {
+            const dateToCheck = (0, dateUtils_1.normalizeDateParam)(args[0]);
+            return context.adaptableApi.calendarApi.isWorkingDay(dateToCheck);
+        },
+        isHiddenFromMenu: false,
+        description: 'Returns true if input date is a Working Day',
+        signatures: ['IS_WORKDAY(a: date)'],
+        examples: ['IS_WORKDAY([columnName])'],
+        category: 'dates',
+        returnType: 'boolean',
+        inputs: ['date'],
+    },
 };
-export const booleanExpressionFunctionsNames = getTypedKeys(booleanExpressionFunctions);
-export const isBooleanAdaptableQlFunction = (functionName) => {
-    return booleanExpressionFunctionsNames.includes(functionName);
+exports.booleanExpressionFunctionsNames = (0, TypeExtensions_1.getTypedKeys)(exports.booleanExpressionFunctions);
+const isBooleanAdaptableQlFunction = (functionName) => {
+    return exports.booleanExpressionFunctionsNames.includes(functionName);
 };
+exports.isBooleanAdaptableQlFunction = isBooleanAdaptableQlFunction;

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

@@ -1 +1,2 @@
 export declare const normalizeDateParams: (args: [string | number | Date, string | number | Date]) => [number | Date, number | Date];
+export declare const normalizeDateParam: (args: string | number | Date) => Date;

package/src/Utilities/ExpressionFunctions/dateUtils.js

@@ -1,4 +1,7 @@
-export const normalizeDateParams = (args) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDateParam = exports.normalizeDateParams = void 0;
+const normalizeDateParams = (args) => {
     let [first, second] = args;
     if (typeof first === 'string') {
         first = new Date(first);
@@ -8,3 +11,14 @@ export const normalizeDateParams = (args) => {
     }
     return [first, second];
 };
+exports.normalizeDateParams = normalizeDateParams;
+const normalizeDateParam = (args) => {
+    if (typeof args === 'string') {
+        args = new Date(args);
+    }
+    if (typeof args === 'number') {
+        args = new Date(args);
+    }
+    return args;
+};
+exports.normalizeDateParam = normalizeDateParam;

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

@@ -1,10 +1,10 @@
-declare type VoidFn = () => void;
-declare type Pair<KeyType, ValueType> = {
+type VoidFn = () => void;
+type Pair<KeyType, ValueType> = {
     value?: ValueType;
     map?: Map<KeyType, Pair<KeyType, ValueType>>;
     revision?: number;
 };
-export declare type DeepMapVisitFn<KeyType, ValueType> = (pair: Pair<KeyType, ValueType>, keys: KeyType[], next: VoidFn) => void;
+export type DeepMapVisitFn<KeyType, ValueType> = (pair: Pair<KeyType, ValueType>, keys: KeyType[], next: VoidFn) => void;
 export declare class DeepMap<KeyType, ValueType> {
     private map;
     private length;

package/src/Utilities/ExpressionFunctions/deepMap.js

@@ -1,5 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepMap = void 0;
 const SORT_ASC_REVISION = (p1, p2) => sortAscending(p1.revision, p2.revision);
-export class DeepMap {
+class DeepMap {
+    static clone(map) {
+        const clone = new DeepMap();
+        map.visit((pair, keys) => {
+            clone.set(keys, pair.value);
+        });
+        return clone;
+    }
     constructor(initial) {
         this.map = new Map();
         this.length = 0;
@@ -39,13 +49,6 @@ export class DeepMap {
             });
         }
     }
-    static clone(map) {
-        const clone = new DeepMap();
-        map.visit((pair, keys) => {
-            clone.set(keys, pair.value);
-        });
-        return clone;
-    }
     set(keys, value) {
         let currentMap = this.map;
         if (!keys.length) {
@@ -263,6 +266,7 @@ export class DeepMap {
         return makeIterator();
     }
 }
+exports.DeepMap = DeepMap;
 function once(fn) {
     let called = false;
     let result = null;

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

@@ -16,7 +16,7 @@ export declare const isTextSearchCaseInsensitive: (context: ExpressionContext) =
 export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<CellDataChangedInfo>;
 export declare const getGridChangeLog$: (context: ExpressionContext, gridChangeType: GridDataChangedInfo['rowTrigger']) => Observable<GridDataChangedInfo>;
 export declare const handleWhereFunction: (args: ExpressionNode[], context: ExpressionContext) => any;
-export declare type ExpressionNode = any;
+export 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[];

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -1,48 +1,57 @@
-import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
-import StringExtensions from '../Extensions/StringExtensions';
-import { filter } from 'rxjs/operators';
-import toNumber from 'lodash/toNumber';
-import { evaluateNode } from '../../parser/src/evaluator';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateColumnType = exports.getNumericValue = exports.handleColumnFunction = exports.extractParameters = exports.extractParameter = exports.extractColumnParameters = exports.extractColumnParameter = exports.evaluateExpressionNode = exports.handleWhereFunction = exports.getGridChangeLog$ = 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"));
+const operators_1 = require("rxjs/operators");
+const toNumber_1 = tslib_1.__importDefault(require("lodash/toNumber"));
+const evaluator_1 = require("../../parser/src/evaluator");
 // string functions may be case (in)sensitive, see internalApi.isTextComparisonCaseSensitive()
 // if case is insensitive, we convert ALL involved strings to lower case
-export const getStringValues = (context, ...stringArguments) => {
-    return isTextSearchCaseInsensitive(context)
+const getStringValues = (context, ...stringArguments) => {
+    return (0, exports.isTextSearchCaseInsensitive)(context)
         ? stringArguments.map((string) => string.toLowerCase())
         : stringArguments;
 };
-export const getStringValue = (context, stringArgument) => {
-    return isTextSearchCaseInsensitive(context) ? stringArgument.toLowerCase() : stringArgument;
+exports.getStringValues = getStringValues;
+const getStringValue = (context, stringArgument) => {
+    return (0, exports.isTextSearchCaseInsensitive)(context) ? stringArgument.toLowerCase() : stringArgument;
 };
-export const isTextSearchCaseInsensitive = (context) => !context.adaptableApi.expressionApi.useCaseSensitivity();
+exports.getStringValue = getStringValue;
+const isTextSearchCaseInsensitive = (context) => !context.adaptableApi.expressionApi.useCaseSensitivity();
+exports.isTextSearchCaseInsensitive = isTextSearchCaseInsensitive;
 // returns an observable which filters the source$ emissions and emits only if the CellDataChangedInfo relates to the given column
 // optionally, if a filter function (where clause) is provided, it is also evaluated
-export const getDataChangeLog$ = (context, columnNameFilter) => {
+const getDataChangeLog$ = (context, columnNameFilter) => {
     let dataChangeLog$ = context.adaptableApi.internalApi.getDataService().dataChangeLog$;
     // filter only the given column changes
-    dataChangeLog$ = dataChangeLog$.pipe(filter((dataChangeLog) => dataChangeLog.column.columnId === columnNameFilter));
+    dataChangeLog$ = dataChangeLog$.pipe((0, operators_1.filter)((dataChangeLog) => dataChangeLog.column.columnId === columnNameFilter));
     // filter based on the WHERE clause
     if (context.filterFn) {
-        dataChangeLog$ = dataChangeLog$.pipe(filter((value) => {
+        dataChangeLog$ = dataChangeLog$.pipe((0, operators_1.filter)((value) => {
             return context.filterFn(value.rowNode);
         }));
     }
     return dataChangeLog$;
 };
-export const getGridChangeLog$ = (context, gridChangeType) => {
+exports.getDataChangeLog$ = getDataChangeLog$;
+const getGridChangeLog$ = (context, gridChangeType) => {
     const gridChangeLog$ = context.adaptableApi.internalApi.getDataService().gridChangeLog$;
-    let gridChangeStream$ = gridChangeLog$.pipe(filter((gridDataChangedInfo) => gridDataChangedInfo.rowTrigger === gridChangeType));
+    let gridChangeStream$ = gridChangeLog$.pipe((0, operators_1.filter)((gridDataChangedInfo) => gridDataChangedInfo.rowTrigger === gridChangeType));
     // filter based on the WHERE clause
     if (context.filterFn) {
-        gridChangeStream$ = gridChangeStream$.pipe(filter((value) => value.rowNodes.some((node) => context.filterFn(node))));
+        gridChangeStream$ = gridChangeStream$.pipe((0, operators_1.filter)((value) => value.rowNodes.some((node) => context.filterFn(node))));
     }
     return gridChangeStream$;
 };
-export const handleWhereFunction = (args, context) => {
+exports.getGridChangeLog$ = getGridChangeLog$;
+const handleWhereFunction = (args, context) => {
     const reactiveExpressionNode = args[0];
     const whereClauseExpressionNode = args[1];
     const filterFn = (rowNode) => {
         // whereClauseResult
-        return evaluateNode(whereClauseExpressionNode, {
+        return (0, evaluator_1.evaluateNode)(whereClauseExpressionNode, {
             node: rowNode,
             userName: context.adaptableApi.optionsApi.getUserName(),
             adaptableId: context.adaptableApi.optionsApi.getAdaptableId(),
@@ -52,10 +61,11 @@ export const handleWhereFunction = (args, context) => {
         });
     };
     // observableExpressionResult
-    return evaluateExpressionNode(reactiveExpressionNode, context, filterFn);
+    return (0, exports.evaluateExpressionNode)(reactiveExpressionNode, context, filterFn);
 };
-export const evaluateExpressionNode = (expressionNode, context, filterFn = context.filterFn) => {
-    return evaluateNode(expressionNode, {
+exports.handleWhereFunction = handleWhereFunction;
+const evaluateExpressionNode = (expressionNode, context, filterFn = context.filterFn) => {
+    return (0, evaluator_1.evaluateNode)(expressionNode, {
         node: context.node,
         adaptableApi: context.adaptableApi,
         userName: context.adaptableApi.optionsApi.getUserName(),
@@ -65,36 +75,41 @@ export const evaluateExpressionNode = (expressionNode, context, filterFn = conte
         evaluateCustomQueryVariable: context.adaptableApi.internalApi.getQueryLanguageService().evaluateCustomQueryVariable,
     });
 };
-export const extractColumnParameter = (consumingFunctionName, args) => {
-    return extractParameter(consumingFunctionName, 'config', ['COL'], args);
+exports.evaluateExpressionNode = evaluateExpressionNode;
+const extractColumnParameter = (consumingFunctionName, args) => {
+    return (0, exports.extractParameter)(consumingFunctionName, 'config', ['COL'], args);
 };
-export const extractColumnParameters = (consumingFunctionName, args) => {
-    return extractParameters(consumingFunctionName, 'config', ['COL'], args);
+exports.extractColumnParameter = extractColumnParameter;
+const extractColumnParameters = (consumingFunctionName, args) => {
+    return (0, exports.extractParameters)(consumingFunctionName, 'config', ['COL'], args);
 };
-export const extractParameter = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
-    const parameters = extractParameters(consumingFunctionName, allowedType, allowedOperands, args, config);
+exports.extractColumnParameters = extractColumnParameters;
+const extractParameter = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
+    const parameters = (0, exports.extractParameters)(consumingFunctionName, allowedType, allowedOperands, args, config);
     if (parameters == undefined) {
         return;
     }
     if (parameters.length > 1) {
-        throw new ExpressionEvaluationError(consumingFunctionName, `expects only 1 argument of type '${[...new Set(parameters.map((op) => op.name))].join(`' / '`)}'`);
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects only 1 argument of type '${[...new Set(parameters.map((op) => op.name))].join(`' / '`)}'`);
     }
     return parameters[0];
 };
-export const extractParameters = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
+exports.extractParameter = extractParameter;
+const extractParameters = (consumingFunctionName, allowedType, allowedOperands, args, config) => {
     const { isOptional } = config !== null && config !== void 0 ? config : {};
     const result = args.filter((arg) => (arg === null || arg === void 0 ? void 0 : arg.type) === allowedType && allowedOperands.includes(arg === null || arg === void 0 ? void 0 : arg.name));
     if (isOptional && !result.length) {
         return;
     }
     if (!result.length) {
-        throw new ExpressionEvaluationError(consumingFunctionName, `expects an argument of type '${allowedOperands.join(`' / '`)}'`);
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects an argument of type '${allowedOperands.join(`' / '`)}'`);
     }
     return result;
 };
-export const handleColumnFunction = (args, context) => {
-    if (StringExtensions.IsNullOrEmpty(args[0])) {
-        throw new ExpressionEvaluationError('COL', `no column name is provided`);
+exports.extractParameters = extractParameters;
+const handleColumnFunction = (args, context) => {
+    if (StringExtensions_1.default.IsNullOrEmpty(args[0])) {
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `no column name is provided`);
     }
     validateColumnId(args[0], context.adaptableApi);
     const result = {
@@ -104,25 +119,28 @@ export const handleColumnFunction = (args, context) => {
     };
     return result;
 };
-export const getNumericValue = (input) => {
+exports.handleColumnFunction = handleColumnFunction;
+const getNumericValue = (input) => {
     if (typeof input === 'number') {
         return input;
     }
-    const numericValue = toNumber(input);
+    const numericValue = (0, toNumber_1.default)(input);
     return isNaN(numericValue) ? 0 : numericValue;
 };
-export const validateColumnType = (columnId, validColumnTypes, consumingFunction, api) => {
+exports.getNumericValue = getNumericValue;
+const validateColumnType = (columnId, validColumnTypes, consumingFunction, api) => {
     const columnType = api.columnApi.getColumnDataTypeForColumnId(columnId);
     if (!validColumnTypes.some((validType) => validType === columnType)) {
-        throw new ExpressionEvaluationError(consumingFunction, `expects a column of type ${validColumnTypes.join(' or ')}`);
+        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.getColumnWithColumnId(columnId);
     if (!column) {
-        throw new ExpressionEvaluationError('', `Column name "${columnId}" is not found`);
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError('', `Column name "${columnId}" is not found`);
     }
     if (!column.queryable) {
-        throw new ExpressionEvaluationError('', `Column name "${columnId}" is not queryable`);
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError('', `Column name "${columnId}" is not queryable`);
     }
 };

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

@@ -1,15 +1,15 @@
 import { DeepMap } from './deepMap';
-export declare type GroupKeyType<T extends any = any> = T;
-export declare type GroupBy<DataType, KeyType> = {
+export type GroupKeyType<T extends any = any> = T;
+export type GroupBy<DataType, KeyType> = {
     field: keyof DataType;
     toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
 };
-export declare type GroupParams<DataType, KeyType> = {
+export type GroupParams<DataType, KeyType> = {
     groupBy: GroupBy<DataType, KeyType>[];
     defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
     reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
 };
-export declare type DataSourceAggregationReducer<T, AggregationResultType> = {
+export type DataSourceAggregationReducer<T, AggregationResultType> = {
     name?: string;
     field?: keyof T;
     initialValue?: AggregationResultType;
@@ -17,18 +17,18 @@ export declare type DataSourceAggregationReducer<T, AggregationResultType> = {
     reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
     done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
 };
-export declare type DataGroupResult<DataType, KeyType extends any> = {
+export type DataGroupResult<DataType, KeyType extends any> = {
     deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
     groupParams: GroupParams<DataType, KeyType>;
     initialData: DataType[];
     reducerResults?: Record<string, any>;
 };
-export declare type DeepMapGroupValueType<DataType, KeyType> = {
+export type DeepMapGroupValueType<DataType, KeyType> = {
     items: DataType[];
     commonData?: Partial<DataType>;
     reducerResults: Record<string, any>;
 };
-export declare type AggregationReducerResult<AggregationResultType extends any = any> = {
+export type AggregationReducerResult<AggregationResultType extends any = any> = {
     value: AggregationResultType;
     id: string;
 };

package/src/Utilities/ExpressionFunctions/groupingMap.js

@@ -1,11 +1,14 @@
-import { DeepMap } from './deepMap';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.group = void 0;
+const deepMap_1 = require("./deepMap");
 function DEFAULT_TO_KEY(value) {
     return value;
 }
-export function group(groupParams, data) {
+function group(groupParams, data) {
     const { groupBy, defaultToKey = DEFAULT_TO_KEY, reducers } = groupParams;
     const groupByLength = groupBy.length;
-    const deepMap = new DeepMap();
+    const deepMap = new deepMap_1.DeepMap();
     let currentGroupKeys = [];
     const initialReducerValue = initReducers(reducers);
     const globalReducerResults = Object.assign({}, initialReducerValue);
@@ -51,6 +54,7 @@ export function group(groupParams, data) {
     };
     return result;
 }
+exports.group = group;
 function initReducers(reducers) {
     if (!reducers || !Object.keys(reducers).length) {
         return {};

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

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