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

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -1,16 +1,20 @@
-import { defer, of } from 'rxjs';
-import { count, debounceTime, delay, filter, map, mergeAll, mergeMap, startWith, takeUntil, tap, withLatestFrom, } from 'rxjs/operators';
-import parseInt from 'lodash/parseInt';
-import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
-import { extractColumnParameter, extractParameter, getDataChangeLog$, getGridChangeLog$, getNumericValue, handleColumnFunction, handleWhereFunction, validateColumnType, } from './expressionFunctionUtils';
-import { getTypedKeys } from '../Extensions/TypeExtensions';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observableExpressionFunctionNames = exports.observableExpressionFunctions = void 0;
+const tslib_1 = require("tslib");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const parseInt_1 = tslib_1.__importDefault(require("lodash/parseInt"));
+const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
+const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
+const TypeExtensions_1 = require("../Extensions/TypeExtensions");
 // numeric value(digits) followed by a single 's', 'm' or 'h' letter (case insensitive)
 const TIMEFRAME_REGEX = /^(\d+)(s|m|h)$/i;
 const SYSTEM_MAX_TIMEFRAME_SIZE = 86400000; // 24h
-export const observableExpressionFunctions = {
+exports.observableExpressionFunctions = {
     WHERE: {
         handler(args, context) {
-            return handleWhereFunction(args, context);
+            return (0, expressionFunctionUtils_1.handleWhereFunction)(args, context);
         },
         isHiddenFromMenu: true,
         description: 'Limits the rows against which the Observable expression will be evaluated',
@@ -21,32 +25,32 @@ export const observableExpressionFunctions = {
     },
     ROW_CHANGE: {
         handler(args, context) {
-            const operandParameter = extractParameter('ROW_CHANGE', 'operand', ['COUNT', 'MAX', 'MIN', 'NONE'], args);
-            const timeframeParameter = extractParameter('ROW_CHANGE', 'config', ['TIMEFRAME'], args);
-            let dataChangeLog$ = getDataChangeLog$(context, operandParameter.column);
+            const operandParameter = (0, expressionFunctionUtils_1.extractParameter)('ROW_CHANGE', 'operand', ['COUNT', 'MAX', 'MIN', 'NONE'], args);
+            const timeframeParameter = (0, expressionFunctionUtils_1.extractParameter)('ROW_CHANGE', 'config', ['TIMEFRAME'], args);
+            let dataChangeLog$ = (0, expressionFunctionUtils_1.getDataChangeLog$)(context, operandParameter.column);
             switch (operandParameter.name) {
                 case 'COUNT': {
                     const timeframeChange$ = getTrailingRowCountChange$(dataChangeLog$, timeframeParameter.value, operandParameter.value);
                     return getDataChangeCount$(dataChangeLog$, timeframeChange$, operandParameter.value);
                 }
                 case 'MIN': {
-                    validateColumnType(operandParameter.column, ['Number'], 'MIN', context.adaptableApi);
+                    (0, expressionFunctionUtils_1.validateColumnType)(operandParameter.column, ['Number'], 'MIN', context.adaptableApi);
                     const timeframeChange$ = getTrailingRowValueChange$(dataChangeLog$, timeframeParameter.value);
                     return getDataChangeMin$(dataChangeLog$, timeframeChange$);
                 }
                 case 'MAX': {
-                    validateColumnType(operandParameter.column, ['Number'], 'MAX', context.adaptableApi);
+                    (0, expressionFunctionUtils_1.validateColumnType)(operandParameter.column, ['Number'], 'MAX', context.adaptableApi);
                     const timeframeChange$ = getTrailingRowValueChange$(dataChangeLog$, timeframeParameter.value);
                     return getDataChangeMax$(dataChangeLog$, timeframeChange$);
                 }
                 case 'NONE': {
                     return dataChangeLog$.pipe(
                     // wait for the given time
-                    debounceTime(timeframeParameter.value), 
+                    (0, operators_1.debounceTime)(timeframeParameter.value), 
                     // completing the observable (ex. alert deletion) will also fire the NONE event
                     // takeUntil takes care of this, ignoring any emissions as soon as the source completes
                     // (count() result is irrelevant here, the main thing is that it emits an source completion)
-                    takeUntil(dataChangeLog$.pipe(count())));
+                    (0, operators_1.takeUntil)(dataChangeLog$.pipe((0, operators_1.count)())));
                 }
             }
         },
@@ -61,34 +65,34 @@ export const observableExpressionFunctions = {
     },
     GRID_CHANGE: {
         handler(args, context) {
-            const operandParameter = extractParameter('GRID_CHANGE', 'operand', ['COUNT', 'MAX', 'MIN', 'NONE'], args);
-            const timeframeParameter = extractParameter('GRID_CHANGE', 'config', ['TIMEFRAME'], args);
-            let dataChangeLog$ = getDataChangeLog$(context, operandParameter.column);
+            const operandParameter = (0, expressionFunctionUtils_1.extractParameter)('GRID_CHANGE', 'operand', ['COUNT', 'MAX', 'MIN', 'NONE'], args);
+            const timeframeParameter = (0, expressionFunctionUtils_1.extractParameter)('GRID_CHANGE', 'config', ['TIMEFRAME'], args);
+            let dataChangeLog$ = (0, expressionFunctionUtils_1.getDataChangeLog$)(context, operandParameter.column);
             switch (operandParameter.name) {
                 case 'COUNT': {
                     const timeframeChange$ = getTrailingGridCountChange$(dataChangeLog$, timeframeParameter.value, operandParameter.value);
                     return getDataChangeCount$(dataChangeLog$, timeframeChange$, operandParameter.value);
                 }
                 case 'MIN': {
-                    validateColumnType(operandParameter.column, ['Number'], 'MIN', context.adaptableApi);
+                    (0, expressionFunctionUtils_1.validateColumnType)(operandParameter.column, ['Number'], 'MIN', context.adaptableApi);
                     const timeframeChange$ = getTrailingGridValueChange$(dataChangeLog$, timeframeParameter.value);
                     return getDataChangeMin$(dataChangeLog$, timeframeChange$);
                 }
                 case 'MAX': {
-                    validateColumnType(operandParameter.column, ['Number'], 'MAX', context.adaptableApi);
+                    (0, expressionFunctionUtils_1.validateColumnType)(operandParameter.column, ['Number'], 'MAX', context.adaptableApi);
                     const timeframeChange$ = getTrailingGridValueChange$(dataChangeLog$, timeframeParameter.value);
                     return getDataChangeMax$(dataChangeLog$, timeframeChange$);
                 }
                 case 'NONE': {
                     return dataChangeLog$.pipe(
                     // add a synthetic first value to ensure the grid is observed even when there are no changes
-                    startWith(getDataChangedInfoStub(context)), 
+                    (0, operators_1.startWith)(getDataChangedInfoStub(context)), 
                     // wait for the given time
-                    debounceTime(timeframeParameter.value), 
+                    (0, operators_1.debounceTime)(timeframeParameter.value), 
                     // completing the observable (ex. alert deletion) will also fire the NONE event
                     // takeUntil takes care of this, ignoring any emissions as soon as the source completes
                     // (count() result is irrelevant here, the main thing is that it emits a source completion)
-                    takeUntil(dataChangeLog$.pipe(count())));
+                    (0, operators_1.takeUntil)(dataChangeLog$.pipe((0, operators_1.count)())));
                 }
             }
         },
@@ -103,7 +107,7 @@ export const observableExpressionFunctions = {
     },
     ROW_ADDED: {
         handler(args, context) {
-            const gridChangeLog$ = getGridChangeLog$(context, 'Add');
+            const gridChangeLog$ = (0, expressionFunctionUtils_1.getGridChangeLog$)(context, 'Add');
             return handleGridRowAddedOrRemoved(args, gridChangeLog$, 'ROW_ADDED', context);
         },
         returnType: 'boolean',
@@ -124,7 +128,7 @@ export const observableExpressionFunctions = {
     },
     ROW_REMOVED: {
         handler(args, context) {
-            const gridChangeLog$ = getGridChangeLog$(context, 'Delete');
+            const gridChangeLog$ = (0, expressionFunctionUtils_1.getGridChangeLog$)(context, 'Delete');
             return handleGridRowAddedOrRemoved(args, gridChangeLog$, 'ROW_REMOVED', context);
         },
         returnType: 'boolean',
@@ -145,7 +149,7 @@ export const observableExpressionFunctions = {
     },
     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)'],
@@ -154,10 +158,10 @@ export const observableExpressionFunctions = {
     },
     COUNT: {
         handler(args) {
-            const columnParameter = extractColumnParameter('COUNT', args);
+            const columnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('COUNT', args);
             const countValue = args.find((arg) => typeof arg === 'number');
             if (countValue == null || countValue <= 0) {
-                throw new ExpressionEvaluationError('COUNT', 'expects a positive number as argument');
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COUNT', 'expects a positive number as argument');
             }
             const result = {
                 type: 'operand',
@@ -177,7 +181,7 @@ export const observableExpressionFunctions = {
     },
     NONE: {
         handler(args) {
-            const columnParameter = extractColumnParameter('NONE', args);
+            const columnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('NONE', args);
             const result = {
                 type: 'operand',
                 name: 'NONE',
@@ -192,7 +196,7 @@ export const observableExpressionFunctions = {
     },
     MIN: {
         handler(args) {
-            const columnParameter = extractColumnParameter('MIN', args);
+            const columnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('MIN', args);
             const result = {
                 type: 'operand',
                 name: 'MIN',
@@ -207,7 +211,7 @@ export const observableExpressionFunctions = {
     },
     MAX: {
         handler(args) {
-            const columnParameter = extractColumnParameter('MAX', args);
+            const columnParameter = (0, expressionFunctionUtils_1.extractColumnParameter)('MAX', args);
             const result = {
                 type: 'operand',
                 name: 'MAX',
@@ -236,10 +240,10 @@ export const observableExpressionFunctions = {
             const unit = (_a = matchingResult === null || matchingResult === void 0 ? void 0 : matchingResult[2]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
             let duration;
             if (value && unit && durationUnitRatios[unit]) {
-                duration = parseInt(value) * durationUnitRatios[unit];
+                duration = (0, parseInt_1.default)(value) * durationUnitRatios[unit];
             }
             if (!duration) {
-                throw new ExpressionEvaluationError('TIMEFRAME', `timeframe expression is invalid`);
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('TIMEFRAME', `timeframe expression is invalid`);
             }
             // check if the given duration is greater than the generally defined maxTimeframe size
             duration = getMaxTimeframeSize(duration, context);
@@ -260,7 +264,7 @@ export const observableExpressionFunctions = {
         category: 'operand',
     },
 };
-export const observableExpressionFunctionNames = getTypedKeys(observableExpressionFunctions);
+exports.observableExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.observableExpressionFunctions);
 // return TRUE if the last(tail) element has the greatest value
 const isLastElementMaxValue = (values) => {
     const [tailValue] = values.slice(-1);
@@ -314,27 +318,27 @@ const getDataChangedInfoStub = (context) => {
 };
 // returns an observable which fires if the source$ emitted `targetCount` times in the given `timeframeChange$` period
 const getDataChangeCount$ = (dataChangeLog$, timeframeChange$, targetCount) => {
-    return dataChangeLog$.pipe(withLatestFrom(timeframeChange$), filter(([_, changeCountWithinTimeframe]) => {
+    return dataChangeLog$.pipe((0, operators_1.withLatestFrom)(timeframeChange$), (0, operators_1.filter)(([_, changeCountWithinTimeframe]) => {
         return targetCount === changeCountWithinTimeframe;
-    }), map(([source]) => source));
+    }), (0, operators_1.map)(([source]) => source));
 };
 // returns an observable which fires if the last source$ emission had the lowest(min) value in the given `timeframeChange$` period
 const getDataChangeMin$ = (dataChangeLog$, timeframeChange$) => {
-    return dataChangeLog$.pipe(withLatestFrom(timeframeChange$), filter(([changeLog, values]) => {
+    return dataChangeLog$.pipe((0, operators_1.withLatestFrom)(timeframeChange$), (0, operators_1.filter)(([changeLog, values]) => {
         return values.length > 1
             ? isLastElementMinValue(values)
-            : getNumericValue(changeLog.oldValue) > getNumericValue(changeLog.newValue);
-    }), map(([changeLog]) => {
+            : (0, expressionFunctionUtils_1.getNumericValue)(changeLog.oldValue) > (0, expressionFunctionUtils_1.getNumericValue)(changeLog.newValue);
+    }), (0, operators_1.map)(([changeLog]) => {
         return changeLog;
     }));
 };
 // returns an observable which fires if the last source$ emission had the highest(max) value in the given `timeframeChange$` period
 const getDataChangeMax$ = (dataChangeLog$, timeframeChange$) => {
-    return dataChangeLog$.pipe(withLatestFrom(timeframeChange$), filter(([changeLog, values]) => {
+    return dataChangeLog$.pipe((0, operators_1.withLatestFrom)(timeframeChange$), (0, operators_1.filter)(([changeLog, values]) => {
         return values.length > 1
             ? isLastElementMaxValue(values)
-            : getNumericValue(changeLog.oldValue) < getNumericValue(changeLog.newValue);
-    }), map(([changeLog]) => {
+            : (0, expressionFunctionUtils_1.getNumericValue)(changeLog.oldValue) < (0, expressionFunctionUtils_1.getNumericValue)(changeLog.newValue);
+    }), (0, operators_1.map)(([changeLog]) => {
         return changeLog;
     }));
 };
@@ -342,7 +346,7 @@ const getDataChangeMax$ = (dataChangeLog$, timeframeChange$) => {
 // the counter is continuously up-to-date in the given timeframe
 // if the given counterLimit is reached, the counter is reset
 const getTrailingGridCountChange$ = (source$, trailingPeriod, counterLimit) => {
-    return defer(() => {
+    return (0, rxjs_1.defer)(() => {
         // keep the counter value in an internal intermediary state
         let counter = 0;
         const movingTimeWindow$ = getSlidingTimeframe$(source$, trailingPeriod, (dataChangeLog) => {
@@ -353,7 +357,7 @@ const getTrailingGridCountChange$ = (source$, trailingPeriod, counterLimit) => {
                 counter--;
             }
         });
-        return movingTimeWindow$.pipe(map(() => {
+        return movingTimeWindow$.pipe((0, operators_1.map)(() => {
             const gridCounter = counter;
             if (gridCounter === counterLimit) {
                 // reset counter
@@ -368,7 +372,7 @@ const getTrailingGridCountChange$ = (source$, trailingPeriod, counterLimit) => {
 // the counter is continuously up-to-date in the given timeframe
 // if the given counterLimit is reached, the counter is reset
 const getTrailingRowCountChange$ = (source$, trailingPeriod, counterLimit) => {
-    return defer(() => {
+    return (0, rxjs_1.defer)(() => {
         // keep the counter value in an internal intermediary state (distinct per row PK)
         const counterMap = new Map();
         const getCellCounter = (dataChangeLog) => { var _a; return (_a = counterMap.get(dataChangeLog.primaryKeyValue)) !== null && _a !== void 0 ? _a : 0; };
@@ -382,7 +386,7 @@ const getTrailingRowCountChange$ = (source$, trailingPeriod, counterLimit) => {
                 counterMap.set(dataChangeLog.primaryKeyValue, --currentCounter);
             }
         });
-        return slidingTimeframe$.pipe(map((dataChangeLog) => {
+        return slidingTimeframe$.pipe((0, operators_1.map)((dataChangeLog) => {
             const cellCounter = getCellCounter(dataChangeLog);
             if (cellCounter === counterLimit) {
                 // reset counter
@@ -395,18 +399,18 @@ const getTrailingRowCountChange$ = (source$, trailingPeriod, counterLimit) => {
 // returns an observable which maps a dataChangeLogEntry to the array of changed values in the entire grid
 // the changed values array is continuously up-to-date in the given timeframe
 const getTrailingGridValueChange$ = (source$, trailingPeriod) => {
-    return defer(() => {
+    return (0, rxjs_1.defer)(() => {
         // keep the changed values in an internal intermediary state
         let values = [];
         const doubleInsertionsMap = new WeakMap();
         const slidingTimeframe$ = getSlidingTimeframe$(source$, trailingPeriod, (dataChangeLog) => {
             if (!values.length) {
                 // values is empty, so we evaluate both old & new node values
-                values.push(getNumericValue(dataChangeLog.oldValue));
+                values.push((0, expressionFunctionUtils_1.getNumericValue)(dataChangeLog.oldValue));
                 // mark the double insertion, we will have to pop 2 elements
                 doubleInsertionsMap.set(dataChangeLog, true);
             }
-            values.push(getNumericValue(dataChangeLog.newValue));
+            values.push((0, expressionFunctionUtils_1.getNumericValue)(dataChangeLog.newValue));
         }, (dataChangeLog) => {
             values.shift();
             if (doubleInsertionsMap.get(dataChangeLog)) {
@@ -415,13 +419,13 @@ const getTrailingGridValueChange$ = (source$, trailingPeriod) => {
                 doubleInsertionsMap.delete(dataChangeLog);
             }
         });
-        return slidingTimeframe$.pipe(map(() => values));
+        return slidingTimeframe$.pipe((0, operators_1.map)(() => values));
     });
 };
 // returns an observable which maps a dataChangeLogEntry to the array of changed values in the row of the given dataChangeLogEntry
 // the changed values array is continuously up-to-date in the given timeframe
 const getTrailingRowValueChange$ = (source$, trailingPeriod) => {
-    return defer(() => {
+    return (0, rxjs_1.defer)(() => {
         // keep the changed values in an internal intermediary state (distinct per row PK)
         const rowValuesMap = new Map();
         const doubleInsertionsMap = new WeakMap();
@@ -430,11 +434,11 @@ const getTrailingRowValueChange$ = (source$, trailingPeriod) => {
             let rowValues = getRowValues(dataChangeLog);
             if (!rowValues.length) {
                 // values is empty, so we evaluate both old & new node values
-                rowValues.push(getNumericValue(dataChangeLog.oldValue));
+                rowValues.push((0, expressionFunctionUtils_1.getNumericValue)(dataChangeLog.oldValue));
                 // mark the double insertion, we will have to pop 2 elements
                 doubleInsertionsMap.set(dataChangeLog, true);
             }
-            rowValues.push(getNumericValue(dataChangeLog.newValue));
+            rowValues.push((0, expressionFunctionUtils_1.getNumericValue)(dataChangeLog.newValue));
             rowValuesMap.set(dataChangeLog.primaryKeyValue, rowValues);
         }, (dataChangeLog) => {
             let rowValues = getRowValues(dataChangeLog);
@@ -446,7 +450,7 @@ const getTrailingRowValueChange$ = (source$, trailingPeriod) => {
             }
             rowValuesMap.set(dataChangeLog.primaryKeyValue, rowValues);
         });
-        return slidingTimeframe$.pipe(map((dataChangeLog) => getRowValues(dataChangeLog)));
+        return slidingTimeframe$.pipe((0, operators_1.map)((dataChangeLog) => getRowValues(dataChangeLog)));
     });
 };
 // return an observable which will emit when the source$ event enters, respectively exits the timeframe
@@ -454,16 +458,16 @@ const getTrailingRowValueChange$ = (source$, trailingPeriod) => {
 const getSlidingTimeframe$ = (source$, timeframeDuration, onTimeframeEnter, onTimeframeExit) => {
     return source$.pipe(
     // create intermediary observable which, for each emission from source$:
-    mergeMap((dataChangeLog) => {
+    (0, operators_1.mergeMap)((dataChangeLog) => {
         // 1. it will emit the payload immediately...
-        const enter$ = of(dataChangeLog).pipe(
+        const enter$ = (0, rxjs_1.of)(dataChangeLog).pipe(
         // ...and execute the provided onPushHandler() callback
-        tap((dataChangeLog) => onTimeframeEnter(dataChangeLog)));
+        (0, operators_1.tap)((dataChangeLog) => onTimeframeEnter(dataChangeLog)));
         // 2. and after a given 'timeWindowSize' delay it will re-emit the payload...
-        const exit$ = of(dataChangeLog).pipe(delay(timeframeDuration), 
+        const exit$ = (0, rxjs_1.of)(dataChangeLog).pipe((0, operators_1.delay)(timeframeDuration), 
         // ...and execute the provided onPopHandler() callback
-        tap((dataChangeLog) => onTimeframeExit(dataChangeLog)));
-        return of(enter$, exit$).pipe(mergeAll());
+        (0, operators_1.tap)((dataChangeLog) => onTimeframeExit(dataChangeLog)));
+        return (0, rxjs_1.of)(enter$, exit$).pipe((0, operators_1.mergeAll)());
     }));
 };
 const getMaxTimeframeSize = (expressionValue, context) => {
@@ -476,11 +480,11 @@ const getMaxTimeframeSize = (expressionValue, context) => {
 const handleGridRowAddedOrRemoved = (args, gridChangeLog$, consumingFunction, context) => {
     let countValue = args.find((arg) => typeof arg === 'number');
     if (countValue < 0) {
-        throw new ExpressionEvaluationError(consumingFunction, 'supports only zero or a positive number as argument');
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunction, 'supports only zero or a positive number as argument');
     }
-    let timeframeParameter = extractParameter(consumingFunction, 'config', ['TIMEFRAME'], args, { isOptional: true });
+    let timeframeParameter = (0, expressionFunctionUtils_1.extractParameter)(consumingFunction, 'config', ['TIMEFRAME'], args, { isOptional: true });
     if (countValue === 0 && timeframeParameter == null) {
-        throw new ExpressionEvaluationError(consumingFunction, 'requires a TIMEFRAME parameter when observing for no changes');
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunction, 'requires a TIMEFRAME parameter when observing for no changes');
     }
     if (countValue == null && timeframeParameter == null) {
         // default - return all new rows
@@ -511,13 +515,13 @@ const handleGridRowAddedOrRemoved = (args, gridChangeLog$, consumingFunction, co
         };
         return gridChangeLog$.pipe(
         // add a synthetic first value to ensure the grid is observed even when there are no changes
-        startWith(gridDataChangeInfoStub), 
+        (0, operators_1.startWith)(gridDataChangeInfoStub), 
         // wait for the given time
-        debounceTime(timeframeParameter.value), 
+        (0, operators_1.debounceTime)(timeframeParameter.value), 
         // completing the observable (ex. alert deletion) will also fire the NONE event
         // takeUntil takes care of this, ignoring any emissions as soon as the source completes
         // (count() result is irrelevant here, the main thing is that it emits a source completion)
-        takeUntil(gridChangeLog$.pipe(count())));
+        (0, operators_1.takeUntil)(gridChangeLog$.pipe((0, operators_1.count)())));
     }
     const timeframeChange$ = getTrailingGridCountChange$(gridChangeLog$, timeframeParameter.value, countValue);
     return getDataChangeCount$(gridChangeLog$, timeframeChange$, countValue);

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

@@ -1,15 +1,15 @@
 import { DeepMap } from './deepMap';
-export declare type GroupKeyType<T extends any = any> = T;
-export declare type GroupBy<DataType, KeyType> = {
+export type GroupKeyType<T extends any = any> = T;
+export type GroupBy<DataType, KeyType> = {
     field: keyof DataType & string;
     toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
 };
-export declare type AggregateParams<DataType, KeyType> = {
+export type AggregateParams<DataType, KeyType> = {
     reducers: Record<string, DataAggregationReducer<DataType, any>>;
     groupBy?: GroupBy<DataType, KeyType>[];
     defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
 };
-export declare type DataAggregationReducer<T, AggregationResultType> = {
+export type DataAggregationReducer<T, AggregationResultType> = {
     name?: string;
     field?: keyof T & string;
     initialValue?: AggregationResultType;
@@ -17,16 +17,16 @@ export declare type DataAggregationReducer<T, AggregationResultType> = {
     reducer: string | ((accumulator: any, value: any, data: T, dataIndex: number) => AggregationResultType | any);
     done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
 };
-export declare type DataAggregationResult<DataType, KeyType extends any> = {
+export type DataAggregationResult<DataType, KeyType extends any> = {
     deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapAggregationValueType<DataType, KeyType>>;
     aggregateParams: AggregateParams<DataType, KeyType>;
     initialData: DataType[];
     reducerResults?: Record<string, AggregationReducerResult>;
 };
-export declare type DeepMapAggregationValueType<DataType, KeyType> = {
+export type DeepMapAggregationValueType<DataType, KeyType> = {
     items: DataType[];
     commonData?: Partial<DataType>;
     reducerResults: Record<string, AggregationReducerResult>;
 };
-export declare type AggregationReducerResult = number;
+export type AggregationReducerResult = number;
 export declare function aggregate<DataType, KeyType = any>(aggregateParams: AggregateParams<DataType, KeyType>, data: DataType[]): DataAggregationResult<DataType, KeyType>;

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -1,11 +1,14 @@
-import { DeepMap } from './deepMap';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregate = void 0;
+const deepMap_1 = require("./deepMap");
 function DEFAULT_TO_KEY(value) {
     return value;
 }
-export function aggregate(aggregateParams, data) {
+function aggregate(aggregateParams, data) {
     const { groupBy = [], defaultToKey = DEFAULT_TO_KEY, reducers } = aggregateParams;
     const groupByLength = groupBy.length;
-    const deepMap = new DeepMap();
+    const deepMap = new deepMap_1.DeepMap();
     let currentGroupKeys = [];
     const getInitialReducerValue = () => {
         return JSON.parse(JSON.stringify(initReducers(reducers)));
@@ -52,6 +55,7 @@ export function aggregate(aggregateParams, data) {
     };
     return result;
 }
+exports.aggregate = aggregate;
 function initReducers(reducers) {
     if (!reducers || !Object.keys(reducers).length) {
         return {};

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

@@ -2,6 +2,6 @@ import { ExpressionFunction } from '../../parser/src/types';
 /**
  * List of all the Scalar Functions available in AdaptableQL
  */
-export declare type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'ABS' | 'CEILING' | 'FLOOR' | 'ROUND' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'TODAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'NULL' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'CASE' | 'COL' | 'VAR' | 'TO_ARRAY' | 'QUERY' | 'IS_BLANK';
+export type ScalarFunctionName = 'ADD' | 'SUB' | 'MUL' | 'DIV' | 'MOD' | 'POW' | 'ABS' | 'CEILING' | 'FLOOR' | 'ROUND' | 'MIN' | 'MAX' | 'AVG' | 'DATE' | 'NOW' | 'TODAY' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | 'ADD_DAYS' | 'ADD_WEEKS' | 'ADD_MONTHS' | 'ADD_YEARS' | 'DIFF_DAYS' | 'DIFF_WEEKS' | 'DIFF_MONTHS' | 'DIFF_YEARS' | 'SUB_STRING' | 'REPLACE' | 'COALESCE' | 'NULL' | 'LEN' | 'UPPER' | 'LOWER' | 'CONCAT' | 'IF' | 'CASE' | 'COL' | 'VAR' | 'TO_ARRAY' | 'QUERY' | 'IS_BLANK' | 'IS_NOT_BLANK';
 export declare const scalarExpressionFunctions: Record<ScalarFunctionName, ExpressionFunction>;
 export declare const scalarExpressionFunctionNames: ScalarFunctionName[];