office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/chart/helper/LineDraw.js

@@ -0,0 +1,126 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var graphic = require('../../util/graphic.js');
+var Line = require('./Line.js');
+var labelStyle = require('../../label/labelStyle.js');
+var Group = require('../../../../zrender/lib/graphic/Group.js');
+
+var LineDraw = /** @class */function () {
+  function LineDraw(LineCtor) {
+    this.group = new Group["default"]();
+    this._LineCtor = LineCtor || Line["default"];
+  }
+  LineDraw.prototype.updateData = function (lineData) {
+    var _this = this;
+    // Remove progressive els.
+    this._progressiveEls = null;
+    var lineDraw = this;
+    var group = lineDraw.group;
+    var oldLineData = lineDraw._lineData;
+    lineDraw._lineData = lineData;
+    // There is no oldLineData only when first rendering or switching from
+    // stream mode to normal mode, where previous elements should be removed.
+    if (!oldLineData) {
+      group.removeAll();
+    }
+    var seriesScope = makeSeriesScope(lineData);
+    lineData.diff(oldLineData).add(function (idx) {
+      _this._doAdd(lineData, idx, seriesScope);
+    }).update(function (newIdx, oldIdx) {
+      _this._doUpdate(oldLineData, lineData, oldIdx, newIdx, seriesScope);
+    }).remove(function (idx) {
+      group.remove(oldLineData.getItemGraphicEl(idx));
+    }).execute();
+  };
+  LineDraw.prototype.updateLayout = function () {
+    var lineData = this._lineData;
+    // Do not support update layout in incremental mode.
+    if (!lineData) {
+      return;
+    }
+    lineData.eachItemGraphicEl(function (el, idx) {
+      el.updateLayout(lineData, idx);
+    }, this);
+  };
+  LineDraw.prototype.incrementalPrepareUpdate = function (lineData) {
+    this._seriesScope = makeSeriesScope(lineData);
+    this._lineData = null;
+    this.group.removeAll();
+  };
+  LineDraw.prototype.incrementalUpdate = function (taskParams, lineData) {
+    this._progressiveEls = [];
+    function updateIncrementalAndHover(el) {
+      if (!el.isGroup && !isEffectObject(el)) {
+        el.incremental = true;
+        el.ensureState('emphasis').hoverLayer = true;
+      }
+    }
+    for (var idx = taskParams.start; idx < taskParams.end; idx++) {
+      var itemLayout = lineData.getItemLayout(idx);
+      if (lineNeedsDraw(itemLayout)) {
+        var el = new this._LineCtor(lineData, idx, this._seriesScope);
+        el.traverse(updateIncrementalAndHover);
+        this.group.add(el);
+        lineData.setItemGraphicEl(idx, el);
+        this._progressiveEls.push(el);
+      }
+    }
+  };
+  LineDraw.prototype.remove = function () {
+    this.group.removeAll();
+  };
+  LineDraw.prototype.eachRendered = function (cb) {
+    graphic.traverseElements(this._progressiveEls || this.group, cb);
+  };
+  LineDraw.prototype._doAdd = function (lineData, idx, seriesScope) {
+    var itemLayout = lineData.getItemLayout(idx);
+    if (!lineNeedsDraw(itemLayout)) {
+      return;
+    }
+    var el = new this._LineCtor(lineData, idx, seriesScope);
+    lineData.setItemGraphicEl(idx, el);
+    this.group.add(el);
+  };
+  LineDraw.prototype._doUpdate = function (oldLineData, newLineData, oldIdx, newIdx, seriesScope) {
+    var itemEl = oldLineData.getItemGraphicEl(oldIdx);
+    if (!lineNeedsDraw(newLineData.getItemLayout(newIdx))) {
+      this.group.remove(itemEl);
+      return;
+    }
+    if (!itemEl) {
+      itemEl = new this._LineCtor(newLineData, newIdx, seriesScope);
+    } else {
+      itemEl.updateData(newLineData, newIdx, seriesScope);
+    }
+    newLineData.setItemGraphicEl(newIdx, itemEl);
+    this.group.add(itemEl);
+  };
+  return LineDraw;
+}();
+function isEffectObject(el) {
+  return el.animators && el.animators.length > 0;
+}
+function makeSeriesScope(lineData) {
+  var hostModel = lineData.hostModel;
+  var emphasisModel = hostModel.getModel('emphasis');
+  return {
+    lineStyle: hostModel.getModel('lineStyle').getLineStyle(),
+    emphasisLineStyle: emphasisModel.getModel(['lineStyle']).getLineStyle(),
+    blurLineStyle: hostModel.getModel(['blur', 'lineStyle']).getLineStyle(),
+    selectLineStyle: hostModel.getModel(['select', 'lineStyle']).getLineStyle(),
+    emphasisDisabled: emphasisModel.get('disabled'),
+    blurScope: emphasisModel.get('blurScope'),
+    focus: emphasisModel.get('focus'),
+    labelStatesModels: labelStyle.getLabelStatesModels(hostModel)
+  };
+}
+function isPointNaN(pt) {
+  return isNaN(pt[0]) || isNaN(pt[1]);
+}
+function lineNeedsDraw(pts) {
+  return pts && !isPointNaN(pts[0]) && !isPointNaN(pts[1]);
+}
+
+exports["default"] = LineDraw;

package/lib/node_modules/echarts/lib/chart/helper/LinePath.js

@@ -0,0 +1,74 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+require('../../util/graphic.js');
+var vector = require('../../../../zrender/lib/core/vector.js');
+var Line = require('../../../../zrender/lib/graphic/shape/Line.js');
+var BezierCurve = require('../../../../zrender/lib/graphic/shape/BezierCurve.js');
+var Path = require('../../../../zrender/lib/graphic/Path.js');
+
+var straightLineProto = Line["default"].prototype;
+var bezierCurveProto = BezierCurve["default"].prototype;
+var StraightLineShape = /** @class */function () {
+  function StraightLineShape() {
+    // Start point
+    this.x1 = 0;
+    this.y1 = 0;
+    // End point
+    this.x2 = 0;
+    this.y2 = 0;
+    this.percent = 1;
+  }
+  return StraightLineShape;
+}();
+/** @class */(function (_super) {
+  tslib.__extends(CurveShape, _super);
+  function CurveShape() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  return CurveShape;
+})(StraightLineShape);
+function isStraightLine(shape) {
+  return isNaN(+shape.cpx1) || isNaN(+shape.cpy1);
+}
+var ECLinePath = /** @class */function (_super) {
+  tslib.__extends(ECLinePath, _super);
+  function ECLinePath(opts) {
+    var _this = _super.call(this, opts) || this;
+    _this.type = 'ec-line';
+    return _this;
+  }
+  ECLinePath.prototype.getDefaultStyle = function () {
+    return {
+      stroke: '#000',
+      fill: null
+    };
+  };
+  ECLinePath.prototype.getDefaultShape = function () {
+    return new StraightLineShape();
+  };
+  ECLinePath.prototype.buildPath = function (ctx, shape) {
+    if (isStraightLine(shape)) {
+      straightLineProto.buildPath.call(this, ctx, shape);
+    } else {
+      bezierCurveProto.buildPath.call(this, ctx, shape);
+    }
+  };
+  ECLinePath.prototype.pointAt = function (t) {
+    if (isStraightLine(this.shape)) {
+      return straightLineProto.pointAt.call(this, t);
+    } else {
+      return bezierCurveProto.pointAt.call(this, t);
+    }
+  };
+  ECLinePath.prototype.tangentAt = function (t) {
+    var shape = this.shape;
+    var p = isStraightLine(shape) ? [shape.x2 - shape.x1, shape.y2 - shape.y1] : bezierCurveProto.tangentAt.call(this, t);
+    return vector.normalize(p, p);
+  };
+  return ECLinePath;
+}(Path["default"]);
+
+exports["default"] = ECLinePath;

package/lib/node_modules/echarts/lib/chart/helper/Polyline.js

@@ -0,0 +1,69 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+require('../../util/graphic.js');
+var states = require('../../util/states.js');
+var Polyline$1 = require('../../../../zrender/lib/graphic/shape/Polyline.js');
+var basicTransition = require('../../animation/basicTransition.js');
+var Group = require('../../../../zrender/lib/graphic/Group.js');
+
+var Polyline = /** @class */function (_super) {
+  tslib.__extends(Polyline, _super);
+  function Polyline(lineData, idx, seriesScope) {
+    var _this = _super.call(this) || this;
+    _this._createPolyline(lineData, idx, seriesScope);
+    return _this;
+  }
+  Polyline.prototype._createPolyline = function (lineData, idx, seriesScope) {
+    // let seriesModel = lineData.hostModel;
+    var points = lineData.getItemLayout(idx);
+    var line = new Polyline$1["default"]({
+      shape: {
+        points: points
+      }
+    });
+    this.add(line);
+    this._updateCommonStl(lineData, idx, seriesScope);
+  };
+  Polyline.prototype.updateData = function (lineData, idx, seriesScope) {
+    var seriesModel = lineData.hostModel;
+    var line = this.childAt(0);
+    var target = {
+      shape: {
+        points: lineData.getItemLayout(idx)
+      }
+    };
+    basicTransition.updateProps(line, target, seriesModel, idx);
+    this._updateCommonStl(lineData, idx, seriesScope);
+  };
+  Polyline.prototype._updateCommonStl = function (lineData, idx, seriesScope) {
+    var line = this.childAt(0);
+    var itemModel = lineData.getItemModel(idx);
+    var emphasisLineStyle = seriesScope && seriesScope.emphasisLineStyle;
+    var focus = seriesScope && seriesScope.focus;
+    var blurScope = seriesScope && seriesScope.blurScope;
+    var emphasisDisabled = seriesScope && seriesScope.emphasisDisabled;
+    if (!seriesScope || lineData.hasItemOption) {
+      var emphasisModel = itemModel.getModel('emphasis');
+      emphasisLineStyle = emphasisModel.getModel('lineStyle').getLineStyle();
+      emphasisDisabled = emphasisModel.get('disabled');
+      focus = emphasisModel.get('focus');
+      blurScope = emphasisModel.get('blurScope');
+    }
+    line.useStyle(lineData.getItemVisual(idx, 'style'));
+    line.style.fill = null;
+    line.style.strokeNoScale = true;
+    var lineEmphasisState = line.ensureState('emphasis');
+    lineEmphasisState.style = emphasisLineStyle;
+    states.toggleHoverEmphasis(this, focus, blurScope, emphasisDisabled);
+  };
+  Polyline.prototype.updateLayout = function (lineData, idx) {
+    var polyline = this.childAt(0);
+    polyline.setShape('points', lineData.getItemLayout(idx));
+  };
+  return Polyline;
+}(Group["default"]);
+
+exports["default"] = Polyline;

package/lib/node_modules/echarts/lib/chart/helper/Symbol.js

@@ -0,0 +1,297 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var symbol = require('../../util/symbol.js');
+require('../../util/graphic.js');
+var innerStore = require('../../util/innerStore.js');
+var states = require('../../util/states.js');
+var labelHelper = require('./labelHelper.js');
+var util = require('../../../../zrender/lib/core/util.js');
+var labelStyle = require('../../label/labelStyle.js');
+var Image = require('../../../../zrender/lib/graphic/Image.js');
+var basicTransition = require('../../animation/basicTransition.js');
+var Group = require('../../../../zrender/lib/graphic/Group.js');
+
+var Symbol = /** @class */function (_super) {
+  tslib.__extends(Symbol, _super);
+  function Symbol(data, idx, seriesScope, opts) {
+    var _this = _super.call(this) || this;
+    _this.updateData(data, idx, seriesScope, opts);
+    return _this;
+  }
+  Symbol.prototype._createSymbol = function (symbolType, data, idx, symbolSize, keepAspect) {
+    // Remove paths created before
+    this.removeAll();
+    // let symbolPath = createSymbol(
+    //     symbolType, -0.5, -0.5, 1, 1, color
+    // );
+    // If width/height are set too small (e.g., set to 1) on ios10
+    // and macOS Sierra, a circle stroke become a rect, no matter what
+    // the scale is set. So we set width/height as 2. See #4150.
+    var symbolPath = symbol.createSymbol(symbolType, -1, -1, 2, 2, null, keepAspect);
+    symbolPath.attr({
+      z2: 100,
+      culling: true,
+      scaleX: symbolSize[0] / 2,
+      scaleY: symbolSize[1] / 2
+    });
+    // Rewrite drift method
+    symbolPath.drift = driftSymbol;
+    this._symbolType = symbolType;
+    this.add(symbolPath);
+  };
+  /**
+   * Stop animation
+   * @param {boolean} toLastFrame
+   */
+  Symbol.prototype.stopSymbolAnimation = function (toLastFrame) {
+    this.childAt(0).stopAnimation(null, toLastFrame);
+  };
+  Symbol.prototype.getSymbolType = function () {
+    return this._symbolType;
+  };
+  /**
+   * FIXME:
+   * Caution: This method breaks the encapsulation of this module,
+   * but it indeed brings convenience. So do not use the method
+   * unless you detailedly know all the implements of `Symbol`,
+   * especially animation.
+   *
+   * Get symbol path element.
+   */
+  Symbol.prototype.getSymbolPath = function () {
+    return this.childAt(0);
+  };
+  /**
+   * Highlight symbol
+   */
+  Symbol.prototype.highlight = function () {
+    states.enterEmphasis(this.childAt(0));
+  };
+  /**
+   * Downplay symbol
+   */
+  Symbol.prototype.downplay = function () {
+    states.leaveEmphasis(this.childAt(0));
+  };
+  /**
+   * @param {number} zlevel
+   * @param {number} z
+   */
+  Symbol.prototype.setZ = function (zlevel, z) {
+    var symbolPath = this.childAt(0);
+    symbolPath.zlevel = zlevel;
+    symbolPath.z = z;
+  };
+  Symbol.prototype.setDraggable = function (draggable, hasCursorOption) {
+    var symbolPath = this.childAt(0);
+    symbolPath.draggable = draggable;
+    symbolPath.cursor = !hasCursorOption && draggable ? 'move' : symbolPath.cursor;
+  };
+  /**
+   * Update symbol properties
+   */
+  Symbol.prototype.updateData = function (data, idx, seriesScope, opts) {
+    this.silent = false;
+    var symbolType = data.getItemVisual(idx, 'symbol') || 'circle';
+    var seriesModel = data.hostModel;
+    var symbolSize = Symbol.getSymbolSize(data, idx);
+    var isInit = symbolType !== this._symbolType;
+    var disableAnimation = opts && opts.disableAnimation;
+    if (isInit) {
+      var keepAspect = data.getItemVisual(idx, 'symbolKeepAspect');
+      this._createSymbol(symbolType, data, idx, symbolSize, keepAspect);
+    } else {
+      var symbolPath = this.childAt(0);
+      symbolPath.silent = false;
+      var target = {
+        scaleX: symbolSize[0] / 2,
+        scaleY: symbolSize[1] / 2
+      };
+      disableAnimation ? symbolPath.attr(target) : basicTransition.updateProps(symbolPath, target, seriesModel, idx);
+      basicTransition.saveOldStyle(symbolPath);
+    }
+    this._updateCommon(data, idx, symbolSize, seriesScope, opts);
+    if (isInit) {
+      var symbolPath = this.childAt(0);
+      if (!disableAnimation) {
+        var target = {
+          scaleX: this._sizeX,
+          scaleY: this._sizeY,
+          style: {
+            // Always fadeIn. Because it has fadeOut animation when symbol is removed..
+            opacity: symbolPath.style.opacity
+          }
+        };
+        symbolPath.scaleX = symbolPath.scaleY = 0;
+        symbolPath.style.opacity = 0;
+        basicTransition.initProps(symbolPath, target, seriesModel, idx);
+      }
+    }
+    if (disableAnimation) {
+      // Must stop leave transition manually if don't call initProps or updateProps.
+      this.childAt(0).stopAnimation('leave');
+    }
+  };
+  Symbol.prototype._updateCommon = function (data, idx, symbolSize, seriesScope, opts) {
+    var symbolPath = this.childAt(0);
+    var seriesModel = data.hostModel;
+    var emphasisItemStyle;
+    var blurItemStyle;
+    var selectItemStyle;
+    var focus;
+    var blurScope;
+    var emphasisDisabled;
+    var labelStatesModels;
+    var hoverScale;
+    var cursorStyle;
+    if (seriesScope) {
+      emphasisItemStyle = seriesScope.emphasisItemStyle;
+      blurItemStyle = seriesScope.blurItemStyle;
+      selectItemStyle = seriesScope.selectItemStyle;
+      focus = seriesScope.focus;
+      blurScope = seriesScope.blurScope;
+      labelStatesModels = seriesScope.labelStatesModels;
+      hoverScale = seriesScope.hoverScale;
+      cursorStyle = seriesScope.cursorStyle;
+      emphasisDisabled = seriesScope.emphasisDisabled;
+    }
+    if (!seriesScope || data.hasItemOption) {
+      var itemModel = seriesScope && seriesScope.itemModel ? seriesScope.itemModel : data.getItemModel(idx);
+      var emphasisModel = itemModel.getModel('emphasis');
+      emphasisItemStyle = emphasisModel.getModel('itemStyle').getItemStyle();
+      selectItemStyle = itemModel.getModel(['select', 'itemStyle']).getItemStyle();
+      blurItemStyle = itemModel.getModel(['blur', 'itemStyle']).getItemStyle();
+      focus = emphasisModel.get('focus');
+      blurScope = emphasisModel.get('blurScope');
+      emphasisDisabled = emphasisModel.get('disabled');
+      labelStatesModels = labelStyle.getLabelStatesModels(itemModel);
+      hoverScale = emphasisModel.getShallow('scale');
+      cursorStyle = itemModel.getShallow('cursor');
+    }
+    var symbolRotate = data.getItemVisual(idx, 'symbolRotate');
+    symbolPath.attr('rotation', (symbolRotate || 0) * Math.PI / 180 || 0);
+    var symbolOffset = symbol.normalizeSymbolOffset(data.getItemVisual(idx, 'symbolOffset'), symbolSize);
+    if (symbolOffset) {
+      symbolPath.x = symbolOffset[0];
+      symbolPath.y = symbolOffset[1];
+    }
+    cursorStyle && symbolPath.attr('cursor', cursorStyle);
+    var symbolStyle = data.getItemVisual(idx, 'style');
+    var visualColor = symbolStyle.fill;
+    if (symbolPath instanceof Image["default"]) {
+      var pathStyle = symbolPath.style;
+      symbolPath.useStyle(util.extend({
+        // TODO other properties like x, y ?
+        image: pathStyle.image,
+        x: pathStyle.x,
+        y: pathStyle.y,
+        width: pathStyle.width,
+        height: pathStyle.height
+      }, symbolStyle));
+    } else {
+      if (symbolPath.__isEmptyBrush) {
+        // fill and stroke will be swapped if it's empty.
+        // So we cloned a new style to avoid it affecting the original style in visual storage.
+        // TODO Better implementation. No empty logic!
+        symbolPath.useStyle(util.extend({}, symbolStyle));
+      } else {
+        symbolPath.useStyle(symbolStyle);
+      }
+      // Disable decal because symbol scale will been applied on the decal.
+      symbolPath.style.decal = null;
+      symbolPath.setColor(visualColor, opts && opts.symbolInnerColor);
+      symbolPath.style.strokeNoScale = true;
+    }
+    var liftZ = data.getItemVisual(idx, 'liftZ');
+    var z2Origin = this._z2;
+    if (liftZ != null) {
+      if (z2Origin == null) {
+        this._z2 = symbolPath.z2;
+        symbolPath.z2 += liftZ;
+      }
+    } else if (z2Origin != null) {
+      symbolPath.z2 = z2Origin;
+      this._z2 = null;
+    }
+    var useNameLabel = opts && opts.useNameLabel;
+    labelStyle.setLabelStyle(symbolPath, labelStatesModels, {
+      labelFetcher: seriesModel,
+      labelDataIndex: idx,
+      defaultText: getLabelDefaultText,
+      inheritColor: visualColor,
+      defaultOpacity: symbolStyle.opacity
+    });
+    // Do not execute util needed.
+    function getLabelDefaultText(idx) {
+      return useNameLabel ? data.getName(idx) : labelHelper.getDefaultLabel(data, idx);
+    }
+    this._sizeX = symbolSize[0] / 2;
+    this._sizeY = symbolSize[1] / 2;
+    var emphasisState = symbolPath.ensureState('emphasis');
+    emphasisState.style = emphasisItemStyle;
+    symbolPath.ensureState('select').style = selectItemStyle;
+    symbolPath.ensureState('blur').style = blurItemStyle;
+    // null / undefined / true means to use default strategy.
+    // 0 / false / negative number / NaN / Infinity means no scale.
+    var scaleRatio = hoverScale == null || hoverScale === true ? Math.max(1.1, 3 / this._sizeY)
+    // PENDING: restrict hoverScale > 1? It seems unreasonable to scale down
+    : isFinite(hoverScale) && hoverScale > 0 ? +hoverScale : 1;
+    // always set scale to allow resetting
+    emphasisState.scaleX = this._sizeX * scaleRatio;
+    emphasisState.scaleY = this._sizeY * scaleRatio;
+    this.setSymbolScale(1);
+    states.toggleHoverEmphasis(this, focus, blurScope, emphasisDisabled);
+  };
+  Symbol.prototype.setSymbolScale = function (scale) {
+    this.scaleX = this.scaleY = scale;
+  };
+  Symbol.prototype.fadeOut = function (cb, seriesModel, opt) {
+    var symbolPath = this.childAt(0);
+    var dataIndex = innerStore.getECData(this).dataIndex;
+    var animationOpt = opt && opt.animation;
+    // Avoid mistaken hover when fading out
+    this.silent = symbolPath.silent = true;
+    // Not show text when animating
+    if (opt && opt.fadeLabel) {
+      var textContent = symbolPath.getTextContent();
+      if (textContent) {
+        basicTransition.removeElement(textContent, {
+          style: {
+            opacity: 0
+          }
+        }, seriesModel, {
+          dataIndex: dataIndex,
+          removeOpt: animationOpt,
+          cb: function () {
+            symbolPath.removeTextContent();
+          }
+        });
+      }
+    } else {
+      symbolPath.removeTextContent();
+    }
+    basicTransition.removeElement(symbolPath, {
+      style: {
+        opacity: 0
+      },
+      scaleX: 0,
+      scaleY: 0
+    }, seriesModel, {
+      dataIndex: dataIndex,
+      cb: cb,
+      removeOpt: animationOpt
+    });
+  };
+  Symbol.getSymbolSize = function (data, idx) {
+    return symbol.normalizeSymbolSize(data.getItemVisual(idx, 'symbolSize'));
+  };
+  return Symbol;
+}(Group["default"]);
+function driftSymbol(dx, dy) {
+  this.parent.drift(dx, dy);
+}
+
+exports["default"] = Symbol;