| (function (global, factory) { |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = global || self, factory(global.myTransform = {})); |
| })(this, function (exports) { |
| 'use strict'; |
| |
| var transform = { |
| type: 'myTransform: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 |
| }; |
| } |
| }; |
| var arrayProto = Array.prototype; |
| var nativeForEach = arrayProto.forEach; |
| var nativeSlice = arrayProto.slice; |
| var nativeMap = arrayProto.map; |
| |
| var ctorFunction = function () {}.constructor; |
| |
| var protoFunction = ctorFunction ? ctorFunction.prototype : null; |
| |
| function each(arr, cb, context) { |
| if (!(arr && cb)) { |
| return; |
| } |
| |
| if (arr.forEach && arr.forEach === nativeForEach) { |
| arr.forEach(cb, context); |
| } else if (arr.length === +arr.length) { |
| for (var i = 0, len = arr.length; i < len; i++) { |
| cb.call(context, arr[i], i, arr); |
| } |
| } else { |
| for (var key in arr) { |
| if (arr.hasOwnProperty(key)) { |
| cb.call(context, arr[key], key, arr); |
| } |
| } |
| } |
| } |
| |
| function map(arr, cb, context) { |
| if (!arr) { |
| return []; |
| } |
| |
| if (!cb) { |
| return slice(arr); |
| } |
| |
| if (arr.map && arr.map === nativeMap) { |
| return arr.map(cb, context); |
| } else { |
| var result = []; |
| |
| for (var i = 0, len = arr.length; i < len; i++) { |
| result.push(cb.call(context, arr[i], i, arr)); |
| } |
| |
| return result; |
| } |
| } |
| |
| function bindPolyfill(func, context) { |
| var args = []; |
| |
| for (var _i = 2; _i < arguments.length; _i++) { |
| args[_i - 2] = arguments[_i]; |
| } |
| |
| return function () { |
| return func.apply(context, args.concat(nativeSlice.call(arguments))); |
| }; |
| } |
| |
| var bind = protoFunction && isFunction(protoFunction.bind) ? protoFunction.call.bind(protoFunction.bind) : bindPolyfill; |
| |
| function isFunction(value) { |
| return typeof value === 'function'; |
| } |
| |
| function slice(arr) { |
| var args = []; |
| |
| for (var _i = 1; _i < arguments.length; _i++) { |
| args[_i - 1] = arguments[_i]; |
| } |
| |
| return nativeSlice.apply(arr, args); |
| } |
| |
| 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: 'myTransform: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); |
| } |
| |
| each(collectionDimInfoList, function (dimInfo) { |
| dimInfo.__collectionResult = collectionResult; |
| asc(dimInfo.gatheredValuesNoGroup); |
| each(dimInfo.gatheredValuesByGroup, function (values) { |
| asc(values); |
| }); |
| }); |
| var finalResult = travel(groupByDimInfo, upstream, finalResultDimInfoList, createFinalResultLine, updateFinalResultLine); |
| return { |
| dimensions: map(finalResultDimInfoList, function (item) { |
| return item.name; |
| }), |
| 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 |
| }); |
| }); |
