office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/chart/helper/EffectPolyline.js

@@ -0,0 +1,89 @@
+import { __extends } from 'tslib';
+import Polyline from './Polyline.js';
+import EffectLine from './EffectLine.js';
+import { dist } from '../../../../zrender/lib/core/vector.js';
+
+var EffectPolyline = /** @class */function (_super) {
+  __extends(EffectPolyline, _super);
+  function EffectPolyline() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this._lastFrame = 0;
+    _this._lastFramePercent = 0;
+    return _this;
+  }
+  // Override
+  EffectPolyline.prototype.createLine = function (lineData, idx, seriesScope) {
+    return new Polyline(lineData, idx, seriesScope);
+  };
+  // Override
+  EffectPolyline.prototype._updateAnimationPoints = function (symbol, points) {
+    this._points = points;
+    var accLenArr = [0];
+    var len = 0;
+    for (var i = 1; i < points.length; i++) {
+      var p1 = points[i - 1];
+      var p2 = points[i];
+      len += dist(p1, p2);
+      accLenArr.push(len);
+    }
+    if (len === 0) {
+      this._length = 0;
+      return;
+    }
+    for (var i = 0; i < accLenArr.length; i++) {
+      accLenArr[i] /= len;
+    }
+    this._offsets = accLenArr;
+    this._length = len;
+  };
+  // Override
+  EffectPolyline.prototype._getLineLength = function () {
+    return this._length;
+  };
+  // Override
+  EffectPolyline.prototype._updateSymbolPosition = function (symbol) {
+    var t = symbol.__t < 1 ? symbol.__t : 2 - symbol.__t;
+    var points = this._points;
+    var offsets = this._offsets;
+    var len = points.length;
+    if (!offsets) {
+      // Has length 0
+      return;
+    }
+    var lastFrame = this._lastFrame;
+    var frame;
+    if (t < this._lastFramePercent) {
+      // Start from the next frame
+      // PENDING start from lastFrame ?
+      var start = Math.min(lastFrame + 1, len - 1);
+      for (frame = start; frame >= 0; frame--) {
+        if (offsets[frame] <= t) {
+          break;
+        }
+      }
+      // PENDING really need to do this ?
+      frame = Math.min(frame, len - 2);
+    } else {
+      for (frame = lastFrame; frame < len; frame++) {
+        if (offsets[frame] > t) {
+          break;
+        }
+      }
+      frame = Math.min(frame - 1, len - 2);
+    }
+    var p = (t - offsets[frame]) / (offsets[frame + 1] - offsets[frame]);
+    var p0 = points[frame];
+    var p1 = points[frame + 1];
+    symbol.x = p0[0] * (1 - p) + p * p1[0];
+    symbol.y = p0[1] * (1 - p) + p * p1[1];
+    var tx = symbol.__t < 1 ? p1[0] - p0[0] : p0[0] - p1[0];
+    var ty = symbol.__t < 1 ? p1[1] - p0[1] : p0[1] - p1[1];
+    symbol.rotation = -Math.atan2(ty, tx) - Math.PI / 2;
+    this._lastFrame = frame;
+    this._lastFramePercent = t;
+    symbol.ignore = false;
+  };
+  return EffectPolyline;
+}(EffectLine);
+
+export { EffectPolyline as default };

package/esm/node_modules/echarts/lib/chart/helper/EffectSymbol.js

@@ -0,0 +1,165 @@
+import { __extends } from 'tslib';
+import { createSymbol, normalizeSymbolSize, normalizeSymbolOffset } from '../../util/symbol.js';
+import '../../util/graphic.js';
+import { enterEmphasis, leaveEmphasis, toggleHoverEmphasis } from '../../util/states.js';
+import Symbol from './Symbol.js';
+import Group from '../../../../zrender/lib/graphic/Group.js';
+
+function updateRipplePath(rippleGroup, effectCfg) {
+  var color = effectCfg.rippleEffectColor || effectCfg.color;
+  rippleGroup.eachChild(function (ripplePath) {
+    ripplePath.attr({
+      z: effectCfg.z,
+      zlevel: effectCfg.zlevel,
+      style: {
+        stroke: effectCfg.brushType === 'stroke' ? color : null,
+        fill: effectCfg.brushType === 'fill' ? color : null
+      }
+    });
+  });
+}
+var EffectSymbol = /** @class */function (_super) {
+  __extends(EffectSymbol, _super);
+  function EffectSymbol(data, idx) {
+    var _this = _super.call(this) || this;
+    var symbol = new Symbol(data, idx);
+    var rippleGroup = new Group();
+    _this.add(symbol);
+    _this.add(rippleGroup);
+    _this.updateData(data, idx);
+    return _this;
+  }
+  EffectSymbol.prototype.stopEffectAnimation = function () {
+    this.childAt(1).removeAll();
+  };
+  EffectSymbol.prototype.startEffectAnimation = function (effectCfg) {
+    var symbolType = effectCfg.symbolType;
+    var color = effectCfg.color;
+    var rippleNumber = effectCfg.rippleNumber;
+    var rippleGroup = this.childAt(1);
+    for (var i = 0; i < rippleNumber; i++) {
+      // 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 #4136.
+      var ripplePath = createSymbol(symbolType, -1, -1, 2, 2, color);
+      ripplePath.attr({
+        style: {
+          strokeNoScale: true
+        },
+        z2: 99,
+        silent: true,
+        scaleX: 0.5,
+        scaleY: 0.5
+      });
+      var delay = -i / rippleNumber * effectCfg.period + effectCfg.effectOffset;
+      ripplePath.animate('', true).when(effectCfg.period, {
+        scaleX: effectCfg.rippleScale / 2,
+        scaleY: effectCfg.rippleScale / 2
+      }).delay(delay).start();
+      ripplePath.animateStyle(true).when(effectCfg.period, {
+        opacity: 0
+      }).delay(delay).start();
+      rippleGroup.add(ripplePath);
+    }
+    updateRipplePath(rippleGroup, effectCfg);
+  };
+  /**
+   * Update effect symbol
+   */
+  EffectSymbol.prototype.updateEffectAnimation = function (effectCfg) {
+    var oldEffectCfg = this._effectCfg;
+    var rippleGroup = this.childAt(1);
+    // Must reinitialize effect if following configuration changed
+    var DIFFICULT_PROPS = ['symbolType', 'period', 'rippleScale', 'rippleNumber'];
+    for (var i = 0; i < DIFFICULT_PROPS.length; i++) {
+      var propName = DIFFICULT_PROPS[i];
+      if (oldEffectCfg[propName] !== effectCfg[propName]) {
+        this.stopEffectAnimation();
+        this.startEffectAnimation(effectCfg);
+        return;
+      }
+    }
+    updateRipplePath(rippleGroup, effectCfg);
+  };
+  /**
+   * Highlight symbol
+   */
+  EffectSymbol.prototype.highlight = function () {
+    enterEmphasis(this);
+  };
+  /**
+   * Downplay symbol
+   */
+  EffectSymbol.prototype.downplay = function () {
+    leaveEmphasis(this);
+  };
+  EffectSymbol.prototype.getSymbolType = function () {
+    var symbol = this.childAt(0);
+    return symbol && symbol.getSymbolType();
+  };
+  /**
+   * Update symbol properties
+   */
+  EffectSymbol.prototype.updateData = function (data, idx) {
+    var _this = this;
+    var seriesModel = data.hostModel;
+    this.childAt(0).updateData(data, idx);
+    var rippleGroup = this.childAt(1);
+    var itemModel = data.getItemModel(idx);
+    var symbolType = data.getItemVisual(idx, 'symbol');
+    var symbolSize = normalizeSymbolSize(data.getItemVisual(idx, 'symbolSize'));
+    var symbolStyle = data.getItemVisual(idx, 'style');
+    var color = symbolStyle && symbolStyle.fill;
+    var emphasisModel = itemModel.getModel('emphasis');
+    rippleGroup.setScale(symbolSize);
+    rippleGroup.traverse(function (ripplePath) {
+      ripplePath.setStyle('fill', color);
+    });
+    var symbolOffset = normalizeSymbolOffset(data.getItemVisual(idx, 'symbolOffset'), symbolSize);
+    if (symbolOffset) {
+      rippleGroup.x = symbolOffset[0];
+      rippleGroup.y = symbolOffset[1];
+    }
+    var symbolRotate = data.getItemVisual(idx, 'symbolRotate');
+    rippleGroup.rotation = (symbolRotate || 0) * Math.PI / 180 || 0;
+    var effectCfg = {};
+    effectCfg.showEffectOn = seriesModel.get('showEffectOn');
+    effectCfg.rippleScale = itemModel.get(['rippleEffect', 'scale']);
+    effectCfg.brushType = itemModel.get(['rippleEffect', 'brushType']);
+    effectCfg.period = itemModel.get(['rippleEffect', 'period']) * 1000;
+    effectCfg.effectOffset = idx / data.count();
+    effectCfg.z = seriesModel.getShallow('z') || 0;
+    effectCfg.zlevel = seriesModel.getShallow('zlevel') || 0;
+    effectCfg.symbolType = symbolType;
+    effectCfg.color = color;
+    effectCfg.rippleEffectColor = itemModel.get(['rippleEffect', 'color']);
+    effectCfg.rippleNumber = itemModel.get(['rippleEffect', 'number']);
+    if (effectCfg.showEffectOn === 'render') {
+      this._effectCfg ? this.updateEffectAnimation(effectCfg) : this.startEffectAnimation(effectCfg);
+      this._effectCfg = effectCfg;
+    } else {
+      // Not keep old effect config
+      this._effectCfg = null;
+      this.stopEffectAnimation();
+      this.onHoverStateChange = function (toState) {
+        if (toState === 'emphasis') {
+          if (effectCfg.showEffectOn !== 'render') {
+            _this.startEffectAnimation(effectCfg);
+          }
+        } else if (toState === 'normal') {
+          if (effectCfg.showEffectOn !== 'render') {
+            _this.stopEffectAnimation();
+          }
+        }
+      };
+    }
+    this._effectCfg = effectCfg;
+    toggleHoverEmphasis(this, emphasisModel.get('focus'), emphasisModel.get('blurScope'), emphasisModel.get('disabled'));
+  };
+  EffectSymbol.prototype.fadeOut = function (cb) {
+    cb && cb();
+  };
+  return EffectSymbol;
+}(Group);
+
+export { EffectSymbol as default };

package/esm/node_modules/echarts/lib/chart/helper/LargeLineDraw.js

@@ -0,0 +1,259 @@
+import { __extends } from 'tslib';
+import '../../util/graphic.js';
+import { containStroke } from '../../../../zrender/lib/contain/line.js';
+import { containStroke as containStroke$1 } from '../../../../zrender/lib/contain/quadratic.js';
+import { getECData } from '../../util/innerStore.js';
+import BoundingRect from '../../../../zrender/lib/core/BoundingRect.js';
+import Path from '../../../../zrender/lib/graphic/Path.js';
+import Group from '../../../../zrender/lib/graphic/Group.js';
+
+var LargeLinesPathShape = /** @class */function () {
+  function LargeLinesPathShape() {
+    this.polyline = false;
+    this.curveness = 0;
+    this.segs = [];
+  }
+  return LargeLinesPathShape;
+}();
+var LargeLinesPath = /** @class */function (_super) {
+  __extends(LargeLinesPath, _super);
+  function LargeLinesPath(opts) {
+    var _this = _super.call(this, opts) || this;
+    _this._off = 0;
+    _this.hoverDataIdx = -1;
+    return _this;
+  }
+  LargeLinesPath.prototype.reset = function () {
+    this.notClear = false;
+    this._off = 0;
+  };
+  LargeLinesPath.prototype.getDefaultStyle = function () {
+    return {
+      stroke: '#000',
+      fill: null
+    };
+  };
+  LargeLinesPath.prototype.getDefaultShape = function () {
+    return new LargeLinesPathShape();
+  };
+  LargeLinesPath.prototype.buildPath = function (ctx, shape) {
+    var segs = shape.segs;
+    var curveness = shape.curveness;
+    var i;
+    if (shape.polyline) {
+      for (i = this._off; i < segs.length;) {
+        var count = segs[i++];
+        if (count > 0) {
+          ctx.moveTo(segs[i++], segs[i++]);
+          for (var k = 1; k < count; k++) {
+            ctx.lineTo(segs[i++], segs[i++]);
+          }
+        }
+      }
+    } else {
+      for (i = this._off; i < segs.length;) {
+        var x0 = segs[i++];
+        var y0 = segs[i++];
+        var x1 = segs[i++];
+        var y1 = segs[i++];
+        ctx.moveTo(x0, y0);
+        if (curveness > 0) {
+          var x2 = (x0 + x1) / 2 - (y0 - y1) * curveness;
+          var y2 = (y0 + y1) / 2 - (x1 - x0) * curveness;
+          ctx.quadraticCurveTo(x2, y2, x1, y1);
+        } else {
+          ctx.lineTo(x1, y1);
+        }
+      }
+    }
+    if (this.incremental) {
+      this._off = i;
+      this.notClear = true;
+    }
+  };
+  LargeLinesPath.prototype.findDataIndex = function (x, y) {
+    var shape = this.shape;
+    var segs = shape.segs;
+    var curveness = shape.curveness;
+    var lineWidth = this.style.lineWidth;
+    if (shape.polyline) {
+      var dataIndex = 0;
+      for (var i = 0; i < segs.length;) {
+        var count = segs[i++];
+        if (count > 0) {
+          var x0 = segs[i++];
+          var y0 = segs[i++];
+          for (var k = 1; k < count; k++) {
+            var x1 = segs[i++];
+            var y1 = segs[i++];
+            if (containStroke(x0, y0, x1, y1, lineWidth, x, y)) {
+              return dataIndex;
+            }
+          }
+        }
+        dataIndex++;
+      }
+    } else {
+      var dataIndex = 0;
+      for (var i = 0; i < segs.length;) {
+        var x0 = segs[i++];
+        var y0 = segs[i++];
+        var x1 = segs[i++];
+        var y1 = segs[i++];
+        if (curveness > 0) {
+          var x2 = (x0 + x1) / 2 - (y0 - y1) * curveness;
+          var y2 = (y0 + y1) / 2 - (x1 - x0) * curveness;
+          if (containStroke$1(x0, y0, x2, y2, x1, y1, lineWidth, x, y)) {
+            return dataIndex;
+          }
+        } else {
+          if (containStroke(x0, y0, x1, y1, lineWidth, x, y)) {
+            return dataIndex;
+          }
+        }
+        dataIndex++;
+      }
+    }
+    return -1;
+  };
+  LargeLinesPath.prototype.contain = function (x, y) {
+    var localPos = this.transformCoordToLocal(x, y);
+    var rect = this.getBoundingRect();
+    x = localPos[0];
+    y = localPos[1];
+    if (rect.contain(x, y)) {
+      // Cache found data index.
+      var dataIdx = this.hoverDataIdx = this.findDataIndex(x, y);
+      return dataIdx >= 0;
+    }
+    this.hoverDataIdx = -1;
+    return false;
+  };
+  LargeLinesPath.prototype.getBoundingRect = function () {
+    // Ignore stroke for large symbol draw.
+    var rect = this._rect;
+    if (!rect) {
+      var shape = this.shape;
+      var points = shape.segs;
+      var minX = Infinity;
+      var minY = Infinity;
+      var maxX = -Infinity;
+      var maxY = -Infinity;
+      for (var i = 0; i < points.length;) {
+        var x = points[i++];
+        var y = points[i++];
+        minX = Math.min(x, minX);
+        maxX = Math.max(x, maxX);
+        minY = Math.min(y, minY);
+        maxY = Math.max(y, maxY);
+      }
+      rect = this._rect = new BoundingRect(minX, minY, maxX, maxY);
+    }
+    return rect;
+  };
+  return LargeLinesPath;
+}(Path);
+var LargeLineDraw = /** @class */function () {
+  function LargeLineDraw() {
+    this.group = new Group();
+  }
+  /**
+   * Update symbols draw by new data
+   */
+  LargeLineDraw.prototype.updateData = function (data) {
+    this._clear();
+    var lineEl = this._create();
+    lineEl.setShape({
+      segs: data.getLayout('linesPoints')
+    });
+    this._setCommon(lineEl, data);
+  };
+  /**
+   * @override
+   */
+  LargeLineDraw.prototype.incrementalPrepareUpdate = function (data) {
+    this.group.removeAll();
+    this._clear();
+  };
+  /**
+   * @override
+   */
+  LargeLineDraw.prototype.incrementalUpdate = function (taskParams, data) {
+    var lastAdded = this._newAdded[0];
+    var linePoints = data.getLayout('linesPoints');
+    var oldSegs = lastAdded && lastAdded.shape.segs;
+    // Merging the exists. Each element has 1e4 points.
+    // Consider the performance balance between too much elements and too much points in one shape(may affect hover optimization)
+    if (oldSegs && oldSegs.length < 2e4) {
+      var oldLen = oldSegs.length;
+      var newSegs = new Float32Array(oldLen + linePoints.length);
+      // Concat two array
+      newSegs.set(oldSegs);
+      newSegs.set(linePoints, oldLen);
+      lastAdded.setShape({
+        segs: newSegs
+      });
+    } else {
+      // Clear
+      this._newAdded = [];
+      var lineEl = this._create();
+      lineEl.incremental = true;
+      lineEl.setShape({
+        segs: linePoints
+      });
+      this._setCommon(lineEl, data);
+      lineEl.__startIndex = taskParams.start;
+    }
+  };
+  /**
+   * @override
+   */
+  LargeLineDraw.prototype.remove = function () {
+    this._clear();
+  };
+  LargeLineDraw.prototype.eachRendered = function (cb) {
+    this._newAdded[0] && cb(this._newAdded[0]);
+  };
+  LargeLineDraw.prototype._create = function () {
+    var lineEl = new LargeLinesPath({
+      cursor: 'default',
+      ignoreCoarsePointer: true
+    });
+    this._newAdded.push(lineEl);
+    this.group.add(lineEl);
+    return lineEl;
+  };
+  LargeLineDraw.prototype._setCommon = function (lineEl, data, isIncremental) {
+    var hostModel = data.hostModel;
+    lineEl.setShape({
+      polyline: hostModel.get('polyline'),
+      curveness: hostModel.get(['lineStyle', 'curveness'])
+    });
+    lineEl.useStyle(hostModel.getModel('lineStyle').getLineStyle());
+    lineEl.style.strokeNoScale = true;
+    var style = data.getVisual('style');
+    if (style && style.stroke) {
+      lineEl.setStyle('stroke', style.stroke);
+    }
+    lineEl.setStyle('fill', null);
+    var ecData = getECData(lineEl);
+    // Enable tooltip
+    // PENDING May have performance issue when path is extremely large
+    ecData.seriesIndex = hostModel.seriesIndex;
+    lineEl.on('mousemove', function (e) {
+      ecData.dataIndex = null;
+      var dataIndex = lineEl.hoverDataIdx;
+      if (dataIndex > 0) {
+        // Provide dataIndex for tooltip
+        ecData.dataIndex = dataIndex + lineEl.__startIndex;
+      }
+    });
+  };
+  LargeLineDraw.prototype._clear = function () {
+    this._newAdded = [];
+    this.group.removeAll();
+  };
+  return LargeLineDraw;
+}();
+
+export { LargeLineDraw as default };