1487 lines
45 KiB
JavaScript
1487 lines
45 KiB
JavaScript
'use strict';
|
|
|
|
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
|
|
|
var constants = require('./constants');
|
|
var utils = require('./utils');
|
|
var utilsLite = require('utils-lite');
|
|
var Core = _interopDefault(require('./core'));
|
|
|
|
var defineProperty = function (obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
var _extends = Object.assign || function (target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
|
|
for (var key in source) {
|
|
if (Object.prototype.hasOwnProperty.call(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return target;
|
|
};
|
|
|
|
// default opacity of bar while dim-axis type is 'value'
|
|
var VALUE_AXIS_OPACITY = 0.5;
|
|
|
|
function getBarDimAxis(args) {
|
|
var innerRows = args.innerRows,
|
|
dimAxisName = args.dimAxisName,
|
|
dimension = args.dimension,
|
|
axisVisible = args.axisVisible,
|
|
dimAxisType = args.dimAxisType,
|
|
dims = args.dims;
|
|
|
|
return dimension.map(function (item) {
|
|
return {
|
|
type: 'category',
|
|
name: dimAxisName,
|
|
nameLocation: 'middle',
|
|
nameGap: 22,
|
|
data: dimAxisType === 'value' ? getValueAxisData(dims) : innerRows.map(function (row) {
|
|
return row[item];
|
|
}),
|
|
axisLabel: {
|
|
formatter: function formatter(v) {
|
|
return String(v);
|
|
}
|
|
},
|
|
show: axisVisible
|
|
};
|
|
});
|
|
}
|
|
|
|
function getValueAxisData(dims) {
|
|
var max = Math.max.apply(null, dims);
|
|
var min = Math.min.apply(null, dims);
|
|
var result = [];
|
|
for (var i = min; i <= max; i++) {
|
|
result.push(i);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function getBarMeaAxis(args) {
|
|
var meaAxisName = args.meaAxisName,
|
|
meaAxisType = args.meaAxisType,
|
|
axisVisible = args.axisVisible,
|
|
digit = args.digit,
|
|
scale = args.scale,
|
|
min = args.min,
|
|
max = args.max;
|
|
|
|
var meaAxisBase = {
|
|
type: 'value',
|
|
axisTick: {
|
|
show: false
|
|
},
|
|
show: axisVisible
|
|
};
|
|
var meaAxis = [];
|
|
|
|
var _loop = function _loop(i) {
|
|
if (meaAxisType[i]) {
|
|
meaAxis[i] = _extends({}, meaAxisBase, {
|
|
axisLabel: {
|
|
formatter: function formatter(val) {
|
|
return utils.getFormated(val, meaAxisType[i], digit);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
meaAxis[i] = _extends({}, meaAxisBase);
|
|
}
|
|
meaAxis[i].name = meaAxisName[i] || '';
|
|
meaAxis[i].scale = scale[i] || false;
|
|
meaAxis[i].min = min[i] || null;
|
|
meaAxis[i].max = max[i] || null;
|
|
};
|
|
|
|
for (var i = 0; i < 2; i++) {
|
|
_loop(i);
|
|
}
|
|
|
|
return meaAxis;
|
|
}
|
|
|
|
function getBarTooltip(args) {
|
|
var axisSite = args.axisSite,
|
|
isHistogram = args.isHistogram,
|
|
meaAxisType = args.meaAxisType,
|
|
digit = args.digit,
|
|
labelMap = args.labelMap;
|
|
|
|
var secondAxis = isHistogram ? axisSite.right || [] : axisSite.top || [];
|
|
if (labelMap) {
|
|
secondAxis = secondAxis.map(function (item) {
|
|
return labelMap[item] === undefined ? item : labelMap[item];
|
|
});
|
|
}
|
|
return {
|
|
trigger: 'axis',
|
|
formatter: function formatter(items) {
|
|
var tpl = [];
|
|
tpl.push(items[0].name + '<br>');
|
|
items.forEach(function (item) {
|
|
var seriesName = item.seriesName;
|
|
var type = ~secondAxis.indexOf(seriesName) ? meaAxisType[1] : meaAxisType[0];
|
|
tpl.push(constants.itemPoint(item.color));
|
|
tpl.push(seriesName + ': ');
|
|
tpl.push(utils.getFormated(item.value, type, digit));
|
|
tpl.push('<br>');
|
|
});
|
|
|
|
return tpl.join('');
|
|
}
|
|
};
|
|
}
|
|
|
|
function getValueData(seriesTemp, dims) {
|
|
var max = Math.max.apply(null, dims);
|
|
var min = Math.min.apply(null, dims);
|
|
var result = [];
|
|
for (var i = min; i <= max; i++) {
|
|
var index = dims.indexOf(i);
|
|
if (~index) {
|
|
result.push(seriesTemp[index]);
|
|
} else {
|
|
result.push(null);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function getBarSeries(args) {
|
|
var innerRows = args.innerRows,
|
|
metrics = args.metrics,
|
|
stack = args.stack,
|
|
axisSite = args.axisSite,
|
|
isHistogram = args.isHistogram,
|
|
labelMap = args.labelMap,
|
|
itemStyle = args.itemStyle,
|
|
label = args.label,
|
|
_args$showLine = args.showLine,
|
|
showLine = _args$showLine === undefined ? [] : _args$showLine,
|
|
dimAxisType = args.dimAxisType,
|
|
barGap = args.barGap,
|
|
opacity = args.opacity,
|
|
dims = args.dims;
|
|
|
|
var series = [];
|
|
var seriesTemp = {};
|
|
var secondAxis = isHistogram ? axisSite.right || [] : axisSite.top || [];
|
|
var secondDimAxisIndex = isHistogram ? 'yAxisIndex' : 'xAxisIndex';
|
|
var stackMap = stack && utils.getStackMap(stack);
|
|
metrics.forEach(function (item) {
|
|
seriesTemp[item] = [];
|
|
});
|
|
innerRows.forEach(function (row) {
|
|
metrics.forEach(function (item) {
|
|
seriesTemp[item].push(row[item]);
|
|
});
|
|
});
|
|
series = Object.keys(seriesTemp).map(function (item, index) {
|
|
var data = dimAxisType === 'value' ? getValueData(seriesTemp[item], dims) : seriesTemp[item];
|
|
var seriesItem = defineProperty({
|
|
name: labelMap[item] != null ? labelMap[item] : item,
|
|
type: ~showLine.indexOf(item) ? 'line' : 'bar',
|
|
data: data
|
|
}, secondDimAxisIndex, ~secondAxis.indexOf(item) ? '1' : '0');
|
|
|
|
if (stack && stackMap[item]) seriesItem.stack = stackMap[item];
|
|
|
|
if (label) seriesItem.label = label;
|
|
if (itemStyle) seriesItem.itemStyle = itemStyle;
|
|
|
|
var itemOpacity = opacity || utilsLite.get(seriesItem, 'itemStyle.normal.opacity');
|
|
if (dimAxisType === 'value') {
|
|
seriesItem.barGap = barGap;
|
|
seriesItem.barCategoryGap = '1%';
|
|
if (itemOpacity == null) itemOpacity = VALUE_AXIS_OPACITY;
|
|
}
|
|
|
|
if (itemOpacity != null) {
|
|
utilsLite.set(seriesItem, 'itemStyle.normal.opacity', itemOpacity);
|
|
}
|
|
|
|
return seriesItem;
|
|
});
|
|
|
|
return series.length ? series : false;
|
|
}
|
|
|
|
function getLegend(args) {
|
|
var metrics = args.metrics,
|
|
labelMap = args.labelMap,
|
|
legendName = args.legendName;
|
|
|
|
if (!legendName && !labelMap) return { data: metrics };
|
|
var data = labelMap ? metrics.map(function (item) {
|
|
return labelMap[item] == null ? item : labelMap[item];
|
|
}) : metrics;
|
|
return {
|
|
data: data,
|
|
formatter: function formatter(name) {
|
|
return legendName[name] != null ? legendName[name] : name;
|
|
}
|
|
};
|
|
}
|
|
|
|
function getDims(rows, dimension) {
|
|
return rows.map(function (row) {
|
|
return row[dimension[0]];
|
|
});
|
|
}
|
|
|
|
var bar = function bar(columns, rows, settings, extra) {
|
|
var innerRows = utilsLite.cloneDeep(rows);
|
|
var _settings$axisSite = settings.axisSite,
|
|
axisSite = _settings$axisSite === undefined ? {} : _settings$axisSite,
|
|
_settings$dimension = settings.dimension,
|
|
dimension = _settings$dimension === undefined ? [columns[0]] : _settings$dimension,
|
|
_settings$stack = settings.stack,
|
|
stack = _settings$stack === undefined ? {} : _settings$stack,
|
|
_settings$axisVisible = settings.axisVisible,
|
|
axisVisible = _settings$axisVisible === undefined ? true : _settings$axisVisible,
|
|
_settings$digit = settings.digit,
|
|
digit = _settings$digit === undefined ? 2 : _settings$digit,
|
|
_settings$dataOrder = settings.dataOrder,
|
|
dataOrder = _settings$dataOrder === undefined ? false : _settings$dataOrder,
|
|
_settings$scale = settings.scale,
|
|
scale = _settings$scale === undefined ? [false, false] : _settings$scale,
|
|
_settings$min = settings.min,
|
|
min = _settings$min === undefined ? [null, null] : _settings$min,
|
|
_settings$max = settings.max,
|
|
max = _settings$max === undefined ? [null, null] : _settings$max,
|
|
_settings$legendName = settings.legendName,
|
|
legendName = _settings$legendName === undefined ? {} : _settings$legendName,
|
|
_settings$labelMap = settings.labelMap,
|
|
labelMap = _settings$labelMap === undefined ? {} : _settings$labelMap,
|
|
label = settings.label,
|
|
itemStyle = settings.itemStyle,
|
|
showLine = settings.showLine,
|
|
_settings$barGap = settings.barGap,
|
|
barGap = _settings$barGap === undefined ? '-100%' : _settings$barGap,
|
|
opacity = settings.opacity;
|
|
var tooltipVisible = extra.tooltipVisible,
|
|
legendVisible = extra.legendVisible;
|
|
|
|
var metrics = columns.slice();
|
|
if (axisSite.top && axisSite.bottom) {
|
|
metrics = axisSite.top.concat(axisSite.bottom);
|
|
} else if (axisSite.bottom && !axisSite.right) {
|
|
metrics = axisSite.bottom;
|
|
} else if (settings.metrics) {
|
|
metrics = settings.metrics;
|
|
} else {
|
|
metrics.splice(columns.indexOf(dimension[0]), 1);
|
|
}
|
|
var meaAxisType = settings.xAxisType || ['normal', 'normal'];
|
|
var dimAxisType = settings.yAxisType || 'category';
|
|
var meaAxisName = settings.xAxisName || [];
|
|
var dimAxisName = settings.yAxisName || '';
|
|
var isHistogram = false;
|
|
|
|
if (dataOrder) {
|
|
var _label = dataOrder.label,
|
|
order = dataOrder.order;
|
|
|
|
if (!_label || !order) {
|
|
console.warn('Need to provide name and order parameters');
|
|
} else {
|
|
innerRows.sort(function (a, b) {
|
|
if (order === 'desc') {
|
|
return a[_label] - b[_label];
|
|
} else {
|
|
return b[_label] - a[_label];
|
|
}
|
|
});
|
|
}
|
|
}
|
|
var dims = getDims(innerRows, dimension);
|
|
|
|
var legend = legendVisible && getLegend({ metrics: metrics, labelMap: labelMap, legendName: legendName });
|
|
var yAxis = getBarDimAxis({
|
|
innerRows: innerRows,
|
|
dimAxisName: dimAxisName,
|
|
dimension: dimension,
|
|
axisVisible: axisVisible,
|
|
dimAxisType: dimAxisType,
|
|
dims: dims
|
|
});
|
|
var xAxis = getBarMeaAxis({
|
|
meaAxisName: meaAxisName,
|
|
meaAxisType: meaAxisType,
|
|
axisVisible: axisVisible,
|
|
digit: digit,
|
|
scale: scale,
|
|
min: min,
|
|
max: max
|
|
});
|
|
var series = getBarSeries({
|
|
innerRows: innerRows,
|
|
metrics: metrics,
|
|
stack: stack,
|
|
axisSite: axisSite,
|
|
isHistogram: isHistogram,
|
|
labelMap: labelMap,
|
|
itemStyle: itemStyle,
|
|
label: label,
|
|
showLine: showLine,
|
|
dimAxisType: dimAxisType,
|
|
dimension: dimension,
|
|
barGap: barGap,
|
|
opacity: opacity,
|
|
dims: dims
|
|
});
|
|
var tooltipParams = { axisSite: axisSite, isHistogram: isHistogram, meaAxisType: meaAxisType, digit: digit, labelMap: labelMap };
|
|
var tooltip = tooltipVisible && getBarTooltip(tooltipParams);
|
|
var options = { legend: legend, yAxis: yAxis, series: series, xAxis: xAxis, tooltip: tooltip };
|
|
return options;
|
|
};
|
|
|
|
var histogram = function histogram(columns, rows, settings, status) {
|
|
var innerRows = utilsLite.cloneDeep(rows);
|
|
var _settings$axisSite2 = settings.axisSite,
|
|
axisSite = _settings$axisSite2 === undefined ? {} : _settings$axisSite2,
|
|
_settings$dimension2 = settings.dimension,
|
|
dimension = _settings$dimension2 === undefined ? [columns[0]] : _settings$dimension2,
|
|
_settings$stack2 = settings.stack,
|
|
stack = _settings$stack2 === undefined ? {} : _settings$stack2,
|
|
_settings$axisVisible2 = settings.axisVisible,
|
|
axisVisible = _settings$axisVisible2 === undefined ? true : _settings$axisVisible2,
|
|
_settings$digit2 = settings.digit,
|
|
digit = _settings$digit2 === undefined ? 2 : _settings$digit2,
|
|
_settings$dataOrder2 = settings.dataOrder,
|
|
dataOrder = _settings$dataOrder2 === undefined ? false : _settings$dataOrder2,
|
|
_settings$scale2 = settings.scale,
|
|
scale = _settings$scale2 === undefined ? [false, false] : _settings$scale2,
|
|
_settings$min2 = settings.min,
|
|
min = _settings$min2 === undefined ? [null, null] : _settings$min2,
|
|
_settings$max2 = settings.max,
|
|
max = _settings$max2 === undefined ? [null, null] : _settings$max2,
|
|
_settings$labelMap2 = settings.labelMap,
|
|
labelMap = _settings$labelMap2 === undefined ? {} : _settings$labelMap2,
|
|
_settings$legendName2 = settings.legendName,
|
|
legendName = _settings$legendName2 === undefined ? {} : _settings$legendName2,
|
|
label = settings.label,
|
|
itemStyle = settings.itemStyle,
|
|
showLine = settings.showLine,
|
|
_settings$barGap2 = settings.barGap,
|
|
barGap = _settings$barGap2 === undefined ? '-100%' : _settings$barGap2,
|
|
opacity = settings.opacity;
|
|
|
|
|
|
if (dataOrder) {
|
|
var _label2 = dataOrder.label,
|
|
order = dataOrder.order;
|
|
|
|
if (!_label2 || !order) {
|
|
console.warn('Need to provide name and order parameters');
|
|
} else {
|
|
innerRows.sort(function (a, b) {
|
|
if (order === 'desc') {
|
|
return a[_label2] - b[_label2];
|
|
} else {
|
|
return b[_label2] - a[_label2];
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
var tooltipVisible = status.tooltipVisible,
|
|
legendVisible = status.legendVisible;
|
|
|
|
var metrics = columns.slice();
|
|
if (axisSite.left && axisSite.right) {
|
|
metrics = axisSite.left.concat(axisSite.right);
|
|
} else if (axisSite.left && !axisSite.right) {
|
|
metrics = axisSite.left;
|
|
} else if (settings.metrics) {
|
|
metrics = settings.metrics;
|
|
} else {
|
|
metrics.splice(columns.indexOf(dimension[0]), 1);
|
|
}
|
|
var meaAxisType = settings.yAxisType || ['normal', 'normal'];
|
|
var dimAxisType = settings.xAxisType || 'category';
|
|
var meaAxisName = settings.yAxisName || [];
|
|
var dimAxisName = settings.xAxisName || '';
|
|
var isHistogram = true;
|
|
var dims = getDims(innerRows, dimension);
|
|
|
|
var legend = legendVisible && getLegend({ metrics: metrics, labelMap: labelMap, legendName: legendName });
|
|
var xAxis = getBarDimAxis({
|
|
innerRows: innerRows,
|
|
dimAxisName: dimAxisName,
|
|
dimension: dimension,
|
|
axisVisible: axisVisible,
|
|
dimAxisType: dimAxisType,
|
|
dims: dims
|
|
});
|
|
var yAxis = getBarMeaAxis({
|
|
meaAxisName: meaAxisName,
|
|
meaAxisType: meaAxisType,
|
|
axisVisible: axisVisible,
|
|
digit: digit,
|
|
scale: scale,
|
|
min: min,
|
|
max: max
|
|
});
|
|
var series = getBarSeries({
|
|
innerRows: innerRows,
|
|
metrics: metrics,
|
|
stack: stack,
|
|
axisSite: axisSite,
|
|
isHistogram: isHistogram,
|
|
labelMap: labelMap,
|
|
itemStyle: itemStyle,
|
|
label: label,
|
|
showLine: showLine,
|
|
dimAxisType: dimAxisType,
|
|
dimension: dimension,
|
|
barGap: barGap,
|
|
opacity: opacity,
|
|
dims: dims
|
|
});
|
|
var tooltipParams = { axisSite: axisSite, isHistogram: isHistogram, meaAxisType: meaAxisType, digit: digit, labelMap: labelMap };
|
|
var tooltip = tooltipVisible && getBarTooltip(tooltipParams);
|
|
var options = { legend: legend, yAxis: yAxis, series: series, xAxis: xAxis, tooltip: tooltip };
|
|
return options;
|
|
};
|
|
|
|
function getLineXAxis(args) {
|
|
var dimension = args.dimension,
|
|
rows = args.rows,
|
|
xAxisName = args.xAxisName,
|
|
axisVisible = args.axisVisible,
|
|
xAxisType = args.xAxisType;
|
|
|
|
return dimension.map(function (item, index) {
|
|
return {
|
|
type: xAxisType,
|
|
nameLocation: 'middle',
|
|
nameGap: 22,
|
|
name: xAxisName[index] || '',
|
|
axisTick: { show: true, lineStyle: { color: '#eee' } },
|
|
data: rows.map(function (row) {
|
|
return row[item];
|
|
}),
|
|
show: axisVisible
|
|
};
|
|
});
|
|
}
|
|
|
|
function getLineSeries(args) {
|
|
var rows = args.rows,
|
|
axisSite = args.axisSite,
|
|
metrics = args.metrics,
|
|
area = args.area,
|
|
stack = args.stack,
|
|
nullAddZero = args.nullAddZero,
|
|
labelMap = args.labelMap,
|
|
label = args.label,
|
|
itemStyle = args.itemStyle,
|
|
lineStyle = args.lineStyle,
|
|
areaStyle = args.areaStyle,
|
|
dimension = args.dimension;
|
|
|
|
var series = [];
|
|
var dataTemp = {};
|
|
var stackMap = stack && utils.getStackMap(stack);
|
|
metrics.forEach(function (item) {
|
|
dataTemp[item] = [];
|
|
});
|
|
rows.forEach(function (row) {
|
|
metrics.forEach(function (item) {
|
|
var value = null;
|
|
if (row[item] != null) {
|
|
value = row[item];
|
|
} else if (nullAddZero) {
|
|
value = 0;
|
|
}
|
|
dataTemp[item].push([row[dimension[0]], value]);
|
|
});
|
|
});
|
|
metrics.forEach(function (item) {
|
|
var seriesItem = {
|
|
name: labelMap[item] != null ? labelMap[item] : item,
|
|
type: 'line',
|
|
data: dataTemp[item]
|
|
};
|
|
|
|
if (area) seriesItem.areaStyle = { normal: {} };
|
|
if (axisSite.right) {
|
|
seriesItem.yAxisIndex = ~axisSite.right.indexOf(item) ? 1 : 0;
|
|
}
|
|
|
|
if (stack && stackMap[item]) seriesItem.stack = stackMap[item];
|
|
|
|
if (label) seriesItem.label = label;
|
|
if (itemStyle) seriesItem.itemStyle = itemStyle;
|
|
if (lineStyle) seriesItem.lineStyle = lineStyle;
|
|
if (areaStyle) seriesItem.areaStyle = areaStyle;
|
|
|
|
series.push(seriesItem);
|
|
});
|
|
return series;
|
|
}
|
|
|
|
function getLineYAxis(args) {
|
|
var yAxisName = args.yAxisName,
|
|
yAxisType = args.yAxisType,
|
|
axisVisible = args.axisVisible,
|
|
scale = args.scale,
|
|
min = args.min,
|
|
max = args.max,
|
|
digit = args.digit;
|
|
|
|
var yAxisBase = {
|
|
type: 'value',
|
|
axisTick: {
|
|
show: false
|
|
},
|
|
show: axisVisible
|
|
};
|
|
var yAxis = [];
|
|
|
|
var _loop = function _loop(i) {
|
|
if (yAxisType[i]) {
|
|
yAxis[i] = _extends({}, yAxisBase, {
|
|
axisLabel: {
|
|
formatter: function formatter(val) {
|
|
return utils.getFormated(val, yAxisType[i], digit);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
yAxis[i] = _extends({}, yAxisBase);
|
|
}
|
|
yAxis[i].name = yAxisName[i] || '';
|
|
yAxis[i].scale = scale[i] || false;
|
|
yAxis[i].min = min[i] || null;
|
|
yAxis[i].max = max[i] || null;
|
|
};
|
|
|
|
for (var i = 0; i < 2; i++) {
|
|
_loop(i);
|
|
}
|
|
return yAxis;
|
|
}
|
|
|
|
function getLineTooltip(args) {
|
|
var axisSite = args.axisSite,
|
|
yAxisType = args.yAxisType,
|
|
digit = args.digit,
|
|
labelMap = args.labelMap,
|
|
tooltipFormatter = args.tooltipFormatter;
|
|
|
|
var rightItems = axisSite.right || [];
|
|
var rightList = labelMap ? rightItems.map(function (item) {
|
|
return labelMap[item] === undefined ? item : labelMap[item];
|
|
}) : rightItems;
|
|
return {
|
|
trigger: 'axis',
|
|
formatter: function formatter(items) {
|
|
if (tooltipFormatter) {
|
|
return tooltipFormatter.apply(null, arguments);
|
|
}
|
|
var tpl = [];
|
|
var _items$ = items[0],
|
|
name = _items$.name,
|
|
axisValueLabel = _items$.axisValueLabel;
|
|
|
|
var title = name || axisValueLabel;
|
|
tpl.push(title + '<br>');
|
|
items.forEach(function (_ref) {
|
|
var seriesName = _ref.seriesName,
|
|
data = _ref.data,
|
|
marker = _ref.marker;
|
|
|
|
var showData = null;
|
|
var type = ~rightList.indexOf(seriesName) ? yAxisType[1] : yAxisType[0];
|
|
var itemData = utilsLite.isArray(data) ? data[1] : data;
|
|
showData = utils.getFormated(itemData, type, digit);
|
|
tpl.push(marker);
|
|
tpl.push(seriesName + ': ' + showData);
|
|
tpl.push('<br>');
|
|
});
|
|
return tpl.join('');
|
|
}
|
|
};
|
|
}
|
|
|
|
function getLegend$1(args) {
|
|
var metrics = args.metrics,
|
|
legendName = args.legendName,
|
|
labelMap = args.labelMap;
|
|
|
|
if (!legendName && !labelMap) return { data: metrics };
|
|
var data = labelMap ? metrics.map(function (item) {
|
|
return labelMap[item] == null ? item : labelMap[item];
|
|
}) : metrics;
|
|
return {
|
|
data: data,
|
|
formatter: function formatter(name) {
|
|
return legendName[name] != null ? legendName[name] : name;
|
|
}
|
|
};
|
|
}
|
|
|
|
var line = function line(columns, rows, settings, extra) {
|
|
rows = utilsLite.isArray(rows) ? rows : [];
|
|
columns = utilsLite.isArray(columns) ? columns : [];
|
|
var _settings$axisSite = settings.axisSite,
|
|
axisSite = _settings$axisSite === undefined ? {} : _settings$axisSite,
|
|
_settings$yAxisType = settings.yAxisType,
|
|
yAxisType = _settings$yAxisType === undefined ? ['normal', 'normal'] : _settings$yAxisType,
|
|
_settings$xAxisType = settings.xAxisType,
|
|
xAxisType = _settings$xAxisType === undefined ? 'category' : _settings$xAxisType,
|
|
_settings$yAxisName = settings.yAxisName,
|
|
yAxisName = _settings$yAxisName === undefined ? [] : _settings$yAxisName,
|
|
_settings$dimension = settings.dimension,
|
|
dimension = _settings$dimension === undefined ? [columns[0]] : _settings$dimension,
|
|
_settings$xAxisName = settings.xAxisName,
|
|
xAxisName = _settings$xAxisName === undefined ? [] : _settings$xAxisName,
|
|
_settings$axisVisible = settings.axisVisible,
|
|
axisVisible = _settings$axisVisible === undefined ? true : _settings$axisVisible,
|
|
area = settings.area,
|
|
stack = settings.stack,
|
|
_settings$scale = settings.scale,
|
|
scale = _settings$scale === undefined ? [false, false] : _settings$scale,
|
|
_settings$min = settings.min,
|
|
min = _settings$min === undefined ? [null, null] : _settings$min,
|
|
_settings$max = settings.max,
|
|
max = _settings$max === undefined ? [null, null] : _settings$max,
|
|
_settings$nullAddZero = settings.nullAddZero,
|
|
nullAddZero = _settings$nullAddZero === undefined ? false : _settings$nullAddZero,
|
|
_settings$digit = settings.digit,
|
|
digit = _settings$digit === undefined ? 2 : _settings$digit,
|
|
_settings$legendName = settings.legendName,
|
|
legendName = _settings$legendName === undefined ? {} : _settings$legendName,
|
|
_settings$labelMap = settings.labelMap,
|
|
labelMap = _settings$labelMap === undefined ? {} : _settings$labelMap,
|
|
label = settings.label,
|
|
itemStyle = settings.itemStyle,
|
|
lineStyle = settings.lineStyle,
|
|
areaStyle = settings.areaStyle;
|
|
var tooltipVisible = extra.tooltipVisible,
|
|
legendVisible = extra.legendVisible,
|
|
tooltipFormatter = extra.tooltipFormatter;
|
|
|
|
var metrics = columns.slice();
|
|
|
|
if (axisSite.left && axisSite.right) {
|
|
metrics = axisSite.left.concat(axisSite.right);
|
|
} else if (axisSite.left && !axisSite.right) {
|
|
metrics = axisSite.left;
|
|
} else if (settings.metrics) {
|
|
metrics = settings.metrics;
|
|
} else {
|
|
metrics.splice(columns.indexOf(dimension[0]), 1);
|
|
}
|
|
|
|
var legend = legendVisible && getLegend$1({ metrics: metrics, legendName: legendName, labelMap: labelMap });
|
|
var tooltip = tooltipVisible && getLineTooltip({
|
|
axisSite: axisSite,
|
|
yAxisType: yAxisType,
|
|
digit: digit,
|
|
labelMap: labelMap,
|
|
xAxisType: xAxisType,
|
|
tooltipFormatter: tooltipFormatter
|
|
});
|
|
var xAxis = getLineXAxis({
|
|
dimension: dimension,
|
|
rows: rows,
|
|
xAxisName: xAxisName,
|
|
axisVisible: axisVisible,
|
|
xAxisType: xAxisType
|
|
});
|
|
var yAxis = getLineYAxis({
|
|
yAxisName: yAxisName,
|
|
yAxisType: yAxisType,
|
|
axisVisible: axisVisible,
|
|
scale: scale,
|
|
min: min,
|
|
max: max,
|
|
digit: digit
|
|
});
|
|
var series = getLineSeries({
|
|
rows: rows,
|
|
axisSite: axisSite,
|
|
metrics: metrics,
|
|
area: area,
|
|
stack: stack,
|
|
nullAddZero: nullAddZero,
|
|
labelMap: labelMap,
|
|
label: label,
|
|
itemStyle: itemStyle,
|
|
lineStyle: lineStyle,
|
|
areaStyle: areaStyle,
|
|
xAxisType: xAxisType,
|
|
dimension: dimension
|
|
});
|
|
var options = { legend: legend, xAxis: xAxis, series: series, yAxis: yAxis, tooltip: tooltip };
|
|
return options;
|
|
};
|
|
|
|
var pieRadius = 100;
|
|
var ringRadius = [80, 100];
|
|
var roseRingRadius = [20, 100];
|
|
var pieOffsetY = 200;
|
|
|
|
function getPieSeries(args) {
|
|
var innerRows = args.innerRows,
|
|
dataType = args.dataType,
|
|
percentShow = args.percentShow,
|
|
dimension = args.dimension,
|
|
metrics = args.metrics,
|
|
radius = args.radius,
|
|
offsetY = args.offsetY,
|
|
selectedMode = args.selectedMode,
|
|
hoverAnimation = args.hoverAnimation,
|
|
digit = args.digit,
|
|
roseType = args.roseType,
|
|
label = args.label,
|
|
level = args.level,
|
|
limitShowNum = args.limitShowNum,
|
|
isRing = args.isRing,
|
|
labelLine = args.labelLine,
|
|
itemStyle = args.itemStyle;
|
|
|
|
|
|
var series = [];
|
|
var levelTemp = {};
|
|
var rowsTemp = [];
|
|
if (level) {
|
|
level.forEach(function (levelItems, index) {
|
|
levelItems.forEach(function (item) {
|
|
utils.setArrayValue(levelTemp, item, index);
|
|
});
|
|
});
|
|
innerRows.forEach(function (row) {
|
|
var itemLevel = levelTemp[row[dimension]];
|
|
if (itemLevel && itemLevel.length) {
|
|
itemLevel.forEach(function (levelItem) {
|
|
utils.setArrayValue(rowsTemp, levelItem, row);
|
|
});
|
|
}
|
|
});
|
|
} else {
|
|
rowsTemp.push(innerRows);
|
|
}
|
|
var seriesBase = {
|
|
type: 'pie',
|
|
selectedMode: selectedMode,
|
|
hoverAnimation: hoverAnimation,
|
|
roseType: roseType,
|
|
center: ['50%', offsetY]
|
|
};
|
|
var rowsTempLength = rowsTemp.length;
|
|
rowsTemp.forEach(function (dataRows, index) {
|
|
var seriesItem = _extends({ data: [] }, seriesBase);
|
|
var centerWidth = radius / rowsTempLength;
|
|
if (!index) {
|
|
seriesItem.radius = isRing ? radius : centerWidth;
|
|
} else {
|
|
var outerWidth = centerWidth + radius / (2 * rowsTempLength) * (2 * index - 1);
|
|
var innerWidth = outerWidth + radius / (2 * rowsTempLength);
|
|
seriesItem.radius = [outerWidth, innerWidth];
|
|
}
|
|
if (rowsTempLength > 1 && index === 0) {
|
|
seriesItem.label = {
|
|
normal: { position: 'inner' }
|
|
};
|
|
}
|
|
if (label) seriesItem.label = label;
|
|
if (labelLine) seriesItem.labelLine = labelLine;
|
|
if (itemStyle) seriesItem.itemStyle = itemStyle;
|
|
if (percentShow) {
|
|
seriesItem.label = {
|
|
normal: {
|
|
show: true,
|
|
position: rowsTempLength > 1 && index === 0 ? 'inner' : 'outside',
|
|
formatter: function formatter(item) {
|
|
var tpl = [];
|
|
tpl.push(item.name + ':');
|
|
tpl.push(utils.getFormated(item.value, dataType, digit));
|
|
tpl.push('(' + item.percent + '%)');
|
|
return tpl.join(' ');
|
|
}
|
|
}
|
|
};
|
|
}
|
|
seriesItem.data = dataRows.map(function (row) {
|
|
return {
|
|
name: row[dimension],
|
|
value: row[metrics]
|
|
};
|
|
});
|
|
series.push(seriesItem);
|
|
});
|
|
if (limitShowNum && limitShowNum < series[0].data.length) {
|
|
var firstData = series[0].data;
|
|
var remainArr = firstData.slice(limitShowNum, firstData.length);
|
|
var sum = 0;
|
|
remainArr.forEach(function (item) {
|
|
sum += item.value;
|
|
});
|
|
series[0].data = firstData.slice(0, limitShowNum);
|
|
series[0].data.push({ name: '其他', value: sum });
|
|
}
|
|
return series;
|
|
}
|
|
|
|
function getPieLegend(args) {
|
|
var innerRows = args.innerRows,
|
|
dimension = args.dimension,
|
|
legendLimit = args.legendLimit,
|
|
legendName = args.legendName,
|
|
level = args.level,
|
|
limitShowNum = args.limitShowNum;
|
|
|
|
var legend = [];
|
|
var levelTemp = [];
|
|
if (level) {
|
|
level.forEach(function (levelItem) {
|
|
levelItem.forEach(function (item) {
|
|
levelTemp.push(item);
|
|
});
|
|
});
|
|
legend = levelTemp;
|
|
} else if (limitShowNum && limitShowNum < innerRows.length) {
|
|
for (var i = 0; i < limitShowNum; i++) {
|
|
legend.push(innerRows[i][dimension]);
|
|
}
|
|
legend.push('其他');
|
|
} else {
|
|
legend = innerRows.map(function (row) {
|
|
return row[dimension];
|
|
});
|
|
}
|
|
if (legend.length) {
|
|
return {
|
|
data: legend,
|
|
show: legend.length < legendLimit,
|
|
formatter: function formatter(name) {
|
|
return legendName[name] != null ? legendName[name] : name;
|
|
}
|
|
};
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function getPieTooltip(args) {
|
|
var dataType = args.dataType,
|
|
innerRows = args.innerRows,
|
|
limitShowNum = args.limitShowNum,
|
|
digit = args.digit,
|
|
metrics = args.metrics,
|
|
dimension = args.dimension;
|
|
|
|
var sum = 0;
|
|
var remainArr = innerRows.map(function (row) {
|
|
sum += row[metrics];
|
|
return {
|
|
name: row[dimension],
|
|
value: row[metrics]
|
|
};
|
|
}).slice(limitShowNum, innerRows.length);
|
|
return {
|
|
formatter: function formatter(item) {
|
|
var tpl = [];
|
|
tpl.push(constants.itemPoint(item.color));
|
|
if (limitShowNum && item.name === '其他') {
|
|
tpl.push('其他:');
|
|
remainArr.forEach(function (_ref) {
|
|
var name = _ref.name,
|
|
value = _ref.value;
|
|
|
|
var percent = utils.getFormated(value / sum, 'percent');
|
|
tpl.push('<br>' + name + ':');
|
|
tpl.push(utils.getFormated(value, dataType, digit));
|
|
tpl.push('(' + percent + ')');
|
|
});
|
|
} else {
|
|
tpl.push(item.name + ':');
|
|
tpl.push(utils.getFormated(item.value, dataType, digit));
|
|
tpl.push('(' + item.percent + '%)');
|
|
}
|
|
return tpl.join(' ');
|
|
}
|
|
};
|
|
}
|
|
|
|
var pie = function pie(columns, rows, settings, extra, isRing) {
|
|
var innerRows = utilsLite.cloneDeep(rows);
|
|
var _settings$dataType = settings.dataType,
|
|
dataType = _settings$dataType === undefined ? 'normal' : _settings$dataType,
|
|
percentShow = settings.percentShow,
|
|
_settings$dimension = settings.dimension,
|
|
dimension = _settings$dimension === undefined ? columns[0] : _settings$dimension,
|
|
_settings$metrics = settings.metrics,
|
|
metrics = _settings$metrics === undefined ? columns[1] : _settings$metrics,
|
|
_settings$roseType = settings.roseType,
|
|
roseType = _settings$roseType === undefined ? false : _settings$roseType,
|
|
_settings$radius = settings.radius,
|
|
radius = _settings$radius === undefined ? isRing ? roseType ? roseRingRadius : ringRadius : pieRadius : _settings$radius,
|
|
_settings$offsetY = settings.offsetY,
|
|
offsetY = _settings$offsetY === undefined ? pieOffsetY : _settings$offsetY,
|
|
_settings$legendLimit = settings.legendLimit,
|
|
legendLimit = _settings$legendLimit === undefined ? 30 : _settings$legendLimit,
|
|
_settings$selectedMod = settings.selectedMode,
|
|
selectedMode = _settings$selectedMod === undefined ? false : _settings$selectedMod,
|
|
_settings$hoverAnimat = settings.hoverAnimation,
|
|
hoverAnimation = _settings$hoverAnimat === undefined ? true : _settings$hoverAnimat,
|
|
_settings$digit = settings.digit,
|
|
digit = _settings$digit === undefined ? 2 : _settings$digit,
|
|
_settings$legendName = settings.legendName,
|
|
legendName = _settings$legendName === undefined ? {} : _settings$legendName,
|
|
_settings$label = settings.label,
|
|
label = _settings$label === undefined ? false : _settings$label,
|
|
_settings$level = settings.level,
|
|
level = _settings$level === undefined ? false : _settings$level,
|
|
_settings$limitShowNu = settings.limitShowNum,
|
|
limitShowNum = _settings$limitShowNu === undefined ? 0 : _settings$limitShowNu,
|
|
labelLine = settings.labelLine,
|
|
itemStyle = settings.itemStyle;
|
|
var tooltipVisible = extra.tooltipVisible,
|
|
legendVisible = extra.legendVisible;
|
|
|
|
if (limitShowNum) innerRows.sort(function (a, b) {
|
|
return b[metrics] - a[metrics];
|
|
});
|
|
var seriesParams = {
|
|
innerRows: innerRows,
|
|
dataType: dataType,
|
|
percentShow: percentShow,
|
|
dimension: dimension,
|
|
metrics: metrics,
|
|
radius: radius,
|
|
offsetY: offsetY,
|
|
selectedMode: selectedMode,
|
|
hoverAnimation: hoverAnimation,
|
|
digit: digit,
|
|
roseType: roseType,
|
|
label: label,
|
|
level: level,
|
|
legendName: legendName,
|
|
limitShowNum: limitShowNum,
|
|
isRing: isRing,
|
|
labelLine: labelLine,
|
|
itemStyle: itemStyle
|
|
};
|
|
var series = getPieSeries(seriesParams);
|
|
var legendParams = {
|
|
innerRows: innerRows,
|
|
dimension: dimension,
|
|
legendLimit: legendLimit,
|
|
legendName: legendName,
|
|
level: level,
|
|
limitShowNum: limitShowNum
|
|
};
|
|
var legend = legendVisible && getPieLegend(legendParams);
|
|
var tooltip = tooltipVisible && getPieTooltip({
|
|
dataType: dataType,
|
|
innerRows: innerRows,
|
|
limitShowNum: limitShowNum,
|
|
digit: digit,
|
|
metrics: metrics,
|
|
dimension: dimension
|
|
});
|
|
var options = { series: series, legend: legend, tooltip: tooltip };
|
|
return options;
|
|
};
|
|
|
|
var ring = function ring(columns, rows, settings, extra) {
|
|
return pie(columns, rows, settings, extra, true);
|
|
};
|
|
|
|
function getFunnelTooltip(dataType, digit) {
|
|
return {
|
|
trigger: 'item',
|
|
formatter: function formatter(item) {
|
|
var tpl = [];
|
|
tpl.push(constants.itemPoint(item.color));
|
|
tpl.push(item.name + ': ' + utils.getFormated(item.data.realValue, dataType, digit));
|
|
return tpl.join('');
|
|
}
|
|
};
|
|
}
|
|
|
|
function getFunnelLegend(args) {
|
|
var data = args.data,
|
|
legendName = args.legendName;
|
|
|
|
return {
|
|
data: data,
|
|
formatter: function formatter(name) {
|
|
return legendName[name] != null ? legendName[name] : name;
|
|
}
|
|
};
|
|
}
|
|
|
|
function getFunnelSeries(args) {
|
|
var dimension = args.dimension,
|
|
metrics = args.metrics,
|
|
rows = args.rows,
|
|
sequence = args.sequence,
|
|
ascending = args.ascending,
|
|
label = args.label,
|
|
labelLine = args.labelLine,
|
|
itemStyle = args.itemStyle,
|
|
filterZero = args.filterZero,
|
|
useDefaultOrder = args.useDefaultOrder;
|
|
|
|
var series = { type: 'funnel' };
|
|
var innerRows = rows.sort(function (a, b) {
|
|
return sequence.indexOf(a[dimension]) - sequence.indexOf(b[dimension]);
|
|
});
|
|
|
|
if (filterZero) {
|
|
innerRows = innerRows.filter(function (row) {
|
|
return row[metrics];
|
|
});
|
|
}
|
|
|
|
var falseFunnel = false;
|
|
innerRows.some(function (row, index) {
|
|
if (index && row[metrics] > innerRows[index - 1][metrics]) {
|
|
falseFunnel = true;
|
|
return true;
|
|
}
|
|
});
|
|
|
|
var step = 100 / innerRows.length;
|
|
|
|
if (falseFunnel && !useDefaultOrder) {
|
|
series.data = innerRows.slice().reverse().map(function (row, index) {
|
|
return {
|
|
name: row[dimension],
|
|
value: (index + 1) * step,
|
|
realValue: row[metrics]
|
|
};
|
|
});
|
|
} else {
|
|
series.data = innerRows.map(function (row) {
|
|
return {
|
|
name: row[dimension],
|
|
value: row[metrics],
|
|
realValue: row[metrics]
|
|
};
|
|
});
|
|
}
|
|
|
|
if (ascending) series.sort = 'ascending';
|
|
if (label) series.label = label;
|
|
if (labelLine) series.labelLine = labelLine;
|
|
if (itemStyle) series.itemStyle = itemStyle;
|
|
return series;
|
|
}
|
|
|
|
var funnel = function funnel(outerColumns, outerRows, settings, extra) {
|
|
var columns = outerColumns.slice();
|
|
var rows = outerRows.slice();
|
|
var _settings$dataType = settings.dataType,
|
|
dataType = _settings$dataType === undefined ? 'normal' : _settings$dataType,
|
|
_settings$dimension = settings.dimension,
|
|
dimension = _settings$dimension === undefined ? columns[0] : _settings$dimension,
|
|
_settings$sequence = settings.sequence,
|
|
sequence = _settings$sequence === undefined ? rows.map(function (row) {
|
|
return row[dimension];
|
|
}) : _settings$sequence,
|
|
_settings$digit = settings.digit,
|
|
digit = _settings$digit === undefined ? 2 : _settings$digit,
|
|
ascending = settings.ascending,
|
|
label = settings.label,
|
|
labelLine = settings.labelLine,
|
|
_settings$legendName = settings.legendName,
|
|
legendName = _settings$legendName === undefined ? {} : _settings$legendName,
|
|
itemStyle = settings.itemStyle,
|
|
filterZero = settings.filterZero,
|
|
useDefaultOrder = settings.useDefaultOrder;
|
|
var tooltipVisible = extra.tooltipVisible,
|
|
legendVisible = extra.legendVisible;
|
|
|
|
var metrics = void 0;
|
|
if (settings.metrics) {
|
|
metrics = settings.metrics;
|
|
} else {
|
|
var metricsTemp = columns.slice();
|
|
metricsTemp.splice(columns.indexOf(dimension), 1);
|
|
metrics = metricsTemp[0];
|
|
}
|
|
|
|
var tooltip = tooltipVisible && getFunnelTooltip(dataType, digit);
|
|
var legend = legendVisible && getFunnelLegend({ data: sequence, legendName: legendName });
|
|
var series = getFunnelSeries({
|
|
dimension: dimension,
|
|
metrics: metrics,
|
|
rows: rows,
|
|
sequence: sequence,
|
|
ascending: ascending,
|
|
label: label,
|
|
labelLine: labelLine,
|
|
itemStyle: itemStyle,
|
|
filterZero: filterZero,
|
|
useDefaultOrder: useDefaultOrder
|
|
});
|
|
var options = { tooltip: tooltip, legend: legend, series: series };
|
|
return options;
|
|
};
|
|
|
|
function getRadarLegend(rows, dimension, legendName) {
|
|
var legendData = rows.map(function (row) {
|
|
return row[dimension];
|
|
});
|
|
|
|
return {
|
|
data: legendData,
|
|
formatter: function formatter(name) {
|
|
return legendName[name] != null ? legendName[name] : name;
|
|
}
|
|
};
|
|
}
|
|
|
|
function getRadarTooltip(dataType, radar, digit) {
|
|
var typeTemp = [];
|
|
var nameTemp = [];
|
|
radar.indicator.map(function (item, index) {
|
|
typeTemp[index] = dataType[item.name];
|
|
nameTemp[index] = item.name;
|
|
});
|
|
return {
|
|
formatter: function formatter(item) {
|
|
var tpl = [];
|
|
tpl.push(constants.itemPoint(item.color));
|
|
tpl.push(item.name + '<br />');
|
|
item.data.value.forEach(function (val, index) {
|
|
tpl.push(nameTemp[index] + ': ');
|
|
tpl.push(utils.getFormated(val, typeTemp[index], digit) + '<br />');
|
|
});
|
|
return tpl.join('');
|
|
}
|
|
};
|
|
}
|
|
|
|
function getRadarSetting(rows, metrics, labelMap) {
|
|
var settingBase = {
|
|
indicator: [],
|
|
shape: 'circle',
|
|
splitNumber: 5
|
|
};
|
|
var indicatorTemp = {};
|
|
rows.forEach(function (items) {
|
|
metrics.forEach(function (item) {
|
|
var key = labelMap[item] != null ? labelMap[item] : item;
|
|
if (!indicatorTemp[key]) {
|
|
indicatorTemp[key] = [items[item]];
|
|
} else {
|
|
indicatorTemp[key].push(items[item]);
|
|
}
|
|
});
|
|
});
|
|
settingBase.indicator = Object.keys(indicatorTemp).map(function (key) {
|
|
return {
|
|
name: key,
|
|
max: Math.max.apply(null, indicatorTemp[key])
|
|
};
|
|
});
|
|
return settingBase;
|
|
}
|
|
|
|
function getRadarSeries(args) {
|
|
var rows = args.rows,
|
|
dimension = args.dimension,
|
|
metrics = args.metrics,
|
|
radar = args.radar,
|
|
label = args.label,
|
|
itemStyle = args.itemStyle,
|
|
lineStyle = args.lineStyle,
|
|
labelMap = args.labelMap,
|
|
areaStyle = args.areaStyle;
|
|
|
|
var radarIndexObj = {};
|
|
radar.indicator.forEach(function (item, index) {
|
|
var name = item.name;
|
|
radarIndexObj[name] = index;
|
|
});
|
|
|
|
var seriesData = rows.map(function (row) {
|
|
var serieData = {
|
|
value: [],
|
|
name: row[dimension]
|
|
};
|
|
Object.keys(row).forEach(function (key) {
|
|
if (~metrics.indexOf(key)) {
|
|
var k = labelMap[key] != null ? radarIndexObj[labelMap[key]] : radarIndexObj[key];
|
|
serieData.value[k] = row[key];
|
|
}
|
|
});
|
|
return serieData;
|
|
});
|
|
var result = {
|
|
name: dimension,
|
|
type: 'radar',
|
|
data: seriesData
|
|
};
|
|
if (label) result.label = label;
|
|
if (itemStyle) result.itemStyle = itemStyle;
|
|
if (lineStyle) result.lineStyle = lineStyle;
|
|
if (areaStyle) result.areaStyle = areaStyle;
|
|
return [result];
|
|
}
|
|
|
|
var radar = function radar(columns, rows, settings, extra) {
|
|
var _settings$dataType = settings.dataType,
|
|
dataType = _settings$dataType === undefined ? {} : _settings$dataType,
|
|
_settings$legendName = settings.legendName,
|
|
legendName = _settings$legendName === undefined ? {} : _settings$legendName,
|
|
_settings$labelMap = settings.labelMap,
|
|
labelMap = _settings$labelMap === undefined ? {} : _settings$labelMap,
|
|
_settings$dimension = settings.dimension,
|
|
dimension = _settings$dimension === undefined ? columns[0] : _settings$dimension,
|
|
_settings$digit = settings.digit,
|
|
digit = _settings$digit === undefined ? 2 : _settings$digit,
|
|
label = settings.label,
|
|
itemStyle = settings.itemStyle,
|
|
lineStyle = settings.lineStyle,
|
|
areaStyle = settings.areaStyle;
|
|
var tooltipVisible = extra.tooltipVisible,
|
|
legendVisible = extra.legendVisible;
|
|
|
|
var metrics = columns.slice();
|
|
if (settings.metrics) {
|
|
metrics = settings.metrics;
|
|
} else {
|
|
metrics.splice(columns.indexOf(dimension), 1);
|
|
}
|
|
var legend = legendVisible && getRadarLegend(rows, dimension, legendName);
|
|
var radar = getRadarSetting(rows, metrics, labelMap);
|
|
var tooltip = tooltipVisible && getRadarTooltip(dataType, radar, digit);
|
|
var series = getRadarSeries({
|
|
rows: rows,
|
|
dimension: dimension,
|
|
metrics: metrics,
|
|
radar: radar,
|
|
label: label,
|
|
itemStyle: itemStyle,
|
|
lineStyle: lineStyle,
|
|
labelMap: labelMap,
|
|
areaStyle: areaStyle
|
|
});
|
|
var options = { legend: legend, tooltip: tooltip, radar: radar, series: series };
|
|
return options;
|
|
};
|
|
|
|
function getWaterfallTooltip(dataType, digit) {
|
|
return {
|
|
trigger: 'axis',
|
|
axisPointer: { type: 'shadow' },
|
|
formatter: function formatter(items) {
|
|
var item = items[1];
|
|
return [item.name + '<br/>' + item.seriesName + ' :', '' + utils.getFormated(item.value, dataType, digit)].join('');
|
|
}
|
|
};
|
|
}
|
|
|
|
function getWaterfallXAxis(args) {
|
|
var dimension = args.dimension,
|
|
rows = args.rows,
|
|
remainStatus = args.remainStatus,
|
|
totalName = args.totalName,
|
|
remainName = args.remainName,
|
|
labelMap = args.labelMap,
|
|
xAxisName = args.xAxisName,
|
|
axisVisible = args.axisVisible;
|
|
|
|
var xAxisData = [totalName].concat(rows.map(function (row) {
|
|
return row[dimension];
|
|
}));
|
|
if (remainStatus === 'have-remain') {
|
|
xAxisData = xAxisData.concat([remainName]);
|
|
}
|
|
|
|
return {
|
|
type: 'category',
|
|
name: labelMap && labelMap[xAxisName] || xAxisName,
|
|
splitLine: { show: false },
|
|
data: xAxisData,
|
|
show: axisVisible
|
|
};
|
|
}
|
|
|
|
function getWaterfallYAxis(args) {
|
|
var dataType = args.dataType,
|
|
yAxisName = args.yAxisName,
|
|
axisVisible = args.axisVisible,
|
|
digit = args.digit,
|
|
labelMap = args.labelMap;
|
|
|
|
return {
|
|
type: 'value',
|
|
name: labelMap[yAxisName] != null ? labelMap[yAxisName] : yAxisName,
|
|
axisTick: { show: false },
|
|
axisLabel: {
|
|
formatter: function formatter(val) {
|
|
return utils.getFormated(val, dataType, digit);
|
|
}
|
|
},
|
|
show: axisVisible
|
|
};
|
|
}
|
|
|
|
function getWaterfallSeries(args) {
|
|
var dataType = args.dataType,
|
|
rows = args.rows,
|
|
metrics = args.metrics,
|
|
totalNum = args.totalNum,
|
|
remainStatus = args.remainStatus,
|
|
dataSum = args.dataSum,
|
|
digit = args.digit;
|
|
|
|
var seriesBase = { type: 'bar', stack: '总量' };
|
|
var dataSumTemp = dataSum;
|
|
var totalNumTemp = totalNum;
|
|
var assistData = void 0;
|
|
var mainData = void 0;
|
|
var rowData = rows.map(function (row) {
|
|
return row[metrics];
|
|
});
|
|
|
|
if (remainStatus === 'have-remain') {
|
|
assistData = [0].concat(rows.map(function (row) {
|
|
totalNumTemp -= row[metrics];
|
|
return totalNumTemp;
|
|
})).concat([0]);
|
|
mainData = [totalNum].concat(rowData).concat([totalNum - dataSum]);
|
|
} else {
|
|
assistData = [0].concat(rows.map(function (row) {
|
|
dataSumTemp -= row[metrics];
|
|
return dataSumTemp;
|
|
}));
|
|
mainData = [dataSum].concat(rowData);
|
|
}
|
|
var series = [];
|
|
|
|
series.push(_extends({
|
|
name: '辅助',
|
|
itemStyle: {
|
|
normal: { opacity: 0 },
|
|
emphasis: { opacity: 0 }
|
|
},
|
|
data: assistData
|
|
}, seriesBase));
|
|
|
|
series.push(_extends({
|
|
name: '数值',
|
|
label: {
|
|
normal: {
|
|
show: true,
|
|
position: 'top',
|
|
formatter: function formatter(item) {
|
|
return utils.getFormated(item.value, dataType, digit);
|
|
}
|
|
}
|
|
},
|
|
data: mainData
|
|
}, seriesBase));
|
|
return series;
|
|
}
|
|
|
|
function getWaterfallRemainStatus(dataSum, totalNum) {
|
|
if (!totalNum) return 'not-total';
|
|
return totalNum > dataSum ? 'have-remain' : 'none-remain';
|
|
}
|
|
|
|
var waterfall = function waterfall(columns, rows, settings, extra) {
|
|
var _settings$dataType = settings.dataType,
|
|
dataType = _settings$dataType === undefined ? 'normal' : _settings$dataType,
|
|
_settings$dimension = settings.dimension,
|
|
dimension = _settings$dimension === undefined ? columns[0] : _settings$dimension,
|
|
_settings$totalName = settings.totalName,
|
|
totalName = _settings$totalName === undefined ? '总计' : _settings$totalName,
|
|
totalNum = settings.totalNum,
|
|
_settings$remainName = settings.remainName,
|
|
remainName = _settings$remainName === undefined ? '其他' : _settings$remainName,
|
|
_settings$xAxisName = settings.xAxisName,
|
|
xAxisName = _settings$xAxisName === undefined ? dimension : _settings$xAxisName,
|
|
_settings$labelMap = settings.labelMap,
|
|
labelMap = _settings$labelMap === undefined ? {} : _settings$labelMap,
|
|
_settings$axisVisible = settings.axisVisible,
|
|
axisVisible = _settings$axisVisible === undefined ? true : _settings$axisVisible,
|
|
_settings$digit = settings.digit,
|
|
digit = _settings$digit === undefined ? 2 : _settings$digit;
|
|
var tooltipVisible = extra.tooltipVisible;
|
|
|
|
var metricsTemp = columns.slice();
|
|
metricsTemp.splice(metricsTemp.indexOf(dimension), 1);
|
|
var metrics = metricsTemp[0];
|
|
var yAxisName = metrics;
|
|
var tooltip = tooltipVisible && getWaterfallTooltip(dataType, digit);
|
|
var dataSum = parseFloat(rows.reduce(function (pre, cur) {
|
|
return pre + Number(cur[metrics]);
|
|
}, 0).toFixed(digit));
|
|
var remainStatus = getWaterfallRemainStatus(dataSum, totalNum);
|
|
var xAxisParams = {
|
|
dimension: dimension,
|
|
rows: rows,
|
|
remainStatus: remainStatus,
|
|
totalName: totalName,
|
|
remainName: remainName,
|
|
xAxisName: xAxisName,
|
|
labelMap: labelMap,
|
|
axisVisible: axisVisible
|
|
};
|
|
var xAxis = getWaterfallXAxis(xAxisParams);
|
|
var yAxis = getWaterfallYAxis({ dataType: dataType, yAxisName: yAxisName, axisVisible: axisVisible, digit: digit, labelMap: labelMap });
|
|
var seriesParams = {
|
|
dataType: dataType,
|
|
rows: rows,
|
|
dimension: dimension,
|
|
metrics: metrics,
|
|
totalNum: totalNum,
|
|
remainStatus: remainStatus,
|
|
dataSum: dataSum,
|
|
digit: digit
|
|
};
|
|
var series = getWaterfallSeries(seriesParams);
|
|
var options = { tooltip: tooltip, xAxis: xAxis, yAxis: yAxis, series: series };
|
|
return options;
|
|
};
|
|
|
|
var index = _extends({}, Core, {
|
|
name: 'VeChart',
|
|
data: function data() {
|
|
this.chartLib = {
|
|
bar: bar,
|
|
histogram: histogram,
|
|
line: line,
|
|
pie: pie,
|
|
ring: ring,
|
|
funnel: funnel,
|
|
radar: radar,
|
|
waterfall: waterfall
|
|
};
|
|
this.chartHandler = this.chartLib[this.settings.type];
|
|
return {};
|
|
}
|
|
});
|
|
|
|
module.exports = index;
|