You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2129 lines
67 KiB
2129 lines
67 KiB
module.exports =
|
|
/******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId]) {
|
|
/******/ return installedModules[moduleId].exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ i: moduleId,
|
|
/******/ l: false,
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.l = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
/******/
|
|
/******/ // define getter function for harmony exports
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
|
|
/******/ }
|
|
/******/ };
|
|
/******/
|
|
/******/ // define __esModule on exports
|
|
/******/ __webpack_require__.r = function(exports) {
|
|
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
|
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
|
/******/ }
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
|
/******/ };
|
|
/******/
|
|
/******/ // create a fake namespace object
|
|
/******/ // mode & 1: value is a module id, require it
|
|
/******/ // mode & 2: merge all properties of value into the ns
|
|
/******/ // mode & 4: return value when already ns object
|
|
/******/ // mode & 8|1: behave like require
|
|
/******/ __webpack_require__.t = function(value, mode) {
|
|
/******/ if(mode & 1) value = __webpack_require__(value);
|
|
/******/ if(mode & 8) return value;
|
|
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
|
|
/******/ var ns = Object.create(null);
|
|
/******/ __webpack_require__.r(ns);
|
|
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
|
|
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
|
|
/******/ return ns;
|
|
/******/ };
|
|
/******/
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function(module) {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ function getDefault() { return module['default']; } :
|
|
/******/ function getModuleExports() { return module; };
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
/******/ return getter;
|
|
/******/ };
|
|
/******/
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "/dist/";
|
|
/******/
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(__webpack_require__.s = 248);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ({
|
|
|
|
/***/ 109:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return bar; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return histogram; });
|
|
/* harmony import */ var main_utils_charts_constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15);
|
|
/* harmony import */ var main_utils_charts_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(32);
|
|
/* harmony import */ var utils_lite__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(3);
|
|
/* harmony import */ var utils_lite__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(utils_lite__WEBPACK_IMPORTED_MODULE_2__);
|
|
|
|
|
|
|
|
// 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,
|
|
axisLine: {
|
|
lineStyle: {
|
|
color: '#FFF'
|
|
}
|
|
}
|
|
};
|
|
});
|
|
}
|
|
|
|
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,
|
|
axisLine: {
|
|
lineStyle: {
|
|
color: '#FFF'
|
|
}
|
|
}
|
|
};
|
|
var meaAxis = [];
|
|
|
|
var _loop = function _loop(i) {
|
|
if (meaAxisType[i]) {
|
|
meaAxis[i] = Object.assign({}, meaAxisBase, {
|
|
axisLabel: {
|
|
formatter: function formatter(val) {
|
|
return Object(main_utils_charts_utils__WEBPACK_IMPORTED_MODULE_1__[/* getFormated */ "c"])(val, meaAxisType[i], digit);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
meaAxis[i] = Object.assign({}, 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(Object(main_utils_charts_constants__WEBPACK_IMPORTED_MODULE_0__[/* itemPoint */ "g"])(item.color));
|
|
tpl.push(seriesName + ': ');
|
|
tpl.push(Object(main_utils_charts_utils__WEBPACK_IMPORTED_MODULE_1__[/* getFormated */ "c"])(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 && Object(main_utils_charts_utils__WEBPACK_IMPORTED_MODULE_1__[/* getStackMap */ "e"])(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 _seriesItem;
|
|
|
|
var data = dimAxisType === 'value' ? getValueData(seriesTemp[item], dims) : seriesTemp[item];
|
|
var seriesItem = (_seriesItem = {
|
|
name: labelMap[item] != null ? labelMap[item] : item,
|
|
type: ~showLine.indexOf(item) ? 'line' : 'bar',
|
|
data: data
|
|
}, _seriesItem[secondDimAxisIndex] = ~secondAxis.indexOf(item) ? '1' : '0', _seriesItem);
|
|
|
|
if (stack && stackMap[item]) seriesItem.stack = stackMap[item];
|
|
|
|
if (label) seriesItem.label = label;
|
|
if (itemStyle) seriesItem.itemStyle = itemStyle;
|
|
|
|
var itemOpacity = opacity || Object(utils_lite__WEBPACK_IMPORTED_MODULE_2__["get"])(seriesItem, 'itemStyle.normal.opacity');
|
|
if (dimAxisType === 'value') {
|
|
seriesItem.barGap = barGap;
|
|
seriesItem.barCategoryGap = '1%';
|
|
if (itemOpacity == null) itemOpacity = VALUE_AXIS_OPACITY;
|
|
}
|
|
|
|
if (itemOpacity != null) {
|
|
Object(utils_lite__WEBPACK_IMPORTED_MODULE_2__["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 = Object(utils_lite__WEBPACK_IMPORTED_MODULE_2__["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 = Object(utils_lite__WEBPACK_IMPORTED_MODULE_2__["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;
|
|
};
|
|
|
|
/***/ }),
|
|
|
|
/***/ 114:
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("echarts/lib/chart/bar");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 12:
|
|
/***/ (function(module, exports) {
|
|
|
|
|
|
/**
|
|
* When source maps are enabled, `style-loader` uses a link element with a data-uri to
|
|
* embed the css on the page. This breaks all relative urls because now they are relative to a
|
|
* bundle instead of the current page.
|
|
*
|
|
* One solution is to only use full urls, but that may be impossible.
|
|
*
|
|
* Instead, this function "fixes" the relative urls to be absolute according to the current page location.
|
|
*
|
|
* A rudimentary test suite is located at `test/fixUrls.js` and can be run via the `npm test` command.
|
|
*
|
|
*/
|
|
|
|
module.exports = function (css) {
|
|
// get current location
|
|
var location = typeof window !== "undefined" && window.location;
|
|
|
|
if (!location) {
|
|
throw new Error("fixUrls requires window.location");
|
|
}
|
|
|
|
// blank or null?
|
|
if (!css || typeof css !== "string") {
|
|
return css;
|
|
}
|
|
|
|
var baseUrl = location.protocol + "//" + location.host;
|
|
var currentDir = baseUrl + location.pathname.replace(/\/[^\/]*$/, "/");
|
|
|
|
// convert each url(...)
|
|
/*
|
|
This regular expression is just a way to recursively match brackets within
|
|
a string.
|
|
|
|
/url\s*\( = Match on the word "url" with any whitespace after it and then a parens
|
|
( = Start a capturing group
|
|
(?: = Start a non-capturing group
|
|
[^)(] = Match anything that isn't a parentheses
|
|
| = OR
|
|
\( = Match a start parentheses
|
|
(?: = Start another non-capturing groups
|
|
[^)(]+ = Match anything that isn't a parentheses
|
|
| = OR
|
|
\( = Match a start parentheses
|
|
[^)(]* = Match anything that isn't a parentheses
|
|
\) = Match a end parentheses
|
|
) = End Group
|
|
*\) = Match anything and then a close parens
|
|
) = Close non-capturing group
|
|
* = Match anything
|
|
) = Close capturing group
|
|
\) = Match a close parens
|
|
|
|
/gi = Get all matches, not the first. Be case insensitive.
|
|
*/
|
|
var fixedCss = css.replace(/url\s*\(((?:[^)(]|\((?:[^)(]+|\([^)(]*\))*\))*)\)/gi, function(fullMatch, origUrl) {
|
|
// strip quotes (if they exist)
|
|
var unquotedOrigUrl = origUrl
|
|
.trim()
|
|
.replace(/^"(.*)"$/, function(o, $1){ return $1; })
|
|
.replace(/^'(.*)'$/, function(o, $1){ return $1; });
|
|
|
|
// already a full url? no change
|
|
if (/^(#|data:|http:\/\/|https:\/\/|file:\/\/\/|\s*$)/i.test(unquotedOrigUrl)) {
|
|
return fullMatch;
|
|
}
|
|
|
|
// convert the url to a full url
|
|
var newUrl;
|
|
|
|
if (unquotedOrigUrl.indexOf("//") === 0) {
|
|
//TODO: should we add protocol?
|
|
newUrl = unquotedOrigUrl;
|
|
} else if (unquotedOrigUrl.indexOf("/") === 0) {
|
|
// path should be relative to the base url
|
|
newUrl = baseUrl + unquotedOrigUrl; // already starts with '/'
|
|
} else {
|
|
// path should be relative to current directory
|
|
newUrl = currentDir + unquotedOrigUrl.replace(/^\.\//, ""); // Strip leading './'
|
|
}
|
|
|
|
// send back the fixed url(...)
|
|
return "url(" + JSON.stringify(newUrl) + ")";
|
|
});
|
|
|
|
// send back the fixed css
|
|
return fixedCss;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 15:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return DEFAULT_THEME; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return DEFAULT_COLORS; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return HEAT_MAP_COLOR; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return HEAT_BMAP_COLOR; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return itemPoint; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return STATIC_PROPS; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return ECHARTS_SETTINGS; });
|
|
var DEFAULT_THEME = {
|
|
categoryAxis: {
|
|
axisLine: { show: false },
|
|
axisTick: { show: false },
|
|
splitLine: { show: false }
|
|
},
|
|
valueAxis: {
|
|
axisLine: { show: false }
|
|
},
|
|
line: {
|
|
smooth: true
|
|
},
|
|
grid: {
|
|
containLabel: true,
|
|
left: 10,
|
|
right: 10
|
|
}
|
|
};
|
|
|
|
var DEFAULT_COLORS = ['#19d4ae', '#5ab1ef', '#fa6e86', '#ffb980', '#0067a6', '#c4b4e4', '#d87a80', '#9cbbff', '#d9d0c7', '#87a997', '#d49ea2', '#5b4947', '#7ba3a8'];
|
|
|
|
var HEAT_MAP_COLOR = ['#313695', '#4575b4', '#74add1', '#abd9e9', '#e0f3f8', '#ffffbf', '#fee090', '#fdae61', '#f46d43', '#d73027', '#a50026'];
|
|
|
|
var HEAT_BMAP_COLOR = ['blue', 'blue', 'green', 'yellow', 'red'];
|
|
|
|
var itemPoint = function itemPoint(color) {
|
|
return ['<span style="', 'background-color:' + color + ';', 'display: inline-block;', 'width: 10px;', 'height: 10px;', 'border-radius: 50%;', 'margin-right:2px;', '"></span>'].join('');
|
|
};
|
|
|
|
var STATIC_PROPS = ['initOptions', 'loading', 'dataEmpty', 'judgeWidth', 'widthChangeDelay'];
|
|
|
|
var ECHARTS_SETTINGS = ['grid', 'dataZoom', 'visualMap', 'toolbox', 'title', 'legend', 'xAxis', 'yAxis', 'radar', 'tooltip', 'axisPointer', 'brush', 'geo', 'timeline', 'graphic', 'series', 'backgroundColor', 'textStyle'];
|
|
|
|
/***/ }),
|
|
|
|
/***/ 17:
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("echarts/lib/echarts");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 2:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return normalizeComponent; });
|
|
/* globals __VUE_SSR_CONTEXT__ */
|
|
|
|
// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
|
|
// This module is a runtime utility for cleaner component module output and will
|
|
// be included in the final webpack user bundle.
|
|
|
|
function normalizeComponent (
|
|
scriptExports,
|
|
render,
|
|
staticRenderFns,
|
|
functionalTemplate,
|
|
injectStyles,
|
|
scopeId,
|
|
moduleIdentifier, /* server only */
|
|
shadowMode /* vue-cli only */
|
|
) {
|
|
// Vue.extend constructor export interop
|
|
var options = typeof scriptExports === 'function'
|
|
? scriptExports.options
|
|
: scriptExports
|
|
|
|
// render functions
|
|
if (render) {
|
|
options.render = render
|
|
options.staticRenderFns = staticRenderFns
|
|
options._compiled = true
|
|
}
|
|
|
|
// functional template
|
|
if (functionalTemplate) {
|
|
options.functional = true
|
|
}
|
|
|
|
// scopedId
|
|
if (scopeId) {
|
|
options._scopeId = 'data-v-' + scopeId
|
|
}
|
|
|
|
var hook
|
|
if (moduleIdentifier) { // server build
|
|
hook = function (context) {
|
|
// 2.3 injection
|
|
context =
|
|
context || // cached call
|
|
(this.$vnode && this.$vnode.ssrContext) || // stateful
|
|
(this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
|
|
// 2.2 with runInNewContext: true
|
|
if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
|
|
context = __VUE_SSR_CONTEXT__
|
|
}
|
|
// inject component styles
|
|
if (injectStyles) {
|
|
injectStyles.call(this, context)
|
|
}
|
|
// register component module identifier for async chunk inferrence
|
|
if (context && context._registeredComponents) {
|
|
context._registeredComponents.add(moduleIdentifier)
|
|
}
|
|
}
|
|
// used by ssr in case component is cached and beforeCreate
|
|
// never gets called
|
|
options._ssrRegister = hook
|
|
} else if (injectStyles) {
|
|
hook = shadowMode
|
|
? function () {
|
|
injectStyles.call(
|
|
this,
|
|
(options.functional ? this.parent : this).$root.$options.shadowRoot
|
|
)
|
|
}
|
|
: injectStyles
|
|
}
|
|
|
|
if (hook) {
|
|
if (options.functional) {
|
|
// for template-only hot-reload because in that case the render fn doesn't
|
|
// go through the normalizer
|
|
options._injectStyles = hook
|
|
// register for functional component in vue file
|
|
var originalRender = options.render
|
|
options.render = function renderWithStyleInjection (h, context) {
|
|
hook.call(context)
|
|
return originalRender(h, context)
|
|
}
|
|
} else {
|
|
// inject component registration as beforeCreate hook
|
|
var existing = options.beforeCreate
|
|
options.beforeCreate = existing
|
|
? [].concat(existing, hook)
|
|
: [hook]
|
|
}
|
|
}
|
|
|
|
return {
|
|
exports: scriptExports,
|
|
options: options
|
|
}
|
|
}
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 248:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony import */ var echarts_lib_chart_bar__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(114);
|
|
/* harmony import */ var echarts_lib_chart_bar__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(echarts_lib_chart_bar__WEBPACK_IMPORTED_MODULE_0__);
|
|
/* harmony import */ var _main__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(109);
|
|
/* harmony import */ var main_utils_charts_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(43);
|
|
|
|
|
|
|
|
/* harmony default export */ __webpack_exports__["default"] = (Object.assign({}, main_utils_charts_core__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"], {
|
|
name: 'VeBar',
|
|
data: function data() {
|
|
this.chartHandler = _main__WEBPACK_IMPORTED_MODULE_1__[/* bar */ "a"];
|
|
return {};
|
|
}
|
|
}));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 3:
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("utils-lite");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 31:
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("numerify");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 32:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return getFormated; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return getStackMap; });
|
|
/* unused harmony export $get */
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return getMapJSON; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getBmap; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getAmap; });
|
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return setArrayValue; });
|
|
/* harmony import */ var numerify__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(31);
|
|
/* harmony import */ var numerify__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(numerify__WEBPACK_IMPORTED_MODULE_0__);
|
|
/* harmony import */ var utils_lite__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3);
|
|
/* harmony import */ var utils_lite__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(utils_lite__WEBPACK_IMPORTED_MODULE_1__);
|
|
|
|
|
|
|
|
var getFormated = function getFormated(val, type, digit) {
|
|
var defaultVal = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '-';
|
|
|
|
if (isNaN(val)) return defaultVal;
|
|
if (!type) return val;
|
|
if (Object(utils_lite__WEBPACK_IMPORTED_MODULE_1__["isFunction"])(type)) return type(val, numerify__WEBPACK_IMPORTED_MODULE_0___default.a);
|
|
|
|
digit = isNaN(digit) ? 0 : ++digit;
|
|
var digitStr = '.[' + new Array(digit).join(0) + ']';
|
|
var formatter = type;
|
|
switch (type) {
|
|
case 'KMB':
|
|
formatter = digit ? '0,0' + digitStr + 'a' : '0,0a';
|
|
break;
|
|
case 'normal':
|
|
formatter = digit ? '0,0' + digitStr : '0,0';
|
|
break;
|
|
case 'percent':
|
|
formatter = digit ? '0,0' + digitStr + '%' : '0,0.[00]%';
|
|
break;
|
|
}
|
|
return numerify__WEBPACK_IMPORTED_MODULE_0___default()(val, formatter);
|
|
};
|
|
|
|
var getStackMap = function getStackMap(stack) {
|
|
var stackMap = {};
|
|
Object.keys(stack).forEach(function (item) {
|
|
stack[item].forEach(function (name) {
|
|
stackMap[name] = item;
|
|
});
|
|
});
|
|
return stackMap;
|
|
};
|
|
|
|
var $get = function $get(url) {
|
|
/* eslint-disable */
|
|
return new Promise(function (resolve, reject) {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open('GET', url);
|
|
xhr.send(null);
|
|
xhr.onload = function () {
|
|
resolve(JSON.parse(xhr.responseText));
|
|
};
|
|
xhr.onerror = function () {
|
|
reject(JSON.parse(xhr.responseText));
|
|
};
|
|
});
|
|
};
|
|
|
|
var mapPromise = {};
|
|
|
|
var getMapJSON = function getMapJSON(_ref) {
|
|
var position = _ref.position,
|
|
positionJsonLink = _ref.positionJsonLink,
|
|
beforeRegisterMapOnce = _ref.beforeRegisterMapOnce,
|
|
mapURLProfix = _ref.mapURLProfix;
|
|
|
|
var link = positionJsonLink || '' + mapURLProfix + position + '.json';
|
|
if (!mapPromise[link]) {
|
|
mapPromise[link] = $get(link).then(function (res) {
|
|
if (beforeRegisterMapOnce) res = beforeRegisterMapOnce(res);
|
|
return res;
|
|
});
|
|
}
|
|
return mapPromise[link];
|
|
};
|
|
|
|
var bmapPromise = null;
|
|
var amapPromise = null;
|
|
|
|
var getBmap = function getBmap(key, v) {
|
|
if (!bmapPromise) {
|
|
bmapPromise = new Promise(function (resolve, reject) {
|
|
var callbackName = 'bmap' + Date.now();
|
|
window[callbackName] = resolve;
|
|
var script = document.createElement('script');
|
|
script.src = ['https://api.map.baidu.com/api?v=' + (v || '2.0'), 'ak=' + key, 'callback=' + callbackName].join('&');
|
|
|
|
document.body.appendChild(script);
|
|
});
|
|
}
|
|
return bmapPromise;
|
|
};
|
|
|
|
var getAmap = function getAmap(key, v) {
|
|
if (!amapPromise) {
|
|
amapPromise = new Promise(function (resolve, reject) {
|
|
var callbackName = 'amap' + Date.now();
|
|
window[callbackName] = resolve;
|
|
var script = document.createElement('script');
|
|
script.src = ['https://webapi.amap.com/maps?v=' + (v || '1.4.3'), 'key=' + key, 'callback=' + callbackName].join('&');
|
|
|
|
document.body.appendChild(script);
|
|
});
|
|
}
|
|
return amapPromise;
|
|
};
|
|
|
|
function setArrayValue(arr, index, value) {
|
|
if (arr[index] !== undefined) {
|
|
arr[index].push(value);
|
|
} else {
|
|
arr[index] = [value];
|
|
}
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 39:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var content = __webpack_require__(57);
|
|
|
|
if(typeof content === 'string') content = [[module.i, content, '']];
|
|
|
|
var transform;
|
|
var insertInto;
|
|
|
|
|
|
|
|
var options = {"hmr":true}
|
|
|
|
options.transform = transform
|
|
options.insertInto = undefined;
|
|
|
|
var update = __webpack_require__(6)(content, options);
|
|
|
|
if(content.locals) module.exports = content.locals;
|
|
|
|
if(false) {}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 40:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var content = __webpack_require__(59);
|
|
|
|
if(typeof content === 'string') content = [[module.i, content, '']];
|
|
|
|
var transform;
|
|
var insertInto;
|
|
|
|
|
|
|
|
var options = {"hmr":true}
|
|
|
|
options.transform = transform
|
|
options.insertInto = undefined;
|
|
|
|
var update = __webpack_require__(6)(content, options);
|
|
|
|
if(content.locals) module.exports = content.locals;
|
|
|
|
if(false) {}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 43:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// EXTERNAL MODULE: external "echarts/lib/echarts"
|
|
var echarts_ = __webpack_require__(17);
|
|
var echarts_default = /*#__PURE__*/__webpack_require__.n(echarts_);
|
|
|
|
// EXTERNAL MODULE: external "echarts/lib/component/tooltip"
|
|
var tooltip_ = __webpack_require__(54);
|
|
|
|
// EXTERNAL MODULE: external "echarts/lib/component/legend"
|
|
var legend_ = __webpack_require__(55);
|
|
|
|
// EXTERNAL MODULE: external "numerify"
|
|
var external_numerify_ = __webpack_require__(31);
|
|
var external_numerify_default = /*#__PURE__*/__webpack_require__.n(external_numerify_);
|
|
|
|
// EXTERNAL MODULE: external "utils-lite"
|
|
var external_utils_lite_ = __webpack_require__(3);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./src/utils/charts/components/loading.vue?vue&type=template&id=6d18fb16&
|
|
var loadingvue_type_template_id_6d18fb16_render = function() {
|
|
var _vm = this
|
|
var _h = _vm.$createElement
|
|
var _c = _vm._self._c || _h
|
|
return _c("div", { staticClass: "v-charts-component-loading" }, [
|
|
_c("div", { staticClass: "loader" }, [
|
|
_c("div", { staticClass: "loading-spinner" }, [
|
|
_c(
|
|
"svg",
|
|
{ staticClass: "circular", attrs: { viewBox: "25 25 50 50" } },
|
|
[
|
|
_c("circle", {
|
|
staticClass: "path",
|
|
attrs: { cx: "50", cy: "50", r: "20", fill: "none" }
|
|
})
|
|
]
|
|
)
|
|
])
|
|
])
|
|
])
|
|
}
|
|
var staticRenderFns = []
|
|
loadingvue_type_template_id_6d18fb16_render._withStripped = true
|
|
|
|
|
|
// CONCATENATED MODULE: ./src/utils/charts/components/loading.vue?vue&type=template&id=6d18fb16&
|
|
|
|
// EXTERNAL MODULE: ./src/utils/charts/components/loading.vue?vue&type=style&index=0&lang=css&
|
|
var loadingvue_type_style_index_0_lang_css_ = __webpack_require__(56);
|
|
|
|
// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
|
|
var componentNormalizer = __webpack_require__(2);
|
|
|
|
// CONCATENATED MODULE: ./src/utils/charts/components/loading.vue
|
|
|
|
var script = {}
|
|
|
|
|
|
|
|
/* normalize component */
|
|
|
|
var component = Object(componentNormalizer["a" /* default */])(
|
|
script,
|
|
loadingvue_type_template_id_6d18fb16_render,
|
|
staticRenderFns,
|
|
false,
|
|
null,
|
|
null,
|
|
null
|
|
|
|
)
|
|
|
|
/* hot reload */
|
|
if (false) { var api; }
|
|
component.options.__file = "src/utils/charts/components/loading.vue"
|
|
/* harmony default export */ var loading = (component.exports);
|
|
// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./src/utils/charts/components/data-empty.vue?vue&type=template&id=1f2f0a80&
|
|
var data_emptyvue_type_template_id_1f2f0a80_render = function() {
|
|
var _vm = this
|
|
var _h = _vm.$createElement
|
|
var _c = _vm._self._c || _h
|
|
return _c("div", { staticClass: "v-charts-data-empty" }, [
|
|
_vm._v("\n 暂无数据\n")
|
|
])
|
|
}
|
|
var data_emptyvue_type_template_id_1f2f0a80_staticRenderFns = []
|
|
data_emptyvue_type_template_id_1f2f0a80_render._withStripped = true
|
|
|
|
|
|
// CONCATENATED MODULE: ./src/utils/charts/components/data-empty.vue?vue&type=template&id=1f2f0a80&
|
|
|
|
// EXTERNAL MODULE: ./src/utils/charts/components/data-empty.vue?vue&type=style&index=0&lang=css&
|
|
var data_emptyvue_type_style_index_0_lang_css_ = __webpack_require__(58);
|
|
|
|
// CONCATENATED MODULE: ./src/utils/charts/components/data-empty.vue
|
|
|
|
var data_empty_script = {}
|
|
|
|
|
|
|
|
/* normalize component */
|
|
|
|
var data_empty_component = Object(componentNormalizer["a" /* default */])(
|
|
data_empty_script,
|
|
data_emptyvue_type_template_id_1f2f0a80_render,
|
|
data_emptyvue_type_template_id_1f2f0a80_staticRenderFns,
|
|
false,
|
|
null,
|
|
null,
|
|
null
|
|
|
|
)
|
|
|
|
/* hot reload */
|
|
if (false) { var data_empty_api; }
|
|
data_empty_component.options.__file = "src/utils/charts/components/data-empty.vue"
|
|
/* harmony default export */ var data_empty = (data_empty_component.exports);
|
|
// EXTERNAL MODULE: ./src/utils/charts/constants.js
|
|
var constants = __webpack_require__(15);
|
|
|
|
// CONCATENATED MODULE: ./src/utils/charts/modules/extend.js
|
|
|
|
|
|
/* harmony default export */ var modules_extend = (function (options, extend) {
|
|
Object.keys(extend).forEach(function (attr) {
|
|
var value = extend[attr];
|
|
if (~attr.indexOf('.')) {
|
|
// eg: a.b.c a.1.b
|
|
Object(external_utils_lite_["set"])(options, attr, value);
|
|
} else if (typeof value === 'function') {
|
|
// get callback value
|
|
options[attr] = value(options[attr]);
|
|
} else {
|
|
// mixin extend value
|
|
if (Object(external_utils_lite_["isArray"])(options[attr]) && Object(external_utils_lite_["isObject"])(options[attr][0])) {
|
|
// eg: [{ xx: 1 }, { xx: 2 }]
|
|
options[attr].forEach(function (option, index) {
|
|
options[attr][index] = Object.assign({}, option, value);
|
|
});
|
|
} else if (Object(external_utils_lite_["isObject"])(options[attr])) {
|
|
// eg: { xx: 1, yy: 2 }
|
|
options[attr] = Object.assign({}, options[attr], value);
|
|
} else {
|
|
options[attr] = value;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
// CONCATENATED MODULE: ./src/utils/charts/modules/mark.js
|
|
/* harmony default export */ var mark = (function (seriesItem, marks) {
|
|
Object.keys(marks).forEach(function (key) {
|
|
if (marks[key]) seriesItem[key] = marks[key];
|
|
});
|
|
});
|
|
// CONCATENATED MODULE: ./src/utils/charts/modules/animation.js
|
|
/* harmony default export */ var animation = (function (options, animation) {
|
|
Object.keys(animation).forEach(function (key) {
|
|
options[key] = animation[key];
|
|
});
|
|
});
|
|
// CONCATENATED MODULE: ./src/utils/charts/core.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* harmony default export */ var core = __webpack_exports__["a"] = ({
|
|
render: function render(h) {
|
|
return h('div', {
|
|
class: [Object(external_utils_lite_["camelToKebab"])(this.$options.name || this.$options._componentTag)],
|
|
style: this.canvasStyle
|
|
}, [h('div', {
|
|
style: this.canvasStyle,
|
|
class: { 'v-charts-mask-status': this.dataEmpty || this.loading },
|
|
ref: 'canvas'
|
|
}), h(data_empty, {
|
|
style: { display: this.dataEmpty ? '' : 'none' }
|
|
}), h(loading, {
|
|
style: { display: this.loading ? '' : 'none' }
|
|
}), this.$slots.default]);
|
|
},
|
|
|
|
|
|
props: {
|
|
data: { type: [Object, Array], default: function _default() {
|
|
return {};
|
|
}
|
|
},
|
|
settings: { type: Object, default: function _default() {
|
|
return {};
|
|
}
|
|
},
|
|
width: { type: String, default: 'auto' },
|
|
height: { type: String, default: '400px' },
|
|
beforeConfig: { type: Function },
|
|
afterConfig: { type: Function },
|
|
afterSetOption: { type: Function },
|
|
afterSetOptionOnce: { type: Function },
|
|
events: { type: Object },
|
|
grid: { type: [Object, Array] },
|
|
colors: { type: Array },
|
|
tooltipVisible: { type: Boolean, default: true },
|
|
legendVisible: { type: Boolean, default: true },
|
|
legendPosition: { type: String },
|
|
markLine: { type: Object },
|
|
markArea: { type: Object },
|
|
markPoint: { type: Object },
|
|
visualMap: { type: [Object, Array] },
|
|
dataZoom: { type: [Object, Array] },
|
|
toolbox: { type: [Object, Array] },
|
|
initOptions: { type: Object, default: function _default() {
|
|
return {};
|
|
}
|
|
},
|
|
title: [Object, Array],
|
|
legend: [Object, Array],
|
|
xAxis: [Object, Array],
|
|
yAxis: [Object, Array],
|
|
radar: Object,
|
|
tooltip: Object,
|
|
axisPointer: [Object, Array],
|
|
brush: [Object, Array],
|
|
geo: [Object, Array],
|
|
timeline: [Object, Array],
|
|
graphic: [Object, Array],
|
|
series: [Object, Array],
|
|
backgroundColor: [Object, String],
|
|
textStyle: [Object, Array],
|
|
animation: Object,
|
|
theme: Object,
|
|
themeName: String,
|
|
loading: Boolean,
|
|
dataEmpty: Boolean,
|
|
extend: Object,
|
|
judgeWidth: { type: Boolean, default: false },
|
|
widthChangeDelay: { type: Number, default: 300 },
|
|
tooltipFormatter: { type: Function },
|
|
resizeable: { type: Boolean, default: true },
|
|
resizeDelay: { type: Number, default: 200 },
|
|
changeDelay: { type: Number, default: 0 },
|
|
setOptionOpts: { type: [Boolean, Object], default: true },
|
|
cancelResizeCheck: Boolean,
|
|
notSetUnchange: Array,
|
|
log: Boolean
|
|
},
|
|
|
|
watch: {
|
|
data: {
|
|
deep: true,
|
|
handler: function handler(v) {
|
|
if (v) {
|
|
this.changeHandler();
|
|
}
|
|
}
|
|
},
|
|
|
|
settings: {
|
|
deep: true,
|
|
handler: function handler(v) {
|
|
if (v.type && this.chartLib) this.chartHandler = this.chartLib[v.type];
|
|
this.changeHandler();
|
|
}
|
|
},
|
|
|
|
width: 'nextTickResize',
|
|
height: 'nextTickResize',
|
|
|
|
events: {
|
|
deep: true,
|
|
handler: 'createEventProxy'
|
|
},
|
|
|
|
theme: {
|
|
deep: true,
|
|
handler: 'themeChange'
|
|
},
|
|
|
|
themeName: 'themeChange',
|
|
|
|
resizeable: 'resizeableHandler'
|
|
},
|
|
|
|
computed: {
|
|
canvasStyle: function canvasStyle() {
|
|
return {
|
|
width: this.width,
|
|
height: this.height,
|
|
position: 'relative'
|
|
};
|
|
},
|
|
chartColor: function chartColor() {
|
|
return this.colors || this.theme && this.theme.color || constants["a" /* DEFAULT_COLORS */];
|
|
}
|
|
},
|
|
|
|
methods: {
|
|
dataHandler: function dataHandler() {
|
|
if (!this.chartHandler) return;
|
|
var data = this.data;
|
|
var _data = data,
|
|
_data$columns = _data.columns,
|
|
columns = _data$columns === undefined ? [] : _data$columns,
|
|
_data$rows = _data.rows,
|
|
rows = _data$rows === undefined ? [] : _data$rows;
|
|
|
|
var extra = {
|
|
tooltipVisible: this.tooltipVisible,
|
|
legendVisible: this.legendVisible,
|
|
echarts: this.echarts,
|
|
color: this.chartColor,
|
|
tooltipFormatter: this.tooltipFormatter,
|
|
_once: this._once
|
|
};
|
|
if (this.beforeConfig) data = this.beforeConfig(data);
|
|
|
|
var options = this.chartHandler(columns, rows, this.settings, extra);
|
|
if (options) {
|
|
if (typeof options.then === 'function') {
|
|
options.then(this.optionsHandler);
|
|
} else {
|
|
this.optionsHandler(options);
|
|
}
|
|
}
|
|
},
|
|
nextTickResize: function nextTickResize() {
|
|
this.$nextTick(this.resize);
|
|
},
|
|
resize: function resize() {
|
|
if (!this.cancelResizeCheck) {
|
|
if (this.$el && this.$el.clientWidth && this.$el.clientHeight) {
|
|
this.echartsResize();
|
|
}
|
|
} else {
|
|
this.echartsResize();
|
|
}
|
|
},
|
|
echartsResize: function echartsResize() {
|
|
this.echarts && this.echarts.resize();
|
|
},
|
|
optionsHandler: function optionsHandler(options) {
|
|
var _this = this;
|
|
|
|
// legend
|
|
if (this.legendPosition && options.legend) {
|
|
options.legend[this.legendPosition] = 10;
|
|
if (~['left', 'right'].indexOf(this.legendPosition)) {
|
|
options.legend.top = 'middle';
|
|
options.legend.orient = 'vertical';
|
|
}
|
|
}
|
|
// color
|
|
options.color = this.chartColor;
|
|
// echarts self settings
|
|
constants["c" /* ECHARTS_SETTINGS */].forEach(function (setting) {
|
|
if (_this[setting]) options[setting] = _this[setting];
|
|
});
|
|
// animation
|
|
if (this.animation) animation(options, this.animation);
|
|
// marks
|
|
if (this.markArea || this.markLine || this.markPoint) {
|
|
var marks = {
|
|
markArea: this.markArea,
|
|
markLine: this.markLine,
|
|
markPoint: this.markPoint
|
|
};
|
|
var series = options.series;
|
|
if (Object(external_utils_lite_["isArray"])(series)) {
|
|
series.forEach(function (item) {
|
|
mark(item, marks);
|
|
});
|
|
} else if (Object(external_utils_lite_["isObject"])(series)) {
|
|
mark(series, marks);
|
|
}
|
|
}
|
|
// change inited echarts settings
|
|
if (this.extend) modules_extend(options, this.extend);
|
|
if (this.afterConfig) options = this.afterConfig(options);
|
|
var setOptionOpts = this.setOptionOpts;
|
|
// map chart not merge
|
|
if ((this.settings.bmap || this.settings.amap) && !Object(external_utils_lite_["isObject"])(setOptionOpts)) {
|
|
setOptionOpts = false;
|
|
}
|
|
// exclude unchange options
|
|
if (this.notSetUnchange && this.notSetUnchange.length) {
|
|
this.notSetUnchange.forEach(function (item) {
|
|
var value = options[item];
|
|
if (value) {
|
|
if (Object(external_utils_lite_["isEqual"])(value, _this._store[item])) {
|
|
options[item] = undefined;
|
|
} else {
|
|
_this._store[item] = Object(external_utils_lite_["cloneDeep"])(value);
|
|
}
|
|
}
|
|
});
|
|
if (Object(external_utils_lite_["isObject"])(setOptionOpts)) {
|
|
setOptionOpts.notMerge = false;
|
|
} else {
|
|
setOptionOpts = false;
|
|
}
|
|
}
|
|
if (this._isDestroyed) return;
|
|
if (this.log) console.log(options);
|
|
console.log('options------->', options);
|
|
console.log('setOptions----->', setOptionOpts);
|
|
// 设置一些基本参数
|
|
options.legend.textStyle = {
|
|
color: '#FFF'
|
|
};
|
|
|
|
this.echarts.setOption(options, setOptionOpts);
|
|
this.$emit('ready', this.echarts, options, echarts_default.a);
|
|
if (!this._once['ready-once']) {
|
|
this._once['ready-once'] = true;
|
|
this.$emit('ready-once', this.echarts, options, echarts_default.a);
|
|
}
|
|
if (this.judgeWidth) this.judgeWidthHandler(options);
|
|
if (this.afterSetOption) this.afterSetOption(this.echarts, options, echarts_default.a);
|
|
if (this.afterSetOptionOnce && !this._once['afterSetOptionOnce']) {
|
|
this._once['afterSetOptionOnce'] = true;
|
|
this.afterSetOptionOnce(this.echarts, options, echarts_default.a);
|
|
}
|
|
},
|
|
judgeWidthHandler: function judgeWidthHandler(options) {
|
|
var _this2 = this;
|
|
|
|
var widthChangeDelay = this.widthChangeDelay,
|
|
resize = this.resize;
|
|
|
|
if (this.$el.clientWidth || this.$el.clientHeight) {
|
|
resize();
|
|
} else {
|
|
this.$nextTick(function (_) {
|
|
if (_this2.$el.clientWidth || _this2.$el.clientHeight) {
|
|
resize();
|
|
} else {
|
|
setTimeout(function (_) {
|
|
resize();
|
|
if (!_this2.$el.clientWidth || !_this2.$el.clientHeight) {
|
|
console.warn(' Can\'t get dom width or height ');
|
|
}
|
|
}, widthChangeDelay);
|
|
}
|
|
});
|
|
}
|
|
},
|
|
resizeableHandler: function resizeableHandler(resizeable) {
|
|
if (resizeable && !this._once.onresize) this.addResizeListener();
|
|
if (!resizeable && this._once.onresize) this.removeResizeListener();
|
|
},
|
|
init: function init() {
|
|
if (this.echarts) return;
|
|
var themeName = this.themeName || this.theme || constants["b" /* DEFAULT_THEME */];
|
|
this.echarts = echarts_default.a.init(this.$refs.canvas, themeName, this.initOptions);
|
|
if (this.data) this.changeHandler();
|
|
this.createEventProxy();
|
|
if (this.resizeable) this.addResizeListener();
|
|
},
|
|
addResizeListener: function addResizeListener() {
|
|
window.addEventListener('resize', this.resizeHandler);
|
|
this._once.onresize = true;
|
|
},
|
|
removeResizeListener: function removeResizeListener() {
|
|
window.removeEventListener('resize', this.resizeHandler);
|
|
this._once.onresize = false;
|
|
},
|
|
addWatchToProps: function addWatchToProps() {
|
|
var _this3 = this;
|
|
|
|
var watchedVariable = this._watchers.map(function (watcher) {
|
|
return watcher.expression;
|
|
});
|
|
Object.keys(this.$props).forEach(function (prop) {
|
|
if (!~watchedVariable.indexOf(prop) && !~constants["f" /* STATIC_PROPS */].indexOf(prop)) {
|
|
var opts = {};
|
|
if (~['[object Object]', '[object Array]'].indexOf(Object(external_utils_lite_["getType"])(_this3.$props[prop]))) {
|
|
opts.deep = true;
|
|
}
|
|
_this3.$watch(prop, function () {
|
|
_this3.changeHandler();
|
|
}, opts);
|
|
}
|
|
});
|
|
},
|
|
createEventProxy: function createEventProxy() {
|
|
var _this4 = this;
|
|
|
|
// 只要用户使用 on 方法绑定的事件都做一层代理，
|
|
// 是否真正执行相应的事件方法取决于该方法是否仍然存在 events 中
|
|
// 实现 events 的动态响应
|
|
var self = this;
|
|
var keys = Object.keys(this.events || {});
|
|
keys.length && keys.forEach(function (ev) {
|
|
if (_this4.registeredEvents.indexOf(ev) === -1) {
|
|
_this4.registeredEvents.push(ev);
|
|
_this4.echarts.on(ev, function (ev) {
|
|
return function () {
|
|
if (ev in self.events) {
|
|
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
self.events[ev].apply(null, args);
|
|
}
|
|
};
|
|
}(ev));
|
|
}
|
|
});
|
|
},
|
|
themeChange: function themeChange(theme) {
|
|
this.clean();
|
|
this.echarts = null;
|
|
this.init();
|
|
},
|
|
clean: function clean() {
|
|
if (this.resizeable) this.removeResizeListener();
|
|
this.echarts.dispose();
|
|
}
|
|
},
|
|
|
|
created: function created() {
|
|
this.echarts = null;
|
|
this.registeredEvents = [];
|
|
this._once = {};
|
|
this._store = {};
|
|
this.resizeHandler = Object(external_utils_lite_["debounce"])(this.resize, this.resizeDelay);
|
|
this.changeHandler = Object(external_utils_lite_["debounce"])(this.dataHandler, this.changeDelay);
|
|
this.addWatchToProps();
|
|
},
|
|
mounted: function mounted() {
|
|
this.init();
|
|
},
|
|
beforeDestroy: function beforeDestroy() {
|
|
this.clean();
|
|
},
|
|
|
|
|
|
_numerify: external_numerify_default.a
|
|
});
|
|
|
|
/***/ }),
|
|
|
|
/***/ 5:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
|
|
/*
|
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|
Author Tobias Koppers @sokra
|
|
*/
|
|
// css base code, injected by the css-loader
|
|
module.exports = function (useSourceMap) {
|
|
var list = []; // return the list of modules as css string
|
|
|
|
list.toString = function toString() {
|
|
return this.map(function (item) {
|
|
var content = cssWithMappingToString(item, useSourceMap);
|
|
|
|
if (item[2]) {
|
|
return '@media ' + item[2] + '{' + content + '}';
|
|
} else {
|
|
return content;
|
|
}
|
|
}).join('');
|
|
}; // import a list of modules into the list
|
|
|
|
|
|
list.i = function (modules, mediaQuery) {
|
|
if (typeof modules === 'string') {
|
|
modules = [[null, modules, '']];
|
|
}
|
|
|
|
var alreadyImportedModules = {};
|
|
|
|
for (var i = 0; i < this.length; i++) {
|
|
var id = this[i][0];
|
|
|
|
if (id != null) {
|
|
alreadyImportedModules[id] = true;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < modules.length; i++) {
|
|
var item = modules[i]; // skip already imported module
|
|
// this implementation is not 100% perfect for weird media query combinations
|
|
// when a module is imported multiple times with different media queries.
|
|
// I hope this will never occur (Hey this way we have smaller bundles)
|
|
|
|
if (item[0] == null || !alreadyImportedModules[item[0]]) {
|
|
if (mediaQuery && !item[2]) {
|
|
item[2] = mediaQuery;
|
|
} else if (mediaQuery) {
|
|
item[2] = '(' + item[2] + ') and (' + mediaQuery + ')';
|
|
}
|
|
|
|
list.push(item);
|
|
}
|
|
}
|
|
};
|
|
|
|
return list;
|
|
};
|
|
|
|
function cssWithMappingToString(item, useSourceMap) {
|
|
var content = item[1] || '';
|
|
var cssMapping = item[3];
|
|
|
|
if (!cssMapping) {
|
|
return content;
|
|
}
|
|
|
|
if (useSourceMap && typeof btoa === 'function') {
|
|
var sourceMapping = toComment(cssMapping);
|
|
var sourceURLs = cssMapping.sources.map(function (source) {
|
|
return '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */';
|
|
});
|
|
return [content].concat(sourceURLs).concat([sourceMapping]).join('\n');
|
|
}
|
|
|
|
return [content].join('\n');
|
|
} // Adapted from convert-source-map (MIT)
|
|
|
|
|
|
function toComment(sourceMap) {
|
|
// eslint-disable-next-line no-undef
|
|
var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));
|
|
var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64;
|
|
return '/*# ' + data + ' */';
|
|
}
|
|
|
|
/***/ }),
|
|
|
|
/***/ 54:
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("echarts/lib/component/tooltip");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 55:
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = require("echarts/lib/component/legend");
|
|
|
|
/***/ }),
|
|
|
|
/***/ 56:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony import */ var _node_modules_style_loader_index_js_node_modules_css_loader_dist_cjs_js_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_vue_loader_lib_index_js_vue_loader_options_loading_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(39);
|
|
/* harmony import */ var _node_modules_style_loader_index_js_node_modules_css_loader_dist_cjs_js_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_vue_loader_lib_index_js_vue_loader_options_loading_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_index_js_node_modules_css_loader_dist_cjs_js_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_vue_loader_lib_index_js_vue_loader_options_loading_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0__);
|
|
/* unused harmony reexport * */
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 57:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
exports = module.exports = __webpack_require__(5)(false);
|
|
// Module
|
|
exports.push([module.i, "\n.v-charts-component-loading {\n position: absolute;\n left: 0;\n right: 0;\n top: 0;\n bottom: 0;\n display: flex;\n justify-content: center;\n align-items: center;\n background-color: rgba(255, 255, 255, .9);\n}\n.v-charts-mask-status {\n filter: blur(1px);\n}\n.v-charts-component-loading .circular {\n width: 42px;\n height: 42px;\n animation: loading-rotate 2s linear infinite;\n}\n.v-charts-component-loading .path {\n animation: loading-dash 1.5s ease-in-out infinite;\n stroke-dasharray: 90,150;\n stroke-dashoffset: 0;\n stroke-width: 2;\n stroke: #20a0ff;\n stroke-linecap: round;\n}\n@keyframes loading-rotate {\n100% {\n transform: rotate(360deg);\n}\n}\n@keyframes loading-dash {\n0% {\n stroke-dasharray: 1, 200;\n stroke-dashoffset: 0;\n}\n50% {\n stroke-dasharray: 90, 150;\n stroke-dashoffset: -40px;\n}\n100% {\n stroke-dasharray: 90, 150;\n stroke-dashoffset: -120px;\n}\n}\n", ""]);
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 58:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* harmony import */ var _node_modules_style_loader_index_js_node_modules_css_loader_dist_cjs_js_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_vue_loader_lib_index_js_vue_loader_options_data_empty_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(40);
|
|
/* harmony import */ var _node_modules_style_loader_index_js_node_modules_css_loader_dist_cjs_js_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_vue_loader_lib_index_js_vue_loader_options_data_empty_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_index_js_node_modules_css_loader_dist_cjs_js_node_modules_vue_loader_lib_loaders_stylePostLoader_js_node_modules_vue_loader_lib_index_js_vue_loader_options_data_empty_vue_vue_type_style_index_0_lang_css___WEBPACK_IMPORTED_MODULE_0__);
|
|
/* unused harmony reexport * */
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 59:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
exports = module.exports = __webpack_require__(5)(false);
|
|
// Module
|
|
exports.push([module.i, "\n.v-charts-data-empty {\n position: absolute;\n left: 0;\n right: 0;\n top: 0;\n bottom: 0;\n display: flex;\n justify-content: center;\n align-items: center;\n background-color: rgba(255, 255, 255, .9);\n color: #888;\n font-size: 14px;\n}\n", ""]);
|
|
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 6:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/*
|
|
MIT License http://www.opensource.org/licenses/mit-license.php
|
|
Author Tobias Koppers @sokra
|
|
*/
|
|
|
|
var stylesInDom = {};
|
|
|
|
var memoize = function (fn) {
|
|
var memo;
|
|
|
|
return function () {
|
|
if (typeof memo === "undefined") memo = fn.apply(this, arguments);
|
|
return memo;
|
|
};
|
|
};
|
|
|
|
var isOldIE = memoize(function () {
|
|
// Test for IE <= 9 as proposed by Browserhacks
|
|
// @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805
|
|
// Tests for existence of standard globals is to allow style-loader
|
|
// to operate correctly into non-standard environments
|
|
// @see https://github.com/webpack-contrib/style-loader/issues/177
|
|
return window && document && document.all && !window.atob;
|
|
});
|
|
|
|
var getTarget = function (target, parent) {
|
|
if (parent){
|
|
return parent.querySelector(target);
|
|
}
|
|
return document.querySelector(target);
|
|
};
|
|
|
|
var getElement = (function (fn) {
|
|
var memo = {};
|
|
|
|
return function(target, parent) {
|
|
// If passing function in options, then use it for resolve "head" element.
|
|
// Useful for Shadow Root style i.e
|
|
// {
|
|
// insertInto: function () { return document.querySelector("#foo").shadowRoot }
|
|
// }
|
|
if (typeof target === 'function') {
|
|
return target();
|
|
}
|
|
if (typeof memo[target] === "undefined") {
|
|
var styleTarget = getTarget.call(this, target, parent);
|
|
// Special case to return head of iframe instead of iframe itself
|
|
if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
|
|
try {
|
|
// This will throw an exception if access to iframe is blocked
|
|
// due to cross-origin restrictions
|
|
styleTarget = styleTarget.contentDocument.head;
|
|
} catch(e) {
|
|
styleTarget = null;
|
|
}
|
|
}
|
|
memo[target] = styleTarget;
|
|
}
|
|
return memo[target]
|
|
};
|
|
})();
|
|
|
|
var singleton = null;
|
|
var singletonCounter = 0;
|
|
var stylesInsertedAtTop = [];
|
|
|
|
var fixUrls = __webpack_require__(12);
|
|
|
|
module.exports = function(list, options) {
|
|
if (typeof DEBUG !== "undefined" && DEBUG) {
|
|
if (typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
|
|
}
|
|
|
|
options = options || {};
|
|
|
|
options.attrs = typeof options.attrs === "object" ? options.attrs : {};
|
|
|
|
// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
|
|
// tags it will allow on a page
|
|
if (!options.singleton && typeof options.singleton !== "boolean") options.singleton = isOldIE();
|
|
|
|
// By default, add <style> tags to the <head> element
|
|
if (!options.insertInto) options.insertInto = "head";
|
|
|
|
// By default, add <style> tags to the bottom of the target
|
|
if (!options.insertAt) options.insertAt = "bottom";
|
|
|
|
var styles = listToStyles(list, options);
|
|
|
|
addStylesToDom(styles, options);
|
|
|
|
return function update (newList) {
|
|
var mayRemove = [];
|
|
|
|
for (var i = 0; i < styles.length; i++) {
|
|
var item = styles[i];
|
|
var domStyle = stylesInDom[item.id];
|
|
|
|
domStyle.refs--;
|
|
mayRemove.push(domStyle);
|
|
}
|
|
|
|
if(newList) {
|
|
var newStyles = listToStyles(newList, options);
|
|
addStylesToDom(newStyles, options);
|
|
}
|
|
|
|
for (var i = 0; i < mayRemove.length; i++) {
|
|
var domStyle = mayRemove[i];
|
|
|
|
if(domStyle.refs === 0) {
|
|
for (var j = 0; j < domStyle.parts.length; j++) domStyle.parts[j]();
|
|
|
|
delete stylesInDom[domStyle.id];
|
|
}
|
|
}
|
|
};
|
|
};
|
|
|
|
function addStylesToDom (styles, options) {
|
|
for (var i = 0; i < styles.length; i++) {
|
|
var item = styles[i];
|
|
var domStyle = stylesInDom[item.id];
|
|
|
|
if(domStyle) {
|
|
domStyle.refs++;
|
|
|
|
for(var j = 0; j < domStyle.parts.length; j++) {
|
|
domStyle.parts[j](item.parts[j]);
|
|
}
|
|
|
|
for(; j < item.parts.length; j++) {
|
|
domStyle.parts.push(addStyle(item.parts[j], options));
|
|
}
|
|
} else {
|
|
var parts = [];
|
|
|
|
for(var j = 0; j < item.parts.length; j++) {
|
|
parts.push(addStyle(item.parts[j], options));
|
|
}
|
|
|
|
stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
|
|
}
|
|
}
|
|
}
|
|
|
|
function listToStyles (list, options) {
|
|
var styles = [];
|
|
var newStyles = {};
|
|
|
|
for (var i = 0; i < list.length; i++) {
|
|
var item = list[i];
|
|
var id = options.base ? item[0] + options.base : item[0];
|
|
var css = item[1];
|
|
var media = item[2];
|
|
var sourceMap = item[3];
|
|
var part = {css: css, media: media, sourceMap: sourceMap};
|
|
|
|
if(!newStyles[id]) styles.push(newStyles[id] = {id: id, parts: [part]});
|
|
else newStyles[id].parts.push(part);
|
|
}
|
|
|
|
return styles;
|
|
}
|
|
|
|
function insertStyleElement (options, style) {
|
|
var target = getElement(options.insertInto)
|
|
|
|
if (!target) {
|
|
throw new Error("Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid.");
|
|
}
|
|
|
|
var lastStyleElementInsertedAtTop = stylesInsertedAtTop[stylesInsertedAtTop.length - 1];
|
|
|
|
if (options.insertAt === "top") {
|
|
if (!lastStyleElementInsertedAtTop) {
|
|
target.insertBefore(style, target.firstChild);
|
|
} else if (lastStyleElementInsertedAtTop.nextSibling) {
|
|
target.insertBefore(style, lastStyleElementInsertedAtTop.nextSibling);
|
|
} else {
|
|
target.appendChild(style);
|
|
}
|
|
stylesInsertedAtTop.push(style);
|
|
} else if (options.insertAt === "bottom") {
|
|
target.appendChild(style);
|
|
} else if (typeof options.insertAt === "object" && options.insertAt.before) {
|
|
var nextSibling = getElement(options.insertAt.before, target);
|
|
target.insertBefore(style, nextSibling);
|
|
} else {
|
|
throw new Error("[Style Loader]\n\n Invalid value for parameter 'insertAt' ('options.insertAt') found.\n Must be 'top', 'bottom', or Object.\n (https://github.com/webpack-contrib/style-loader#insertat)\n");
|
|
}
|
|
}
|
|
|
|
function removeStyleElement (style) {
|
|
if (style.parentNode === null) return false;
|
|
style.parentNode.removeChild(style);
|
|
|
|
var idx = stylesInsertedAtTop.indexOf(style);
|
|
if(idx >= 0) {
|
|
stylesInsertedAtTop.splice(idx, 1);
|
|
}
|
|
}
|
|
|
|
function createStyleElement (options) {
|
|
var style = document.createElement("style");
|
|
|
|
if(options.attrs.type === undefined) {
|
|
options.attrs.type = "text/css";
|
|
}
|
|
|
|
if(options.attrs.nonce === undefined) {
|
|
var nonce = getNonce();
|
|
if (nonce) {
|
|
options.attrs.nonce = nonce;
|
|
}
|
|
}
|
|
|
|
addAttrs(style, options.attrs);
|
|
insertStyleElement(options, style);
|
|
|
|
return style;
|
|
}
|
|
|
|
function createLinkElement (options) {
|
|
var link = document.createElement("link");
|
|
|
|
if(options.attrs.type === undefined) {
|
|
options.attrs.type = "text/css";
|
|
}
|
|
options.attrs.rel = "stylesheet";
|
|
|
|
addAttrs(link, options.attrs);
|
|
insertStyleElement(options, link);
|
|
|
|
return link;
|
|
}
|
|
|
|
function addAttrs (el, attrs) {
|
|
Object.keys(attrs).forEach(function (key) {
|
|
el.setAttribute(key, attrs[key]);
|
|
});
|
|
}
|
|
|
|
function getNonce() {
|
|
if (false) {}
|
|
|
|
return __webpack_require__.nc;
|
|
}
|
|
|
|
function addStyle (obj, options) {
|
|
var style, update, remove, result;
|
|
|
|
// If a transform function was defined, run it on the css
|
|
if (options.transform && obj.css) {
|
|
result = typeof options.transform === 'function'
|
|
? options.transform(obj.css)
|
|
: options.transform.default(obj.css);
|
|
|
|
if (result) {
|
|
// If transform returns a value, use that instead of the original css.
|
|
// This allows running runtime transformations on the css.
|
|
obj.css = result;
|
|
} else {
|
|
// If the transform function returns a falsy value, don't add this css.
|
|
// This allows conditional loading of css
|
|
return function() {
|
|
// noop
|
|
};
|
|
}
|
|
}
|
|
|
|
if (options.singleton) {
|
|
var styleIndex = singletonCounter++;
|
|
|
|
style = singleton || (singleton = createStyleElement(options));
|
|
|
|
update = applyToSingletonTag.bind(null, style, styleIndex, false);
|
|
remove = applyToSingletonTag.bind(null, style, styleIndex, true);
|
|
|
|
} else if (
|
|
obj.sourceMap &&
|
|
typeof URL === "function" &&
|
|
typeof URL.createObjectURL === "function" &&
|
|
typeof URL.revokeObjectURL === "function" &&
|
|
typeof Blob === "function" &&
|
|
typeof btoa === "function"
|
|
) {
|
|
style = createLinkElement(options);
|
|
update = updateLink.bind(null, style, options);
|
|
remove = function () {
|
|
removeStyleElement(style);
|
|
|
|
if(style.href) URL.revokeObjectURL(style.href);
|
|
};
|
|
} else {
|
|
style = createStyleElement(options);
|
|
update = applyToTag.bind(null, style);
|
|
remove = function () {
|
|
removeStyleElement(style);
|
|
};
|
|
}
|
|
|
|
update(obj);
|
|
|
|
return function updateStyle (newObj) {
|
|
if (newObj) {
|
|
if (
|
|
newObj.css === obj.css &&
|
|
newObj.media === obj.media &&
|
|
newObj.sourceMap === obj.sourceMap
|
|
) {
|
|
return;
|
|
}
|
|
|
|
update(obj = newObj);
|
|
} else {
|
|
remove();
|
|
}
|
|
};
|
|
}
|
|
|
|
var replaceText = (function () {
|
|
var textStore = [];
|
|
|
|
return function (index, replacement) {
|
|
textStore[index] = replacement;
|
|
|
|
return textStore.filter(Boolean).join('\n');
|
|
};
|
|
})();
|
|
|
|
function applyToSingletonTag (style, index, remove, obj) {
|
|
var css = remove ? "" : obj.css;
|
|
|
|
if (style.styleSheet) {
|
|
style.styleSheet.cssText = replaceText(index, css);
|
|
} else {
|
|
var cssNode = document.createTextNode(css);
|
|
var childNodes = style.childNodes;
|
|
|
|
if (childNodes[index]) style.removeChild(childNodes[index]);
|
|
|
|
if (childNodes.length) {
|
|
style.insertBefore(cssNode, childNodes[index]);
|
|
} else {
|
|
style.appendChild(cssNode);
|
|
}
|
|
}
|
|
}
|
|
|
|
function applyToTag (style, obj) {
|
|
var css = obj.css;
|
|
var media = obj.media;
|
|
|
|
if(media) {
|
|
style.setAttribute("media", media)
|
|
}
|
|
|
|
if(style.styleSheet) {
|
|
style.styleSheet.cssText = css;
|
|
} else {
|
|
while(style.firstChild) {
|
|
style.removeChild(style.firstChild);
|
|
}
|
|
|
|
style.appendChild(document.createTextNode(css));
|
|
}
|
|
}
|
|
|
|
function updateLink (link, options, obj) {
|
|
var css = obj.css;
|
|
var sourceMap = obj.sourceMap;
|
|
|
|
/*
|
|
If convertToAbsoluteUrls isn't defined, but sourcemaps are enabled
|
|
and there is no publicPath defined then lets turn convertToAbsoluteUrls
|
|
on by default. Otherwise default to the convertToAbsoluteUrls option
|
|
directly
|
|
*/
|
|
var autoFixUrls = options.convertToAbsoluteUrls === undefined && sourceMap;
|
|
|
|
if (options.convertToAbsoluteUrls || autoFixUrls) {
|
|
css = fixUrls(css);
|
|
}
|
|
|
|
if (sourceMap) {
|
|
// http://stackoverflow.com/a/26603875
|
|
css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
|
|
}
|
|
|
|
var blob = new Blob([css], { type: "text/css" });
|
|
|
|
var oldSrc = link.href;
|
|
|
|
link.href = URL.createObjectURL(blob);
|
|
|
|
if(oldSrc) URL.revokeObjectURL(oldSrc);
|
|
}
|
|
|
|
|
|
/***/ })
|
|
|
|
/******/ });
|