@qn-pandora/pandora-visualization
Version:
Pandora 通用可视化库
193 lines (192 loc) • 7.62 kB
JavaScript
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
var __spread = (this && this.__spread) || function () {
for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
return ar;
};
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
import _ from 'lodash';
import getMergeValueWithNil from '../../../../utils/getMergeValueWithNil';
function getKeyByBucketValues(bucketIndexs, row) {
return bucketIndexs.map(function (index) { return row[index][0]; }).join('__PVBUCKETCONNECTOR__');
}
function generateArray(length, item) {
var arr = new Array(length);
for (var index = 0; index < arr.length; index++) {
arr[index] = _.cloneDeep(item);
}
return arr;
}
function merge(values, mergeType) {
var hasNumber = values.some(function (value) { return _.isNumber(value); });
switch (mergeType) {
case "max" /* Max */:
return _.max(values);
case "min" /* Min */:
return _.min(values);
case "avg" /* Avg */:
return getMergeValueWithNil(_.mean(values), hasNumber);
case "oldest" /* Oldest */:
return _.last(values);
case "newest" /* Newest */:
return _.first(values);
case "sum" /* Sum */:
default:
return getMergeValueWithNil(_.sum(values), hasNumber);
}
}
function mergeData(values, mergeFunc, index) {
var metricValues = values.map(function (value) { return value[index]; });
return merge(metricValues, mergeFunc);
}
/**
* 合并dataset：只保留选择的buckets和metrics列，buckets取值的组合不唯一时，通过mergeFunc（默认求和）合并。
* 返回的dataset的rows为BasicFieldDataType[][]类型，即忽略了compare
*/
export function mergeDataset(fields, rows, currentMetrics, currentBuckets, mergeFunc) {
var e_1, _a;
if (mergeFunc === void 0) { mergeFunc = "sum" /* Sum */; }
var metricIndexs = currentMetrics
.map(function (currentMetric) {
return fields.findIndex(function (field) { return field.key === currentMetric; });
})
.filter(function (index) { return index !== -1; });
var bucketIndexs = currentBuckets
.map(function (currentBucket) {
return fields.findIndex(function (field) { return field.key === currentBucket; });
})
.filter(function (index) { return index !== -1; });
// 有指标无分组
if (bucketIndexs.length === 0 && metricIndexs.length > 0) {
var mergedFields_1 = [];
var items = metricIndexs.map(function (metricIndex) {
mergedFields_1.push(fields[metricIndex]);
var metricValues = rows.map(function (row) { return row[metricIndex]; });
return [mergeData(metricValues, mergeFunc, 0)];
});
return {
fields: mergedFields_1,
rows: [items]
};
}
// 有分组有指标
if (metricIndexs.length > 0) {
var map_1 = new Map();
// 将bucketValue相同的metricValue合并到一个数组
rows.forEach(function (row) {
var key = getKeyByBucketValues(bucketIndexs, row);
// 只处理了当前值，TODO: 处理compare
metricIndexs.forEach(function (metricIndex, index) {
var metricValue = row[metricIndex];
if (map_1.has(key)) {
map_1.get(key).metricValues[index].push(metricValue);
}
else {
var metricValues = generateArray(metricIndexs.length, []);
metricValues[index].push(metricValue);
map_1.set(key, {
bucketValues: bucketIndexs.map(function (bucketIndex) { return row[bucketIndex]; }),
metricValues: metricValues
});
}
});
});
var resultRows = [];
var _loop_1 = function (bucketValues, metricValues) {
// 将bucketValue相同的metricValue经过统一的运算规则处理。
var resultRow = __spread(bucketValues);
metricValues.forEach(function (values) {
var currentValues = values.map(function (value) { return _.get(value, 0); });
var mergedCurrentValue = merge(currentValues, mergeFunc);
var mergedValue = [mergedCurrentValue];
if (values[0] && values[0].length > 1) {
var compareValues = values.map(function (value) { return _.get(value, 1); });
var mergedCompareValue = merge(compareValues, mergeFunc);
mergedValue.push(mergedCompareValue);
}
resultRow.push(mergedValue);
});
resultRows.push(resultRow);
};
try {
for (var _b = __values(map_1.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read(_c.value, 2), _e = _d[1], bucketValues = _e.bucketValues, metricValues = _e.metricValues;
_loop_1(bucketValues, metricValues);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
return {
fields: bucketIndexs
.map(function (index) { return fields[index]; })
.concat(metricIndexs.map(function (index) { return fields[index]; })),
rows: resultRows
};
}
return {
fields: [],
rows: []
};
}
/**
* 从原始数据中选择需要的数据，减少数据量
*/
export function pickDataset(fields, rows, currentMetrics, currentBuckets, fieldsGetter) {
var fieldIndexMap = compFieldIndexMap(fields);
var otherFieldkeys = (fieldsGetter === null || fieldsGetter === void 0 ? void 0 : fieldsGetter(fields)) || [];
var pickFieldKeys = __spread(currentBuckets, currentMetrics, otherFieldkeys);
var pickFieldIndexs = [];
var pickedFields = [];
pickFieldKeys.forEach(function (item) {
var findObj = fieldIndexMap[item];
if (findObj) {
pickFieldIndexs.push(findObj.index);
pickedFields.push(findObj.field);
}
});
return {
fields: pickedFields,
rows: rows.map(function (row) {
return pickFieldIndexs.map(function (index) { return row[index]; });
})
};
}
// 计算出field 的index
export function compFieldIndexMap(fields) {
return fields.reduce(function (preMap, cur, index) {
preMap[cur.name] = {
index: index,
field: cur
};
return preMap;
}, {});
}