@adaptabletools/adaptable 17.0.0-canary.4 → 17.0.0-canary.6

package/src/Utilities/ExpressionFunctions/aggregatedBooleanExpressionFunctions.js

@@ -1,8 +1,12 @@
-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';
+"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");
 const SUPPORTED_AGGREGATION_FNS = ['SUM', 'MIN', 'MAX', 'AVG', 'COUNT'];
 const aggregationScalarOperandMap = {
     SUM: ['string', 'number'],
@@ -15,10 +19,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;
-export const aggregatedBooleanExpressionFunctions = {
+exports.aggregatedBooleanExpressionFunctions = {
     WHERE: {
         handler(args, context) {
-            return handleWhereFunction(args, context);
+            return (0, expressionFunctionUtils_1.handleWhereFunction)(args, context);
         },
         isHiddenFromMenu: true,
         description: 'Splits 2 composed queries, allowing for a main query(lhs) to have a where clause query(rhs) defined',
@@ -27,13 +31,13 @@ export const aggregatedBooleanExpressionFunctions = {
         hasEagerEvaluation: true,
         category: 'conditional',
     },
-    SUM: aggregatedScalarExpressionFunctions['SUM'],
-    MIN: aggregatedScalarExpressionFunctions['MIN'],
-    MAX: aggregatedScalarExpressionFunctions['MAX'],
-    AVG: aggregatedScalarExpressionFunctions['AVG'],
-    WEIGHT: aggregatedScalarExpressionFunctions['WEIGHT'],
-    COUNT: aggregatedScalarExpressionFunctions['COUNT'],
-    GROUP_BY: aggregatedScalarExpressionFunctions['GROUP_BY'],
+    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'],
     EQ: {
         handler(args, context) {
             return buildBooleanAggregationParameter(args, context, '=', (aggregatedValue, conditionValue) => aggregatedValue === conditionValue);
@@ -126,7 +130,7 @@ export const aggregatedBooleanExpressionFunctions = {
     },
     COL: {
         handler(args, context) {
-            return handleColumnFunction(args, context);
+            return (0, expressionFunctionUtils_1.handleColumnFunction)(args, context);
         },
         description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
@@ -152,14 +156,14 @@ const extractScalarAggregationOperand = (consumingFunctionName, argument) => {
     if (result == undefined ||
         result.type !== 'aggregationScalar' ||
         !SUPPORTED_AGGREGATION_FNS.includes(result.name)) {
-        throw new ExpressionEvaluationError(consumingFunctionName, `comparison operator expects as a left-hand operand an aggregation function of type '${SUPPORTED_AGGREGATION_FNS.join(' | ')}'`);
+        throw new ExpressionEvaluationError_1.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(consumingFunctionName, `comparison operator expects as a right-hand operand a scalar value of type '${allowedTypes.join(' | ')}'`);
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `comparison operator expects as a right-hand operand a scalar value of type '${allowedTypes.join(' | ')}'`);
     }
     if (typeof value === 'number') {
         return value;
@@ -170,7 +174,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('Numeric abbreviation', `"${stringValue}" is invalid, expecting a number with a suffix for thousands(K), millions(M) or billions(B)"`);
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError('Numeric abbreviation', `"${stringValue}" is invalid, expecting a number with a suffix for thousands(K), millions(M) or billions(B)"`);
     }
     // unit -> number
     const numberUnitRatios = {
@@ -180,6 +184,6 @@ const extractScalarOperand = (consumingFunctionName, value, allowedTypes) => {
         b: 1000000000,
     };
     // numeric value
-    return parseInt(numericString) * numberUnitRatios[largeNumberUnit.toLowerCase()];
+    return (0, parseInt_1.default)(numericString) * numberUnitRatios[largeNumberUnit.toLowerCase()];
 };
-export const aggregatedBooleanExpressionFunctionNames = getTypedKeys(aggregatedBooleanExpressionFunctions);
+exports.aggregatedBooleanExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.aggregatedBooleanExpressionFunctions);

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

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

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.js

@@ -1,11 +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';
-import { normalizeDateParam } from './dateUtils';
-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;
@@ -65,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];
@@ -89,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];
@@ -113,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];
@@ -140,10 +144,10 @@ export const booleanExpressionFunctions = {
     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];
@@ -167,10 +171,10 @@ export const booleanExpressionFunctions = {
     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];
@@ -194,10 +198,10 @@ export const booleanExpressionFunctions = {
     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];
@@ -221,7 +225,7 @@ export const booleanExpressionFunctions = {
     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',
@@ -243,7 +247,7 @@ export const booleanExpressionFunctions = {
     },
     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',
@@ -255,7 +259,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',
@@ -267,7 +271,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',
@@ -280,11 +284,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;
             });
         },
@@ -323,7 +327,7 @@ export const booleanExpressionFunctions = {
     },
     IS_HOLIDAY: {
         handler(args, context) {
-            const dateToCheck = normalizeDateParam(args[0]);
+            const dateToCheck = (0, dateUtils_1.normalizeDateParam)(args[0]);
             return context.adaptableApi.calendarApi.isHoliday(dateToCheck);
         },
         isHiddenFromMenu: false,
@@ -336,7 +340,7 @@ export const booleanExpressionFunctions = {
     },
     IS_WORKDAY: {
         handler(args, context) {
-            const dateToCheck = normalizeDateParam(args[0]);
+            const dateToCheck = (0, dateUtils_1.normalizeDateParam)(args[0]);
             return context.adaptableApi.calendarApi.isWorkingDay(dateToCheck);
         },
         isHiddenFromMenu: false,
@@ -348,7 +352,8 @@ export const booleanExpressionFunctions = {
         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.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,7 +11,8 @@ export const normalizeDateParams = (args) => {
     }
     return [first, second];
 };
-export const normalizeDateParam = (args) => {
+exports.normalizeDateParams = normalizeDateParams;
+const normalizeDateParam = (args) => {
     if (typeof args === 'string') {
         args = new Date(args);
     }
@@ -17,3 +21,4 @@ export const normalizeDateParam = (args) => {
     }
     return args;
 };
+exports.normalizeDateParam = normalizeDateParam;

package/src/Utilities/ExpressionFunctions/deepMap.js

@@ -1,5 +1,8 @@
+"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) => {
@@ -263,6 +266,7 @@ export class DeepMap {
         return makeIterator();
     }
 }
+exports.DeepMap = DeepMap;
 function once(fn) {
     let called = false;
     let result = null;