@adaptabletools/adaptable 16.2.4 → 17.0.0-canary.1

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

@@ -5,9 +5,9 @@ import { AggregateParams } from './scalarAggregationHelper';
 /**
  * List of all the AggregatedScalar Functions available in AdaptableQL
  */
-export declare type AggregatedScalarFunctionName = ScalarAggregationFunction | OperandFunction;
-export declare type ScalarAggregationFunction = 'SUM' | 'PERCENTAGE' | 'QUANT' | 'QUARTILE' | 'PERCENTILE' | 'AVG' | 'MIN' | 'MAX' | 'COUNT' | 'CUMUL';
-declare type OperandFunction = 'COL' | 'OVER' | 'GROUP_BY' | 'WEIGHT';
+export type AggregatedScalarFunctionName = ScalarAggregationFunction | OperandFunction;
+export type ScalarAggregationFunction = 'SUM' | 'PERCENTAGE' | 'QUANT' | 'QUARTILE' | 'PERCENTILE' | 'AVG' | 'MIN' | 'MAX' | 'COUNT' | 'CUMUL';
+type OperandFunction = 'COL' | 'OVER' | 'GROUP_BY' | 'WEIGHT';
 export interface ScalarAggregationParameter extends BaseParameter<'aggregationScalar', ScalarAggregationFunction> {
     value: AggregatedScalarExpressionEvaluation;
 }

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

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

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

@@ -2,6 +2,7 @@ import { ExpressionFunction } from '../../parser/src/types';
 /**
  * List of all the Boolean Functions available in AdaptableQL
  */
-export declare type BooleanFunctionName = 'EQ' | 'NEQ' | 'GT' | 'LT' | 'GTE' | 'LTE' | 'AND' | 'OR' | 'NOT' | 'BETWEEN' | 'IN' | 'CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'ANY_CONTAINS' | 'TRUE' | 'FALSE';
+export type BooleanFunctionName = 'EQ' | 'NEQ' | 'GT' | 'LT' | 'GTE' | 'LTE' | 'AND' | 'OR' | 'NOT' | 'BETWEEN' | 'IN' | 'CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'ANY_CONTAINS' | 'IS_NUMERIC' | 'REGEX' | 'IS_HOLIDAY' | 'IS_WORKDAY' | 'TRUE' | 'FALSE';
 export declare const booleanExpressionFunctions: Record<BooleanFunctionName, ExpressionFunction>;
 export declare const booleanExpressionFunctionsNames: BooleanFunctionName[];
+export declare const isBooleanAdaptableQlFunction: (functionName: string) => functionName is BooleanFunctionName;

package/src/Utilities/ExpressionFunctions/booleanExpressionFunctions.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-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;
@@ -39,6 +36,7 @@ exports.booleanExpressionFunctions = {
         signatures: ['statement AND statement'],
         examples: ['[col1] > 5 AND [col2] > 10'],
         returnType: 'boolean',
+        inputs: ['boolean', 'boolean'],
     },
     OR: {
         handler(args) {
@@ -50,6 +48,7 @@ exports.booleanExpressionFunctions = {
         signatures: ['statement OR statement'],
         examples: ['[col1] > 5 OR [col2] > 10'],
         returnType: 'boolean',
+        inputs: ['boolean', 'boolean'],
     },
     NOT: {
         handler(args) {
@@ -61,14 +60,15 @@ exports.booleanExpressionFunctions = {
         signatures: ['!statement'],
         examples: ['!([col1] > 5 AND [col2] > 10)'],
         returnType: 'boolean',
+        inputs: ['boolean'],
     },
     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];
@@ -79,14 +79,20 @@ exports.booleanExpressionFunctions = {
         signatures: ['value = value', 'EQ(a: value, b: value)'],
         examples: ['[col1] = 5', 'EQ([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+            ['text', 'text'],
+            ['boolean', 'boolean'],
+        ],
     },
     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];
@@ -97,14 +103,20 @@ exports.booleanExpressionFunctions = {
         signatures: ['value != value', 'NEQ(a: value, b: value)'],
         examples: ['[col1] != 5', 'NEQ([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+            ['text', 'text'],
+            ['boolean', 'boolean'],
+        ],
     },
     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];
@@ -120,14 +132,18 @@ exports.booleanExpressionFunctions = {
         ],
         examples: ['[col1] < 5', 'LT([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+        ],
     },
     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];
@@ -143,14 +159,18 @@ exports.booleanExpressionFunctions = {
         ],
         examples: ['[col1] <= 5', 'LTE([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+        ],
     },
     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];
@@ -166,14 +186,18 @@ exports.booleanExpressionFunctions = {
         ],
         examples: ['[col1] > 5', 'GT([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+        ],
     },
     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];
@@ -189,18 +213,23 @@ exports.booleanExpressionFunctions = {
         ],
         examples: ['[col1] >= 5', 'GTE([col1], 5)'],
         returnType: 'boolean',
+        inputs: [
+            ['number', 'number'],
+            ['date', 'date'],
+        ],
     },
     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',
         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'],
     },
     IN: {
         handler([needle, haystack]) {
@@ -214,7 +243,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',
@@ -222,10 +251,11 @@ exports.booleanExpressionFunctions = {
         signatures: ['CONTAINS(a: string, b: string)'],
         examples: ['CONTAINS([col1], "S")'],
         returnType: 'boolean',
+        inputs: ['text', 'text'],
     },
     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',
@@ -233,10 +263,11 @@ exports.booleanExpressionFunctions = {
         signatures: ['STARTS_WITH(a: string, b: string)'],
         examples: ['STARTS_WITH([col1], "S")'],
         returnType: 'boolean',
+        inputs: ['text', 'text'],
     },
     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',
@@ -244,15 +275,16 @@ exports.booleanExpressionFunctions = {
         signatures: ['ENDS_WITH(a: string, b: string)'],
         examples: ['ENDS_WITH([col1], "S")'],
         returnType: 'boolean',
+        inputs: ['text', 'text'],
     },
     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;
             });
         },
@@ -262,5 +294,61 @@ exports.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 = 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 = 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);

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