office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/chart/boxplot/BoxplotSeries.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Series = require('../../model/Series.js');
+var whiskerBoxCommon = require('../helper/whiskerBoxCommon.js');
+var util = require('../../../../zrender/lib/core/util.js');
+
+var BoxplotSeriesModel = /** @class */function (_super) {
+  tslib.__extends(BoxplotSeriesModel, _super);
+  function BoxplotSeriesModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = BoxplotSeriesModel.type;
+    // TODO
+    // box width represents group size, so dimension should have 'size'.
+    /**
+     * @see <https://en.wikipedia.org/wiki/Box_plot>
+     * The meanings of 'min' and 'max' depend on user,
+     * and echarts do not need to know it.
+     * @readOnly
+     */
+    _this.defaultValueDimensions = [{
+      name: 'min',
+      defaultTooltip: true
+    }, {
+      name: 'Q1',
+      defaultTooltip: true
+    }, {
+      name: 'median',
+      defaultTooltip: true
+    }, {
+      name: 'Q3',
+      defaultTooltip: true
+    }, {
+      name: 'max',
+      defaultTooltip: true
+    }];
+    _this.visualDrawType = 'stroke';
+    return _this;
+  }
+  BoxplotSeriesModel.type = 'series.boxplot';
+  BoxplotSeriesModel.dependencies = ['xAxis', 'yAxis', 'grid'];
+  BoxplotSeriesModel.defaultOption = {
+    // zlevel: 0,
+    z: 2,
+    coordinateSystem: 'cartesian2d',
+    legendHoverLink: true,
+    layout: null,
+    boxWidth: [7, 50],
+    itemStyle: {
+      color: '#fff',
+      borderWidth: 1
+    },
+    emphasis: {
+      scale: true,
+      itemStyle: {
+        borderWidth: 2,
+        shadowBlur: 5,
+        shadowOffsetX: 1,
+        shadowOffsetY: 1,
+        shadowColor: 'rgba(0,0,0,0.2)'
+      }
+    },
+    animationDuration: 800
+  };
+  return BoxplotSeriesModel;
+}(Series["default"]);
+util.mixin(BoxplotSeriesModel, whiskerBoxCommon.WhiskerBoxCommonMixin, true);
+
+exports["default"] = BoxplotSeriesModel;

package/lib/node_modules/echarts/lib/chart/boxplot/BoxplotView.js

@@ -0,0 +1,135 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../../../../zrender/lib/core/util.js');
+var Chart = require('../../view/Chart.js');
+var graphic = require('../../util/graphic.js');
+var states = require('../../util/states.js');
+var Path = require('../../../../zrender/lib/graphic/Path.js');
+var basicTransition = require('../../animation/basicTransition.js');
+
+var BoxplotView = /** @class */function (_super) {
+  tslib.__extends(BoxplotView, _super);
+  function BoxplotView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = BoxplotView.type;
+    return _this;
+  }
+  BoxplotView.prototype.render = function (seriesModel, ecModel, api) {
+    var data = seriesModel.getData();
+    var group = this.group;
+    var oldData = this._data;
+    // There is no old data only when first rendering or switching from
+    // stream mode to normal mode, where previous elements should be removed.
+    if (!this._data) {
+      group.removeAll();
+    }
+    var constDim = seriesModel.get('layout') === 'horizontal' ? 1 : 0;
+    data.diff(oldData).add(function (newIdx) {
+      if (data.hasValue(newIdx)) {
+        var itemLayout = data.getItemLayout(newIdx);
+        var symbolEl = createNormalBox(itemLayout, data, newIdx, constDim, true);
+        data.setItemGraphicEl(newIdx, symbolEl);
+        group.add(symbolEl);
+      }
+    }).update(function (newIdx, oldIdx) {
+      var symbolEl = oldData.getItemGraphicEl(oldIdx);
+      // Empty data
+      if (!data.hasValue(newIdx)) {
+        group.remove(symbolEl);
+        return;
+      }
+      var itemLayout = data.getItemLayout(newIdx);
+      if (!symbolEl) {
+        symbolEl = createNormalBox(itemLayout, data, newIdx, constDim);
+      } else {
+        basicTransition.saveOldStyle(symbolEl);
+        updateNormalBoxData(itemLayout, symbolEl, data, newIdx);
+      }
+      group.add(symbolEl);
+      data.setItemGraphicEl(newIdx, symbolEl);
+    }).remove(function (oldIdx) {
+      var el = oldData.getItemGraphicEl(oldIdx);
+      el && group.remove(el);
+    }).execute();
+    this._data = data;
+  };
+  BoxplotView.prototype.remove = function (ecModel) {
+    var group = this.group;
+    var data = this._data;
+    this._data = null;
+    data && data.eachItemGraphicEl(function (el) {
+      el && group.remove(el);
+    });
+  };
+  BoxplotView.type = 'boxplot';
+  return BoxplotView;
+}(Chart["default"]);
+var BoxPathShape = /** @class */function () {
+  function BoxPathShape() {}
+  return BoxPathShape;
+}();
+var BoxPath = /** @class */function (_super) {
+  tslib.__extends(BoxPath, _super);
+  function BoxPath(opts) {
+    var _this = _super.call(this, opts) || this;
+    _this.type = 'boxplotBoxPath';
+    return _this;
+  }
+  BoxPath.prototype.getDefaultShape = function () {
+    return new BoxPathShape();
+  };
+  BoxPath.prototype.buildPath = function (ctx, shape) {
+    var ends = shape.points;
+    var i = 0;
+    ctx.moveTo(ends[i][0], ends[i][1]);
+    i++;
+    for (; i < 4; i++) {
+      ctx.lineTo(ends[i][0], ends[i][1]);
+    }
+    ctx.closePath();
+    for (; i < ends.length; i++) {
+      ctx.moveTo(ends[i][0], ends[i][1]);
+      i++;
+      ctx.lineTo(ends[i][0], ends[i][1]);
+    }
+  };
+  return BoxPath;
+}(Path["default"]);
+function createNormalBox(itemLayout, data, dataIndex, constDim, isInit) {
+  var ends = itemLayout.ends;
+  var el = new BoxPath({
+    shape: {
+      points: isInit ? transInit(ends, constDim, itemLayout) : ends
+    }
+  });
+  updateNormalBoxData(itemLayout, el, data, dataIndex, isInit);
+  return el;
+}
+function updateNormalBoxData(itemLayout, el, data, dataIndex, isInit) {
+  var seriesModel = data.hostModel;
+  var updateMethod = graphic[isInit ? 'initProps' : 'updateProps'];
+  updateMethod(el, {
+    shape: {
+      points: itemLayout.ends
+    }
+  }, seriesModel, dataIndex);
+  el.useStyle(data.getItemVisual(dataIndex, 'style'));
+  el.style.strokeNoScale = true;
+  el.z2 = 100;
+  var itemModel = data.getItemModel(dataIndex);
+  var emphasisModel = itemModel.getModel('emphasis');
+  states.setStatesStylesFromModel(el, itemModel);
+  states.toggleHoverEmphasis(el, emphasisModel.get('focus'), emphasisModel.get('blurScope'), emphasisModel.get('disabled'));
+}
+function transInit(points, dim, itemLayout) {
+  return util.map(points, function (point) {
+    point = point.slice();
+    point[dim] = itemLayout.initBaseline;
+    return point;
+  });
+}
+
+exports["default"] = BoxplotView;

package/lib/node_modules/echarts/lib/chart/boxplot/boxplotLayout.js

@@ -0,0 +1,145 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../zrender/lib/core/util.js');
+var number = require('../../util/number.js');
+
+var each = util.each;
+function boxplotLayout(ecModel) {
+  var groupResult = groupSeriesByAxis(ecModel);
+  each(groupResult, function (groupItem) {
+    var seriesModels = groupItem.seriesModels;
+    if (!seriesModels.length) {
+      return;
+    }
+    calculateBase(groupItem);
+    each(seriesModels, function (seriesModel, idx) {
+      layoutSingleSeries(seriesModel, groupItem.boxOffsetList[idx], groupItem.boxWidthList[idx]);
+    });
+  });
+}
+/**
+ * Group series by axis.
+ */
+function groupSeriesByAxis(ecModel) {
+  var result = [];
+  var axisList = [];
+  ecModel.eachSeriesByType('boxplot', function (seriesModel) {
+    var baseAxis = seriesModel.getBaseAxis();
+    var idx = util.indexOf(axisList, baseAxis);
+    if (idx < 0) {
+      idx = axisList.length;
+      axisList[idx] = baseAxis;
+      result[idx] = {
+        axis: baseAxis,
+        seriesModels: []
+      };
+    }
+    result[idx].seriesModels.push(seriesModel);
+  });
+  return result;
+}
+/**
+ * Calculate offset and box width for each series.
+ */
+function calculateBase(groupItem) {
+  var baseAxis = groupItem.axis;
+  var seriesModels = groupItem.seriesModels;
+  var seriesCount = seriesModels.length;
+  var boxWidthList = groupItem.boxWidthList = [];
+  var boxOffsetList = groupItem.boxOffsetList = [];
+  var boundList = [];
+  var bandWidth;
+  if (baseAxis.type === 'category') {
+    bandWidth = baseAxis.getBandWidth();
+  } else {
+    var maxDataCount_1 = 0;
+    each(seriesModels, function (seriesModel) {
+      maxDataCount_1 = Math.max(maxDataCount_1, seriesModel.getData().count());
+    });
+    var extent = baseAxis.getExtent();
+    bandWidth = Math.abs(extent[1] - extent[0]) / maxDataCount_1;
+  }
+  each(seriesModels, function (seriesModel) {
+    var boxWidthBound = seriesModel.get('boxWidth');
+    if (!util.isArray(boxWidthBound)) {
+      boxWidthBound = [boxWidthBound, boxWidthBound];
+    }
+    boundList.push([number.parsePercent(boxWidthBound[0], bandWidth) || 0, number.parsePercent(boxWidthBound[1], bandWidth) || 0]);
+  });
+  var availableWidth = bandWidth * 0.8 - 2;
+  var boxGap = availableWidth / seriesCount * 0.3;
+  var boxWidth = (availableWidth - boxGap * (seriesCount - 1)) / seriesCount;
+  var base = boxWidth / 2 - availableWidth / 2;
+  each(seriesModels, function (seriesModel, idx) {
+    boxOffsetList.push(base);
+    base += boxGap + boxWidth;
+    boxWidthList.push(Math.min(Math.max(boxWidth, boundList[idx][0]), boundList[idx][1]));
+  });
+}
+/**
+ * Calculate points location for each series.
+ */
+function layoutSingleSeries(seriesModel, offset, boxWidth) {
+  var coordSys = seriesModel.coordinateSystem;
+  var data = seriesModel.getData();
+  var halfWidth = boxWidth / 2;
+  var cDimIdx = seriesModel.get('layout') === 'horizontal' ? 0 : 1;
+  var vDimIdx = 1 - cDimIdx;
+  var coordDims = ['x', 'y'];
+  var cDim = data.mapDimension(coordDims[cDimIdx]);
+  var vDims = data.mapDimensionsAll(coordDims[vDimIdx]);
+  if (cDim == null || vDims.length < 5) {
+    return;
+  }
+  for (var dataIndex = 0; dataIndex < data.count(); dataIndex++) {
+    var axisDimVal = data.get(cDim, dataIndex);
+    var median = getPoint(axisDimVal, vDims[2], dataIndex);
+    var end1 = getPoint(axisDimVal, vDims[0], dataIndex);
+    var end2 = getPoint(axisDimVal, vDims[1], dataIndex);
+    var end4 = getPoint(axisDimVal, vDims[3], dataIndex);
+    var end5 = getPoint(axisDimVal, vDims[4], dataIndex);
+    var ends = [];
+    addBodyEnd(ends, end2, false);
+    addBodyEnd(ends, end4, true);
+    ends.push(end1, end2, end5, end4);
+    layEndLine(ends, end1);
+    layEndLine(ends, end5);
+    layEndLine(ends, median);
+    data.setItemLayout(dataIndex, {
+      initBaseline: median[vDimIdx],
+      ends: ends
+    });
+  }
+  function getPoint(axisDimVal, dim, dataIndex) {
+    var val = data.get(dim, dataIndex);
+    var p = [];
+    p[cDimIdx] = axisDimVal;
+    p[vDimIdx] = val;
+    var point;
+    if (isNaN(axisDimVal) || isNaN(val)) {
+      point = [NaN, NaN];
+    } else {
+      point = coordSys.dataToPoint(p);
+      point[cDimIdx] += offset;
+    }
+    return point;
+  }
+  function addBodyEnd(ends, point, start) {
+    var point1 = point.slice();
+    var point2 = point.slice();
+    point1[cDimIdx] += halfWidth;
+    point2[cDimIdx] -= halfWidth;
+    start ? ends.push(point1, point2) : ends.push(point2, point1);
+  }
+  function layEndLine(ends, endCenter) {
+    var from = endCenter.slice();
+    var to = endCenter.slice();
+    from[cDimIdx] -= halfWidth;
+    to[cDimIdx] += halfWidth;
+    ends.push(from, to);
+  }
+}
+
+exports["default"] = boxplotLayout;

package/lib/node_modules/echarts/lib/chart/boxplot/boxplotTransform.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var prepareBoxplotData = require('./prepareBoxplotData.js');
+var log = require('../../util/log.js');
+var types = require('../../util/types.js');
+
+var boxplotTransform = {
+  type: 'echarts:boxplot',
+  transform: function transform(params) {
+    var upstream = params.upstream;
+    if (upstream.sourceFormat !== types.SOURCE_FORMAT_ARRAY_ROWS) {
+      var errMsg = '';
+      if (process.env.NODE_ENV !== 'production') {
+        errMsg = log.makePrintable('source data is not applicable for this boxplot transform. Expect number[][].');
+      }
+      log.throwError(errMsg);
+    }
+    var result = prepareBoxplotData["default"](upstream.getRawData(), params.config);
+    return [{
+      dimensions: ['ItemName', 'Low', 'Q1', 'Q2', 'Q3', 'High'],
+      data: result.boxData
+    }, {
+      data: result.outliers
+    }];
+  }
+};
+
+exports.boxplotTransform = boxplotTransform;

package/lib/node_modules/echarts/lib/chart/boxplot/install.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var BoxplotSeries = require('./BoxplotSeries.js');
+var BoxplotView = require('./BoxplotView.js');
+var boxplotLayout = require('./boxplotLayout.js');
+var boxplotTransform = require('./boxplotTransform.js');
+
+function install(registers) {
+  registers.registerSeriesModel(BoxplotSeries["default"]);
+  registers.registerChartView(BoxplotView["default"]);
+  registers.registerLayout(boxplotLayout["default"]);
+  registers.registerTransform(boxplotTransform.boxplotTransform);
+}
+
+exports.install = install;

package/lib/node_modules/echarts/lib/chart/boxplot/prepareBoxplotData.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var number = require('../../util/number.js');
+var util = require('../../../../zrender/lib/core/util.js');
+
+/**
+ * See:
+ *  <https://en.wikipedia.org/wiki/Box_plot#cite_note-frigge_hoaglin_iglewicz-2>
+ *  <http://stat.ethz.ch/R-manual/R-devel/library/grDevices/html/boxplot.stats.html>
+ *
+ * Helper method for preparing data.
+ *
+ * @param rawData like
+ *        [
+ *            [12,232,443], (raw data set for the first box)
+ *            [3843,5545,1232], (raw data set for the second box)
+ *            ...
+ *        ]
+ * @param opt.boundIQR=1.5 Data less than min bound is outlier.
+ *      default 1.5, means Q1 - 1.5 * (Q3 - Q1).
+ *      If 'none'/0 passed, min bound will not be used.
+ */
+function prepareBoxplotData(rawData, opt) {
+  opt = opt || {};
+  var boxData = [];
+  var outliers = [];
+  var boundIQR = opt.boundIQR;
+  var useExtreme = boundIQR === 'none' || boundIQR === 0;
+  for (var i = 0; i < rawData.length; i++) {
+    var ascList = number.asc(rawData[i].slice());
+    var Q1 = number.quantile(ascList, 0.25);
+    var Q2 = number.quantile(ascList, 0.5);
+    var Q3 = number.quantile(ascList, 0.75);
+    var min = ascList[0];
+    var max = ascList[ascList.length - 1];
+    var bound = (boundIQR == null ? 1.5 : boundIQR) * (Q3 - Q1);
+    var low = useExtreme ? min : Math.max(min, Q1 - bound);
+    var high = useExtreme ? max : Math.min(max, Q3 + bound);
+    var itemNameFormatter = opt.itemNameFormatter;
+    var itemName = util.isFunction(itemNameFormatter) ? itemNameFormatter({
+      value: i
+    }) : util.isString(itemNameFormatter) ? itemNameFormatter.replace('{value}', i + '') : i + '';
+    boxData.push([itemName, low, Q1, Q2, Q3, high]);
+    for (var j = 0; j < ascList.length; j++) {
+      var dataItem = ascList[j];
+      if (dataItem < low || dataItem > high) {
+        var outlier = [itemName, dataItem];
+        outliers.push(outlier);
+      }
+    }
+  }
+  return {
+    boxData: boxData,
+    outliers: outliers
+  };
+}
+
+exports["default"] = prepareBoxplotData;

package/lib/node_modules/echarts/lib/chart/candlestick/CandlestickSeries.js

@@ -0,0 +1,83 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Series = require('../../model/Series.js');
+var whiskerBoxCommon = require('../helper/whiskerBoxCommon.js');
+var util = require('../../../../zrender/lib/core/util.js');
+
+var CandlestickSeriesModel = /** @class */function (_super) {
+  tslib.__extends(CandlestickSeriesModel, _super);
+  function CandlestickSeriesModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = CandlestickSeriesModel.type;
+    _this.defaultValueDimensions = [{
+      name: 'open',
+      defaultTooltip: true
+    }, {
+      name: 'close',
+      defaultTooltip: true
+    }, {
+      name: 'lowest',
+      defaultTooltip: true
+    }, {
+      name: 'highest',
+      defaultTooltip: true
+    }];
+    return _this;
+  }
+  /**
+   * Get dimension for shadow in dataZoom
+   * @return dimension name
+   */
+  CandlestickSeriesModel.prototype.getShadowDim = function () {
+    return 'open';
+  };
+  CandlestickSeriesModel.prototype.brushSelector = function (dataIndex, data, selectors) {
+    var itemLayout = data.getItemLayout(dataIndex);
+    return itemLayout && selectors.rect(itemLayout.brushRect);
+  };
+  CandlestickSeriesModel.type = 'series.candlestick';
+  CandlestickSeriesModel.dependencies = ['xAxis', 'yAxis', 'grid'];
+  CandlestickSeriesModel.defaultOption = {
+    // zlevel: 0,
+    z: 2,
+    coordinateSystem: 'cartesian2d',
+    legendHoverLink: true,
+    // xAxisIndex: 0,
+    // yAxisIndex: 0,
+    layout: null,
+    clip: true,
+    itemStyle: {
+      color: '#eb5454',
+      color0: '#47b262',
+      borderColor: '#eb5454',
+      borderColor0: '#47b262',
+      borderColorDoji: null,
+      // borderColor: '#d24040',
+      // borderColor0: '#398f4f',
+      borderWidth: 1
+    },
+    emphasis: {
+      scale: true,
+      itemStyle: {
+        borderWidth: 2
+      }
+    },
+    barMaxWidth: null,
+    barMinWidth: null,
+    barWidth: null,
+    large: true,
+    largeThreshold: 600,
+    progressive: 3e3,
+    progressiveThreshold: 1e4,
+    progressiveChunkMode: 'mod',
+    animationEasing: 'linear',
+    animationDuration: 300
+  };
+  return CandlestickSeriesModel;
+}(Series["default"]);
+util.mixin(CandlestickSeriesModel, whiskerBoxCommon.WhiskerBoxCommonMixin, true);
+
+exports["default"] = CandlestickSeriesModel;