@adaptabletools/adaptable 17.0.6 → 18.0.0-canary.0

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.js

@@ -1,15 +1,11 @@
-"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 = {
+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 = {
     TRUE: {
         handler: () => {
             return true;
@@ -69,10 +65,10 @@ exports.booleanExpressionFunctions = {
     EQ: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return (0, isEqual_1.default)(args[0], args[1]);
+                return isEqual(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first == second;
             }
             return args[0] == args[1];
@@ -93,10 +89,10 @@ exports.booleanExpressionFunctions = {
     NEQ: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return !(0, isEqual_1.default)(args[0], args[1]);
+                return !isEqual(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first != second;
             }
             return args[0] != args[1];
@@ -117,10 +113,10 @@ exports.booleanExpressionFunctions = {
     LT: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return (0, isBefore_1.default)(args[0], args[1]);
+                return isBefore(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first < second;
             }
             return args[0] < args[1];
@@ -144,10 +140,10 @@ exports.booleanExpressionFunctions = {
     LTE: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return (0, isBefore_1.default)(args[0], args[1]) || (0, isEqual_1.default)(args[0], args[1]);
+                return isBefore(args[0], args[1]) || isEqual(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first <= second;
             }
             return args[0] <= args[1];
@@ -171,10 +167,10 @@ exports.booleanExpressionFunctions = {
     GT: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return (0, isAfter_1.default)(args[0], args[1]);
+                return isAfter(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first > second;
             }
             return args[0] > args[1];
@@ -198,10 +194,10 @@ exports.booleanExpressionFunctions = {
     GTE: {
         handler(args, context) {
             if (args[0] instanceof Date && args[1] instanceof Date) {
-                return (0, isAfter_1.default)(args[0], args[1]) || (0, isEqual_1.default)(args[0], args[1]);
+                return isAfter(args[0], args[1]) || isEqual(args[0], args[1]);
             }
             if (typeof args[0] === 'string' || typeof args[1] === 'string') {
-                const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+                const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
                 return first >= second;
             }
             return args[0] >= args[1];
@@ -225,7 +221,7 @@ exports.booleanExpressionFunctions = {
     BETWEEN: {
         handler([input, lower, upper]) {
             if (typeof input !== 'number')
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('BETWEEN', 'arg 1 should be a number');
+                throw new ExpressionEvaluationError('BETWEEN', 'arg 1 should be a number');
             return input >= lower && input <= upper;
         },
         category: 'comparison',
@@ -253,7 +249,7 @@ exports.booleanExpressionFunctions = {
     },
     CONTAINS: {
         handler(args, context) {
-            const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+            const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
             return first.indexOf(second) !== -1;
         },
         category: 'strings',
@@ -265,7 +261,7 @@ exports.booleanExpressionFunctions = {
     },
     STARTS_WITH: {
         handler(args, context) {
-            const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+            const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
             return first.startsWith(second);
         },
         category: 'strings',
@@ -277,7 +273,7 @@ exports.booleanExpressionFunctions = {
     },
     ENDS_WITH: {
         handler(args, context) {
-            const [first, second] = (0, expressionFunctionUtils_1.getStringValues)(context, String(args[0]), String(args[1]));
+            const [first, second] = getStringValues(context, String(args[0]), String(args[1]));
             return first.endsWith(second);
         },
         category: 'strings',
@@ -290,11 +286,11 @@ exports.booleanExpressionFunctions = {
     ANY_CONTAINS: {
         handler(args, context) {
             var _a;
-            const searchTerm = (0, expressionFunctionUtils_1.getStringValue)(context, String(args[0]));
+            const searchTerm = 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 = (0, expressionFunctionUtils_1.getStringValue)(context, String(value));
+                const columnValue = getStringValue(context, String(value));
                 return columnValue.indexOf(searchTerm) !== -1;
             });
         },
@@ -333,7 +329,7 @@ exports.booleanExpressionFunctions = {
     },
     IS_HOLIDAY: {
         handler(args, context) {
-            const dateToCheck = (0, dateUtils_1.normalizeDateParam)(args[0]);
+            const dateToCheck = normalizeDateParam(args[0]);
             return context.adaptableApi.calendarApi.isHoliday(dateToCheck);
         },
         isHiddenFromMenu: false,
@@ -346,7 +342,7 @@ exports.booleanExpressionFunctions = {
     },
     IS_WORKDAY: {
         handler(args, context) {
-            const dateToCheck = (0, dateUtils_1.normalizeDateParam)(args[0]);
+            const dateToCheck = normalizeDateParam(args[0]);
             return context.adaptableApi.calendarApi.isWorkingDay(dateToCheck);
         },
         isHiddenFromMenu: false,
@@ -358,8 +354,7 @@ exports.booleanExpressionFunctions = {
         inputs: ['date'],
     },
 };
-exports.booleanExpressionFunctionsNames = (0, TypeExtensions_1.getTypedKeys)(exports.booleanExpressionFunctions);
-const isBooleanAdaptableQlFunction = (functionName) => {
-    return exports.booleanExpressionFunctionsNames.includes(functionName);
+export const booleanExpressionFunctionsNames = getTypedKeys(booleanExpressionFunctions);
+export const isBooleanAdaptableQlFunction = (functionName) => {
+    return booleanExpressionFunctionsNames.includes(functionName);
 };
-exports.isBooleanAdaptableQlFunction = isBooleanAdaptableQlFunction;

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

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

package/src/Utilities/ExpressionFunctions/dateUtils.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeDateParam = exports.normalizeDateParams = void 0;
-const normalizeDateParams = (args) => {
+export const normalizeDateParams = (args) => {
     let [first, second] = args;
     if (typeof first === 'string') {
         first = new Date(first);
@@ -11,8 +8,7 @@ const normalizeDateParams = (args) => {
     }
     return [first, second];
 };
-exports.normalizeDateParams = normalizeDateParams;
-const normalizeDateParam = (args) => {
+export const normalizeDateParam = (args) => {
     if (typeof args === 'string') {
         args = new Date(args);
     }
@@ -21,4 +17,19 @@ const normalizeDateParam = (args) => {
     }
     return args;
 };
-exports.normalizeDateParam = normalizeDateParam;
+export const formatDate = (date, format) => {
+    date = normalizeDateParam(date);
+    const day = date.getDate();
+    const month = date.getMonth() + 1;
+    const year = date.getFullYear();
+    const hour = date.getHours();
+    const minute = date.getMinutes();
+    const second = date.getSeconds();
+    return format
+        .replace('DD', day.toString().padStart(2, '0'))
+        .replace('MM', month.toString().padStart(2, '0'))
+        .replace('YYYY', year.toString())
+        .replace('HH', hour.toString().padStart(2, '0'))
+        .replace('mm', minute.toString().padStart(2, '0'))
+        .replace('ss', second.toString().padStart(2, '0'));
+};

package/src/Utilities/ExpressionFunctions/deepMap.js

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