@adaptabletools/adaptable 11.0.0-canary.5 → 11.0.0

package/src/Utilities/ExpressionFunctions/deepMap.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepMap = void 0;
+const SORT_ASC_REVISION = (p1, p2) => sortAscending(p1.revision, p2.revision);
+class DeepMap {
+    constructor(initial) {
+        this.map = new Map();
+        this.length = 0;
+        this.revision = 0;
+        this.visit = (fn) => {
+            this.map.forEach((_, k) => this.visitKey(k, this.map, [], fn));
+        };
+        this.visitDepthFirst = (fn) => {
+            this.visitWithNext([], fn);
+        };
+        this.visitWithNext = (parentKeys, fn, currentMap = this.map) => {
+            if (!currentMap) {
+                return;
+            }
+            let i = 0;
+            currentMap.forEach((_, key) => {
+                const pair = currentMap.get(key);
+                if (!pair) {
+                    return;
+                }
+                const { map } = pair;
+                const keys = [...parentKeys, key];
+                const next = map ? () => this.visitWithNext(keys, fn, map) : undefined;
+                if (pair.hasOwnProperty('value')) {
+                    fn(pair.value, keys, i, next);
+                    i++;
+                }
+                else {
+                    next === null || next === void 0 ? void 0 : next();
+                }
+            });
+        };
+        if (initial) {
+            initial.forEach((entry) => {
+                const [keys, value] = entry;
+                this.set(keys, value);
+            });
+        }
+    }
+    static clone(map) {
+        const clone = new DeepMap();
+        map.visit((pair, keys) => {
+            clone.set(keys, pair.value);
+        });
+        return clone;
+    }
+    set(keys, value) {
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot set given keys - please provide a non-empty keys array.`;
+            // currentMap.set((EMPTY_KEY as unknown) as K, { value });
+            // this.length++;
+            // return this;
+        }
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                const pair = currentMap.has(key) ? currentMap.get(key) : {};
+                pair.revision = this.revision++;
+                pair.value = value;
+                currentMap.set(key, pair);
+                this.length++;
+            }
+            else {
+                const pair = currentMap.has(key) ? currentMap.get(key) : {};
+                if (!pair.map) {
+                    pair.map = new Map();
+                    currentMap.set(key, pair);
+                }
+                currentMap = pair.map;
+            }
+        }
+        return this;
+    }
+    get(keys) {
+        var _a;
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot get given keys - please provide a non-empty keys array.`;
+            // return currentMap.get((EMPTY_KEY as unknown) as K)?.value;
+        }
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                return (_a = currentMap.get(key)) === null || _a === void 0 ? void 0 : _a.value;
+            }
+            else {
+                const pair = currentMap.get(key);
+                if (!pair || !pair.map) {
+                    return;
+                }
+                currentMap = pair.map;
+            }
+        }
+        return;
+    }
+    get size() {
+        return this.length;
+    }
+    clear() {
+        const clearMap = (map) => {
+            map.forEach((value, _key) => {
+                const { map } = value;
+                if (map) {
+                    clearMap(map);
+                }
+            });
+            map.clear();
+        };
+        clearMap(this.map);
+        this.length = 0;
+        this.revision = 0;
+    }
+    delete(keys) {
+        keys = [...keys];
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot delete given keys - please provide a non-empty keys array.`;
+            // if (currentMap.has(EMPTY_KEY as unknown as K)) {
+            //   this.length--;
+            // }
+            // return currentMap.delete((EMPTY_KEY as unknown) as K);
+        }
+        let maps = [currentMap];
+        let result = false;
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                const pair = currentMap.get(key);
+                if (pair) {
+                    if (pair.hasOwnProperty('value')) {
+                        delete pair.value;
+                        delete pair.revision;
+                        result = true;
+                        this.length--;
+                    }
+                    if (pair.map && pair.map.size === 0) {
+                        delete pair.map;
+                    }
+                    if (!pair.map) {
+                        // pair is empty, so we can remove it altogether
+                        currentMap.delete(key);
+                    }
+                }
+                break;
+            }
+            else {
+                const pair = currentMap.get(key);
+                if (!pair || !pair.map) {
+                    result = false;
+                    break;
+                }
+                currentMap = pair.map;
+                maps.push(currentMap);
+            }
+        }
+        while (maps.length) {
+            let map = maps.pop();
+            let key = keys.pop();
+            if (key && (map === null || map === void 0 ? void 0 : map.size) === 0) {
+                let parentMap = maps[maps.length - 1];
+                let pair = parentMap === null || parentMap === void 0 ? void 0 : parentMap.get(key);
+                if (pair) {
+                    // pair.map === map ; which can be deleted
+                    delete pair.map;
+                    if (!pair.hasOwnProperty('value')) {
+                        // whole pair can be successfully deleted from parentMap
+                        parentMap.delete(key);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    has(keys) {
+        let currentMap = this.map;
+        if (!keys.length) {
+            throw `Cannot find existing given keys - please provide a non-empty keys array.`;
+            // return (
+            //   currentMap.has((EMPTY_KEY as unknown) as K) &&
+            //   currentMap.get((EMPTY_KEY as unknown) as K)?.value !== undefined
+            // );
+        }
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const last = i === len - 1;
+            if (last) {
+                const pair = currentMap.get(key);
+                return !!pair && pair.hasOwnProperty('value');
+            }
+            else {
+                const pair = currentMap.get(key);
+                if (!pair || !pair.map) {
+                    return false;
+                }
+                currentMap = pair.map;
+            }
+        }
+        return false;
+    }
+    visitKey(key, currentMap, parentKeys, fn) {
+        const pair = currentMap.get(key);
+        if (!pair) {
+            return;
+        }
+        const { map } = pair;
+        const keys = [...parentKeys, key];
+        const next = once(() => {
+            if (map) {
+                map.forEach((_, k) => {
+                    this.visitKey(k, map, keys, fn);
+                });
+            }
+        });
+        if (pair.hasOwnProperty('value')) {
+            fn(pair, keys, next);
+        }
+        // if it was called by fn, it won't be called again, as it's once-d
+        next();
+    }
+    getArray(fn) {
+        const result = [];
+        this.visit((pair, keys) => {
+            result.push(fn(Object.assign(Object.assign({}, pair), { keys })));
+        });
+        return result;
+    }
+    values() {
+        return this.sortedIterator((pair) => pair.value);
+    }
+    keys() {
+        const keys = this.sortedIterator((pair) => pair.keys);
+        return keys;
+    }
+    entries() {
+        return this.sortedIterator((pair) => [pair.keys, pair.value]);
+    }
+    topDownEntries() {
+        return this.getArray((pair) => [pair.keys, pair.value]);
+    }
+    topDownKeys() {
+        return this.getArray((pair) => pair.keys);
+    }
+    topDownValues() {
+        return this.getArray((pair) => pair.value);
+    }
+    sortedIterator(fn) {
+        const result = [];
+        this.visit((pair, keys) => {
+            result.push(Object.assign(Object.assign({}, pair), { keys }));
+        });
+        result.sort(SORT_ASC_REVISION);
+        function* makeIterator() {
+            for (let i = 0, len = result.length; i < len; i++) {
+                yield fn(result[i]);
+            }
+        }
+        return makeIterator();
+    }
+}
+exports.DeepMap = DeepMap;
+function once(fn) {
+    let called = false;
+    let result = null;
+    const onceFn = () => {
+        if (called) {
+            return result;
+        }
+        called = true;
+        result = fn();
+        return result;
+    };
+    return onceFn;
+}
+const sortAscending = (a, b) => a - b;

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

@@ -14,8 +14,8 @@ export declare const getStringValue: (context: ExpressionContext, stringArgument
 export declare const isTextSearchCaseInsensitive: (context: ExpressionContext) => boolean;
 export declare const getDataChangeLog$: (context: ExpressionContext, columnNameFilter: string) => Observable<DataChangedInfo>;
 export declare const handleWhereFunction: (args: any[], context: ExpressionContext) => any;
-export declare const extractColumnParameter: (consumingFunctionName: string, args: BaseParameter[], validateType?: 'number') => ColumnParameter;
-export declare const extractParameter: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: string, allowedOperands: string[], args?: BaseParameter[]) => T;
+export declare const extractColumnParameter: (consumingFunctionName: string, args: BaseParameter[]) => ColumnParameter;
+export declare const extractParameter: <T extends BaseParameter<string, string>>(consumingFunctionName: string, allowedType: T["type"], allowedOperands: T["name"][], args: BaseParameter[], isOptional?: boolean) => T;
 export declare const handleColumnFunction: (args: any[], context: ExpressionContext) => ColumnParameter;
 export declare const getNumericValue: (input: unknown) => number;
 export declare const validateColumnType: (columnId: string, validColumnTypes: ('Number' | 'String' | 'Date')[], consumingFunction: string, api: AdaptableApi) => void;

package/src/Utilities/ExpressionFunctions/expressionFunctionUtils.js

@@ -49,19 +49,19 @@ exports.handleWhereFunction = (args, context) => {
         filterFn,
     });
 };
-exports.extractColumnParameter = (consumingFunctionName, args, validateType) => {
-    const result = exports.extractParameter(consumingFunctionName, 'config', ['COL'], args);
-    if (validateType) {
-    }
-    return result;
+exports.extractColumnParameter = (consumingFunctionName, args) => {
+    return exports.extractParameter(consumingFunctionName, 'config', ['COL'], args);
 };
-exports.extractParameter = (consumingFunctionName, allowedType, allowedOperands, args = []) => {
+exports.extractParameter = (consumingFunctionName, allowedType, allowedOperands, args, isOptional) => {
     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 > 1) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects only 1 argument of type '${[...new Set(result.map((op) => op.name))].join(' / ')}'`);
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects only 1 argument of type '${[...new Set(result.map((op) => op.name))].join(`' / '`)}'`);
     }
     if (!result.length) {
-        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects an argument of type '${allowedOperands.join(' / ')}'`);
+        throw new ExpressionEvaluationError_1.ExpressionEvaluationError(consumingFunctionName, `expects an argument of type '${allowedOperands.join(`' / '`)}'`);
     }
     return result[0];
 };

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

@@ -0,0 +1,35 @@
+import { DeepMap } from './deepMap';
+export declare type GroupKeyType<T extends any = any> = T;
+export declare type GroupBy<DataType, KeyType> = {
+    field: keyof DataType;
+    toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
+};
+export declare type GroupParams<DataType, KeyType> = {
+    groupBy: GroupBy<DataType, KeyType>[];
+    defaultToKey?: (value: any, item: DataType) => GroupKeyType<KeyType>;
+    reducers?: Record<string, DataSourceAggregationReducer<DataType, any>>;
+};
+export declare type DataSourceAggregationReducer<T, AggregationResultType> = {
+    name?: string;
+    field?: keyof T;
+    initialValue?: AggregationResultType;
+    getter?: (data: T) => any;
+    reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
+    done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
+};
+export declare type DataGroupResult<DataType, KeyType extends any> = {
+    deepMap: DeepMap<GroupKeyType<KeyType>, DeepMapGroupValueType<DataType, KeyType>>;
+    groupParams: GroupParams<DataType, KeyType>;
+    initialData: DataType[];
+    reducerResults?: Record<string, any>;
+};
+export declare type DeepMapGroupValueType<DataType, KeyType> = {
+    items: DataType[];
+    commonData?: Partial<DataType>;
+    reducerResults: Record<string, any>;
+};
+export declare type AggregationReducerResult<AggregationResultType extends any = any> = {
+    value: AggregationResultType;
+    id: string;
+};
+export declare function group<DataType, KeyType = any>(groupParams: GroupParams<DataType, KeyType>, data: DataType[]): DataGroupResult<DataType, KeyType>;

package/src/Utilities/ExpressionFunctions/groupingMap.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.group = void 0;
+const deepMap_1 = require("./deepMap");
+function DEFAULT_TO_KEY(value) {
+    return value;
+}
+function group(groupParams, data) {
+    const { groupBy, defaultToKey = DEFAULT_TO_KEY, reducers } = groupParams;
+    const groupByLength = groupBy.length;
+    const deepMap = new deepMap_1.DeepMap();
+    let currentGroupKeys = [];
+    const initialReducerValue = initReducers(reducers);
+    const globalReducerResults = Object.assign({}, initialReducerValue);
+    for (let i = 0, len = data.length; i < len; i++) {
+        let item = data[i];
+        for (let groupByIndex = 0; groupByIndex < groupByLength; groupByIndex++) {
+            const { field: groupByProperty, toKey: groupToKey } = groupBy[groupByIndex];
+            const key = (groupToKey || defaultToKey)(item[groupByProperty], item);
+            currentGroupKeys.push(key);
+            if (!deepMap.has(currentGroupKeys)) {
+                const deepMapGroupValue = {
+                    items: [],
+                    reducerResults: Object.assign({}, initialReducerValue),
+                };
+                deepMap.set(currentGroupKeys, deepMapGroupValue);
+            }
+            const { items: currentGroupItems, reducerResults } = deepMap.get(currentGroupKeys);
+            currentGroupItems.push(item);
+            if (reducers) {
+                computeReducersFor(item, reducers, reducerResults);
+            }
+        }
+        if (reducers) {
+            computeReducersFor(item, reducers, globalReducerResults);
+        }
+        currentGroupKeys.length = 0;
+    }
+    const hasReducersWithDoneFn = reducers && Object.values(reducers).some((reducer) => reducer.done);
+    if (hasReducersWithDoneFn) {
+        deepMap.visitDepthFirst((deepMapValue, _keys, _indexInGroup, next) => {
+            completeReducers(reducers, deepMapValue.reducerResults, deepMapValue.items);
+            next === null || next === void 0 ? void 0 : next();
+        });
+    }
+    if (hasReducersWithDoneFn) {
+        completeReducers(reducers, globalReducerResults, data);
+    }
+    const result = {
+        deepMap,
+        groupParams,
+        initialData: data,
+        reducerResults: globalReducerResults,
+    };
+    return result;
+}
+exports.group = group;
+function initReducers(reducers) {
+    if (!reducers || !Object.keys(reducers).length) {
+        return {};
+    }
+    const result = {};
+    for (let key in reducers)
+        if (reducers.hasOwnProperty(key)) {
+            result[key] = reducers[key].initialValue;
+        }
+    return result;
+}
+/**
+ *
+ * This fn mutates the reducerResults array!!!
+ *
+ * @param data data item
+ * @param reducers an array of reducers
+ * @param reducerResults the results on which to operate
+ *
+ */
+function computeReducersFor(data, reducers, reducerResults) {
+    var _a, _b;
+    if (!reducers || !Object.keys(reducers).length) {
+        return;
+    }
+    for (let key in reducers)
+        if (reducers.hasOwnProperty(key)) {
+            const reducer = reducers[key];
+            if (typeof reducer.reducer !== 'function') {
+                continue;
+            }
+            const currentValue = reducerResults[key];
+            const value = reducer.field ? data[reducer.field] : (_b = (_a = reducer.getter) === null || _a === void 0 ? void 0 : _a.call(reducer, data)) !== null && _b !== void 0 ? _b : null;
+            reducerResults[key] = reducer.reducer(currentValue, value, data);
+        }
+}
+function completeReducers(reducers, reducerResults, items) {
+    if (reducers) {
+        for (let key in reducers)
+            if (reducers.hasOwnProperty(key)) {
+                const reducer = reducers[key];
+                if (reducer.done) {
+                    reducerResults[key] = reducer.done(reducerResults[key], items);
+                }
+            }
+    }
+    return reducerResults;
+}

package/src/Utilities/ExpressionFunctions/observableExpressionFunctions.js

@@ -105,7 +105,7 @@ exports.observableExpressionFunctions = {
         handler(args, context) {
             return expressionFunctionUtils_1.handleColumnFunction(args, context);
         },
-        description: 'References a grid column by name',
+        description: 'References a column by its unique identifier',
         signatures: ['[colName]', 'COL(name: string)'],
         examples: ['[col1]', "COL('col1')"],
     },
@@ -417,7 +417,8 @@ const getSlidingTimeframe$ = (source$, timeframeDuration, onTimeframeEnter, onTi
     }));
 };
 const getMaxTimeframeSize = (expressionValue, context) => {
-    let maxTimeframeSize = context.api.internalApi.getAdaptableOptions().queryLanguageOptions.maxTimeframeSize;
+    let maxTimeframeSize = context.api.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
+        .maxTimeframeSize;
     if (maxTimeframeSize > SYSTEM_MAX_TIMEFRAME_SIZE) {
         maxTimeframeSize = SYSTEM_MAX_TIMEFRAME_SIZE;
     }

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

@@ -0,0 +1,33 @@
+import { DeepMap } from './deepMap';
+export declare type GroupKeyType<T extends any = any> = T;
+export declare type GroupBy<DataType, KeyType> = {
+    field: keyof DataType & string;
+    toKey?: (value: any, data: DataType) => GroupKeyType<KeyType>;
+};
+export declare 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> = {
+    name?: string;
+    field?: keyof T & string;
+    initialValue?: AggregationResultType;
+    getter?: (data: T) => any;
+    reducer: string | ((accumulator: any, value: any, data: T) => AggregationResultType | any);
+    done?: (accumulatedValue: AggregationResultType | any, array: T[]) => AggregationResultType;
+};
+export declare 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> = {
+    items: DataType[];
+    commonData?: Partial<DataType>;
+    reducerResults: Record<string, AggregationReducerResult>;
+};
+export declare type AggregationReducerResult = number;
+export declare function aggregate<DataType, KeyType = any>(aggregateParams: AggregateParams<DataType, KeyType>, data: DataType[]): DataAggregationResult<DataType, KeyType>;
+export declare function cumulate<DataType, KeyType = any>(aggregateParams: AggregateParams<DataType, KeyType>, data: DataType[]): DataAggregationResult<DataType, KeyType>;

package/src/Utilities/ExpressionFunctions/scalarAggregationHelper.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cumulate = exports.aggregate = void 0;
+const deepMap_1 = require("./deepMap");
+function DEFAULT_TO_KEY(value) {
+    return value;
+}
+function aggregate(aggregateParams, data) {
+    const { groupBy = [], defaultToKey = DEFAULT_TO_KEY, reducers } = aggregateParams;
+    const groupByLength = groupBy.length;
+    const deepMap = new deepMap_1.DeepMap();
+    let currentGroupKeys = [];
+    const initialReducerValue = initReducers(reducers);
+    const globalReducerResults = Object.assign({}, initialReducerValue);
+    for (let i = 0, len = data.length; i < len; i++) {
+        let item = data[i];
+        for (let groupByIndex = 0; groupByIndex < groupByLength; groupByIndex++) {
+            const { field: groupByProperty, toKey: groupToKey } = groupBy[groupByIndex];
+            const key = (groupToKey || defaultToKey)(item[groupByProperty], item);
+            currentGroupKeys.push(key);
+            if (!deepMap.has(currentGroupKeys)) {
+                const deepMapGroupValue = {
+                    items: [],
+                    reducerResults: Object.assign({}, initialReducerValue),
+                };
+                deepMap.set(currentGroupKeys, deepMapGroupValue);
+            }
+            const { items: currentGroupItems, reducerResults } = deepMap.get(currentGroupKeys);
+            currentGroupItems.push(item);
+            if (reducers) {
+                computeReducersFor(item, reducers, reducerResults);
+            }
+        }
+        if (reducers) {
+            computeReducersFor(item, reducers, globalReducerResults);
+        }
+        currentGroupKeys.length = 0;
+    }
+    if (reducers) {
+        deepMap.visitDepthFirst((deepMapValue, _keys, _indexInGroup, next) => {
+            completeReducers(reducers, deepMapValue.reducerResults, deepMapValue.items);
+            next === null || next === void 0 ? void 0 : next();
+        });
+    }
+    if (reducers) {
+        completeReducers(reducers, globalReducerResults, data);
+    }
+    const result = {
+        deepMap,
+        aggregateParams,
+        initialData: data,
+        reducerResults: globalReducerResults,
+    };
+    return result;
+}
+exports.aggregate = aggregate;
+function cumulate(aggregateParams, data) {
+    const { groupBy = [], defaultToKey = DEFAULT_TO_KEY, reducers } = aggregateParams;
+    const groupByLength = groupBy.length;
+    const deepMap = new deepMap_1.DeepMap();
+    let currentGroupKeys = [];
+    let initialReducerValue = initReducers(reducers);
+    const globalReducerResults = Object.assign({}, initialReducerValue);
+    for (let i = 0, len = data.length; i < len; i++) {
+        let item = data[i];
+        for (let groupByIndex = 0; groupByIndex < groupByLength; groupByIndex++) {
+            const { field: groupByProperty, toKey: groupToKey } = groupBy[groupByIndex];
+            const key = (groupToKey || defaultToKey)(item[groupByProperty], item);
+            currentGroupKeys.push(key);
+            if (!deepMap.has(currentGroupKeys)) {
+                const deepMapGroupValue = {
+                    items: [],
+                    reducerResults: Object.assign({}, initialReducerValue),
+                };
+                deepMap.set(currentGroupKeys, deepMapGroupValue);
+            }
+            const { items: currentGroupItems, reducerResults } = deepMap.get(currentGroupKeys);
+            currentGroupItems.push(item);
+            if (reducers) {
+                computeReducersFor(item, reducers, reducerResults);
+            }
+        }
+        if (reducers) {
+            computeReducersFor(item, reducers, globalReducerResults);
+        }
+        initialReducerValue = Object.assign({}, deepMap.get(currentGroupKeys).reducerResults);
+        currentGroupKeys.length = 0;
+    }
+    if (reducers) {
+        deepMap.visitDepthFirst((deepMapValue, _keys, _indexInGroup, next) => {
+            completeReducers(reducers, deepMapValue.reducerResults, deepMapValue.items);
+            next === null || next === void 0 ? void 0 : next();
+        });
+    }
+    if (reducers) {
+        completeReducers(reducers, globalReducerResults, data);
+    }
+    const result = {
+        deepMap,
+        aggregateParams,
+        initialData: data,
+        reducerResults: globalReducerResults,
+    };
+    return result;
+}
+exports.cumulate = cumulate;
+function initReducers(reducers) {
+    if (!reducers || !Object.keys(reducers).length) {
+        return {};
+    }
+    const result = {};
+    for (let key in reducers)
+        if (reducers.hasOwnProperty(key)) {
+            result[key] = reducers[key].initialValue;
+        }
+    return result;
+}
+/**
+ *
+ * This fn mutates the reducerResults array!!!
+ *
+ * @param data data item
+ * @param reducers an array of reducers
+ * @param reducerResults the results on which to operate
+ *
+ */
+function computeReducersFor(data, reducers, reducerResults) {
+    var _a, _b;
+    if (!reducers || !Object.keys(reducers).length) {
+        return;
+    }
+    for (let key in reducers)
+        if (reducers.hasOwnProperty(key)) {
+            const reducer = reducers[key];
+            if (typeof reducer.reducer !== 'function') {
+                continue;
+            }
+            const currentValue = reducerResults[key];
+            const value = reducer.field ? data[reducer.field] : (_b = (_a = reducer.getter) === null || _a === void 0 ? void 0 : _a.call(reducer, data)) !== null && _b !== void 0 ? _b : null;
+            reducerResults[key] = reducer.reducer(currentValue, value, data);
+        }
+}
+function completeReducers(reducers, reducerResults, items) {
+    if (reducers) {
+        for (let key in reducers)
+            if (reducers.hasOwnProperty(key)) {
+                const reducer = reducers[key];
+                if (reducer.done) {
+                    reducerResults[key] = reducer.done(reducerResults[key], items);
+                }
+            }
+    }
+    return reducerResults;
+}