@adaptabletools/adaptable 17.0.0-canary.1 → 17.0.0-canary.11

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

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

package/src/Utilities/ExpressionFunctions/groupingMap.js

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

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.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.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 {};