(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
    typeof define === 'function' && define.amd ? define(['exports'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ecSimpleTransform = {}));
}(this, (function (exports) { 'use strict';

    var transform = {
        type: 'ecSimpleTransform:id',
        transform: function (params) {
            var upstream = params.upstream;
            var config = params.config;
            var dimensionIndex = config.dimensionIndex;
            var dimensionName = config.dimensionName;
            var dimsDef = upstream.cloneAllDimensionInfo();
            dimsDef[dimensionIndex] = dimensionName;
            var data = upstream.cloneRawData();
            for (var i = 0, len = data.length; i < len; i++) {
                var line = data[i];
                line[dimensionIndex] = i;
            }
            return {
                dimensions: dimsDef,
                data: data
            };
        }
    };

    function assert(condition, message) {
        if (!condition) {
            throw new Error(message);
        }
    }
    function hasOwn(own, prop) {
        return own.hasOwnProperty(prop);
    }
    function quantile(ascArr, p) {
        var H = (ascArr.length - 1) * p + 1;
        var h = Math.floor(H);
        var v = +ascArr[h - 1];
        var e = H - h;
        return e ? v + e * (ascArr[h] - v) : v;
    }

    var METHOD_INTERNAL = {
        'SUM': true,
        'COUNT': true,
        'FIRST': true,
        'AVERAGE': true,
        'Q1': true,
        'Q2': true,
        'Q3': true,
        'MIN': true,
        'MAX': true
    };
    var METHOD_NEEDS_COLLECT = {
        AVERAGE: ['COUNT']
    };
    var METHOD_NEEDS_GATHER_VALUES = {
        Q1: true,
        Q2: true,
        Q3: true
    };
    var METHOD_ALIAS = {
        MEDIAN: 'Q2'
    };
    var ResultDimInfoInternal = (function () {
        function ResultDimInfoInternal(index, indexInUpstream, method, name, needGatherValues) {
            this.collectionInfoList = [];
            this.gatheredValuesByGroup = {};
            this.gatheredValuesNoGroup = [];
            this.needGatherValues = false;
            this._collectionInfoMap = {};
            this.method = method;
            this.name = name;
            this.index = index;
            this.indexInUpstream = indexInUpstream;
            this.needGatherValues = needGatherValues;
        }
        ResultDimInfoInternal.prototype.addCollectionInfo = function (item) {
            this._collectionInfoMap[item.method] = this.collectionInfoList.length;
            this.collectionInfoList.push(item);
        };
        ResultDimInfoInternal.prototype.getCollectionInfo = function (method) {
            return this.collectionInfoList[this._collectionInfoMap[method]];
        };
        ResultDimInfoInternal.prototype.gatherValue = function (groupByDimInfo, groupVal, value) {
            value = +value;
            if (groupByDimInfo) {
                if (groupVal != null) {
                    var groupValStr = groupVal + '';
                    var values = this.gatheredValuesByGroup[groupValStr]
                        || (this.gatheredValuesByGroup[groupValStr] = []);
                    values.push(value);
                }
            }
            else {
                this.gatheredValuesNoGroup.push(value);
            }
        };
        return ResultDimInfoInternal;
    }());
    var transform$1 = {
        type: 'ecSimpleTransform:aggregate',
        transform: function (params) {
            var upstream = params.upstream;
            var config = params.config;
            var groupByDimInfo = prepareGroupByDimInfo(config, upstream);
            var _a = prepareDimensions(config, upstream, groupByDimInfo), finalResultDimInfoList = _a.finalResultDimInfoList, collectionDimInfoList = _a.collectionDimInfoList;
            var collectionResult;
            if (collectionDimInfoList.length) {
                collectionResult = travel(groupByDimInfo, upstream, collectionDimInfoList, createCollectionResultLine, updateCollectionResultLine);
            }
            for (var i = 0; i < collectionDimInfoList.length; i++) {
                var dimInfo = collectionDimInfoList[i];
                dimInfo.__collectionResult = collectionResult;
                asc(dimInfo.gatheredValuesNoGroup);
                var gatheredValuesByGroup = dimInfo.gatheredValuesByGroup;
                for (var key in gatheredValuesByGroup) {
                    if (hasOwn(gatheredValuesByGroup, key)) {
                        asc(gatheredValuesByGroup[key]);
                    }
                }
            }
            var finalResult = travel(groupByDimInfo, upstream, finalResultDimInfoList, createFinalResultLine, updateFinalResultLine);
            var dimensions = [];
            for (var i = 0; i < finalResultDimInfoList.length; i++) {
                dimensions.push(finalResultDimInfoList[i].name);
            }
            return {
                dimensions: dimensions,
                data: finalResult.outList
            };
        }
    };
    function prepareDimensions(config, upstream, groupByDimInfo) {
        var resultDimensionsConfig = config.resultDimensions;
        var finalResultDimInfoList = [];
        var collectionDimInfoList = [];
        var gIndexInLine = 0;
        for (var i = 0; i < resultDimensionsConfig.length; i++) {
            var resultDimInfoConfig = resultDimensionsConfig[i];
            var dimInfoInUpstream = upstream.getDimensionInfo(resultDimInfoConfig.from);
            assert(dimInfoInUpstream, 'Can not find dimension by `from`: ' + resultDimInfoConfig.from);
            var rawMethod = resultDimInfoConfig.method;
            assert(groupByDimInfo.index !== dimInfoInUpstream.index || rawMethod == null, "Dimension " + dimInfoInUpstream.name + " is the \"groupBy\" dimension, must not have any \"method\".");
            var method = normalizeMethod(rawMethod);
            assert(method, 'method is required');
            var name_1 = resultDimInfoConfig.name != null ? resultDimInfoConfig.name : dimInfoInUpstream.name;
            var finalResultDimInfo = new ResultDimInfoInternal(finalResultDimInfoList.length, dimInfoInUpstream.index, method, name_1, hasOwn(METHOD_NEEDS_GATHER_VALUES, method));
            finalResultDimInfoList.push(finalResultDimInfo);
            var needCollect = false;
            if (hasOwn(METHOD_NEEDS_COLLECT, method)) {
                needCollect = true;
                var collectionTargetMethods = METHOD_NEEDS_COLLECT[method];
                for (var j = 0; j < collectionTargetMethods.length; j++) {
                    finalResultDimInfo.addCollectionInfo({
                        method: collectionTargetMethods[j],
                        indexInLine: gIndexInLine++
                    });
                }
            }
            if (hasOwn(METHOD_NEEDS_GATHER_VALUES, method)) {
                needCollect = true;
            }
            if (needCollect) {
                collectionDimInfoList.push(finalResultDimInfo);
            }
        }
        return { collectionDimInfoList: collectionDimInfoList, finalResultDimInfoList: finalResultDimInfoList };
    }
    function prepareGroupByDimInfo(config, upstream) {
        var groupByConfig = config.groupBy;
        var groupByDimInfo;
        if (groupByConfig != null) {
            groupByDimInfo = upstream.getDimensionInfo(groupByConfig);
            assert(groupByDimInfo, 'Can not find dimension by `groupBy`: ' + groupByConfig);
        }
        return groupByDimInfo;
    }
    function travel(groupByDimInfo, upstream, resultDimInfoList, doCreate, doUpdate) {
        var outList = [];
        var mapByGroup;
        if (groupByDimInfo) {
            mapByGroup = {};
            for (var dataIndex = 0, len = upstream.count(); dataIndex < len; dataIndex++) {
                var groupByVal = upstream.retrieveValue(dataIndex, groupByDimInfo.index);
                if (groupByVal == null) {
                    continue;
                }
                var groupByValStr = groupByVal + '';
                if (!hasOwn(mapByGroup, groupByValStr)) {
                    var newLine = doCreate(upstream, dataIndex, resultDimInfoList, groupByDimInfo, groupByVal);
                    outList.push(newLine);
                    mapByGroup[groupByValStr] = newLine;
                }
                else {
                    var targetLine = mapByGroup[groupByValStr];
                    doUpdate(upstream, dataIndex, targetLine, resultDimInfoList, groupByDimInfo, groupByVal);
                }
            }
        }
        else {
            var targetLine = doCreate(upstream, 0, resultDimInfoList);
            outList.push(targetLine);
            for (var dataIndex = 1, len = upstream.count(); dataIndex < len; dataIndex++) {
                doUpdate(upstream, dataIndex, targetLine, resultDimInfoList);
            }
        }
        return { mapByGroup: mapByGroup, outList: outList };
    }
    function normalizeMethod(method) {
        if (method == null) {
            return 'FIRST';
        }
        var methodInternal = method.toUpperCase();
        methodInternal = hasOwn(METHOD_ALIAS, methodInternal)
            ? METHOD_ALIAS[methodInternal]
            : methodInternal;
        assert(hasOwn(METHOD_INTERNAL, methodInternal), "Illegal method " + method + ".");
        return methodInternal;
    }
    var createCollectionResultLine = function (upstream, dataIndex, collectionDimInfoList, groupByDimInfo, groupByVal) {
        var newLine = [];
        for (var i = 0; i < collectionDimInfoList.length; i++) {
            var dimInfo = collectionDimInfoList[i];
            var collectionInfoList = dimInfo.collectionInfoList;
            for (var j = 0; j < collectionInfoList.length; j++) {
                var collectionInfo = collectionInfoList[j];
                newLine[collectionInfo.indexInLine] = +lineCreator[collectionInfo.method](upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal);
            }
            if (dimInfo.needGatherValues) {
                var val = upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
                dimInfo.gatherValue(groupByDimInfo, groupByVal, val);
            }
        }
        return newLine;
    };
    var updateCollectionResultLine = function (upstream, dataIndex, targetLine, collectionDimInfoList, groupByDimInfo, groupByVal) {
        for (var i = 0; i < collectionDimInfoList.length; i++) {
            var dimInfo = collectionDimInfoList[i];
            var collectionInfoList = dimInfo.collectionInfoList;
            for (var j = 0; j < collectionInfoList.length; j++) {
                var collectionInfo = collectionInfoList[j];
                var indexInLine = collectionInfo.indexInLine;
                targetLine[indexInLine] = +lineUpdater[collectionInfo.method](targetLine[indexInLine], upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal);
            }
            if (dimInfo.needGatherValues) {
                var val = upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
                dimInfo.gatherValue(groupByDimInfo, groupByVal, val);
            }
        }
    };
    var createFinalResultLine = function (upstream, dataIndex, finalResultDimInfoList, groupByDimInfo, groupByVal) {
        var newLine = [];
        for (var i = 0; i < finalResultDimInfoList.length; i++) {
            var dimInfo = finalResultDimInfoList[i];
            var method = dimInfo.method;
            newLine[i] = isGroupByDimension(groupByDimInfo, dimInfo)
                ? groupByVal
                : lineCreator[method](upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal);
        }
        return newLine;
    };
    var updateFinalResultLine = function (upstream, dataIndex, targetLine, finalResultDimInfoList, groupByDimInfo, groupByVal) {
        for (var i = 0; i < finalResultDimInfoList.length; i++) {
            var dimInfo = finalResultDimInfoList[i];
            if (isGroupByDimension(groupByDimInfo, dimInfo)) {
                continue;
            }
            var method = dimInfo.method;
            targetLine[i] = lineUpdater[method](targetLine[i], upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal);
        }
    };
    function isGroupByDimension(groupByDimInfo, targetDimInfo) {
        return groupByDimInfo && targetDimInfo.indexInUpstream === groupByDimInfo.index;
    }
    function asc(list) {
        list.sort(function (a, b) {
            return a - b;
        });
    }
    var lineCreator = {
        'SUM': function () {
            return 0;
        },
        'COUNT': function () {
            return 1;
        },
        'FIRST': function (upstream, dataIndex, dimInfo) {
            return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
        },
        'MIN': function (upstream, dataIndex, dimInfo) {
            return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
        },
        'MAX': function (upstream, dataIndex, dimInfo) {
            return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
        },
        'AVERAGE': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) {
            var collectLine = groupByDimInfo
                ? dimInfo.__collectionResult.mapByGroup[groupByVal + '']
                : dimInfo.__collectionResult.outList[0];
            return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream)
                / collectLine[dimInfo.getCollectionInfo('COUNT').indexInLine];
        },
        'Q1': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) {
            return lineCreatorForQ(0.25, dimInfo, groupByDimInfo, groupByVal);
        },
        'Q2': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) {
            return lineCreatorForQ(0.5, dimInfo, groupByDimInfo, groupByVal);
        },
        'Q3': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) {
            return lineCreatorForQ(0.75, dimInfo, groupByDimInfo, groupByVal);
        }
    };
    var lineUpdater = {
        'SUM': function (val, upstream, dataIndex, dimInfo) {
            return val + upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream);
        },
        'COUNT': function (val) {
            return val + 1;
        },
        'FIRST': function (val) {
            return val;
        },
        'MIN': function (val, upstream, dataIndex, dimInfo) {
            return Math.min(val, upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream));
        },
        'MAX': function (val, upstream, dataIndex, dimInfo) {
            return Math.max(val, upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream));
        },
        'AVERAGE': function (val, upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) {
            var collectLine = groupByDimInfo
                ? dimInfo.__collectionResult.mapByGroup[groupByVal + '']
                : dimInfo.__collectionResult.outList[0];
            return val
                + upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream)
                    / collectLine[dimInfo.getCollectionInfo('COUNT').indexInLine];
        },
        'Q1': function (val, upstream, dataIndex, dimInfo) {
            return val;
        },
        'Q2': function (val, upstream, dataIndex, dimInfo) {
            return val;
        },
        'Q3': function (val, upstream, dataIndex, dimInfo) {
            return val;
        }
    };
    function lineCreatorForQ(percent, dimInfo, groupByDimInfo, groupByVal) {
        var gatheredValues = groupByDimInfo
            ? dimInfo.gatheredValuesByGroup[groupByVal + '']
            : dimInfo.gatheredValuesNoGroup;
        return quantile(gatheredValues, percent);
    }

    exports.aggregate = transform$1;
    exports.id = transform;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=index.js.map