office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/echarts/lib/label/LabelManager.js

@@ -0,0 +1,399 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../util/graphic.js');
+var innerStore = require('../util/innerStore.js');
+var number = require('../util/number.js');
+var Transformable = require('../../../zrender/lib/core/Transformable.js');
+var labelGuideHelper = require('./labelGuideHelper.js');
+var model = require('../util/model.js');
+var util$1 = require('../../../zrender/lib/core/util.js');
+var labelLayoutHelper = require('./labelLayoutHelper.js');
+var labelStyle = require('./labelStyle.js');
+var util = require('../../../zrender/lib/contain/util.js');
+var BoundingRect = require('../../../zrender/lib/core/BoundingRect.js');
+var basicTransition = require('../animation/basicTransition.js');
+
+function cloneArr(points) {
+  if (points) {
+    var newPoints = [];
+    for (var i = 0; i < points.length; i++) {
+      newPoints.push(points[i].slice());
+    }
+    return newPoints;
+  }
+}
+function prepareLayoutCallbackParams(labelItem, hostEl) {
+  var label = labelItem.label;
+  var labelLine = hostEl && hostEl.getTextGuideLine();
+  return {
+    dataIndex: labelItem.dataIndex,
+    dataType: labelItem.dataType,
+    seriesIndex: labelItem.seriesModel.seriesIndex,
+    text: labelItem.label.style.text,
+    rect: labelItem.hostRect,
+    labelRect: labelItem.rect,
+    // x: labelAttr.x,
+    // y: labelAttr.y,
+    align: label.style.align,
+    verticalAlign: label.style.verticalAlign,
+    labelLinePoints: cloneArr(labelLine && labelLine.shape.points)
+  };
+}
+var LABEL_OPTION_TO_STYLE_KEYS = ['align', 'verticalAlign', 'width', 'height', 'fontSize'];
+var dummyTransformable = new Transformable["default"]();
+var labelLayoutInnerStore = model.makeInner();
+var labelLineAnimationStore = model.makeInner();
+function extendWithKeys(target, source, keys) {
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    if (source[key] != null) {
+      target[key] = source[key];
+    }
+  }
+}
+var LABEL_LAYOUT_PROPS = ['x', 'y', 'rotation'];
+var LabelManager = /** @class */function () {
+  function LabelManager() {
+    this._labelList = [];
+    this._chartViewList = [];
+  }
+  LabelManager.prototype.clearLabels = function () {
+    this._labelList = [];
+    this._chartViewList = [];
+  };
+  /**
+   * Add label to manager
+   */
+  LabelManager.prototype._addLabel = function (dataIndex, dataType, seriesModel, label, layoutOption) {
+    var labelStyle = label.style;
+    var hostEl = label.__hostTarget;
+    var textConfig = hostEl.textConfig || {};
+    // TODO: If label is in other state.
+    var labelTransform = label.getComputedTransform();
+    var labelRect = label.getBoundingRect().plain();
+    BoundingRect["default"].applyTransform(labelRect, labelRect, labelTransform);
+    if (labelTransform) {
+      dummyTransformable.setLocalTransform(labelTransform);
+    } else {
+      // Identity transform.
+      dummyTransformable.x = dummyTransformable.y = dummyTransformable.rotation = dummyTransformable.originX = dummyTransformable.originY = 0;
+      dummyTransformable.scaleX = dummyTransformable.scaleY = 1;
+    }
+    dummyTransformable.rotation = util.normalizeRadian(dummyTransformable.rotation);
+    var host = label.__hostTarget;
+    var hostRect;
+    if (host) {
+      hostRect = host.getBoundingRect().plain();
+      var transform = host.getComputedTransform();
+      BoundingRect["default"].applyTransform(hostRect, hostRect, transform);
+    }
+    var labelGuide = hostRect && host.getTextGuideLine();
+    this._labelList.push({
+      label: label,
+      labelLine: labelGuide,
+      seriesModel: seriesModel,
+      dataIndex: dataIndex,
+      dataType: dataType,
+      layoutOption: layoutOption,
+      computedLayoutOption: null,
+      rect: labelRect,
+      hostRect: hostRect,
+      // Label with lower priority will be hidden when overlapped
+      // Use rect size as default priority
+      priority: hostRect ? hostRect.width * hostRect.height : 0,
+      // Save default label attributes.
+      // For restore if developers want get back to default value in callback.
+      defaultAttr: {
+        ignore: label.ignore,
+        labelGuideIgnore: labelGuide && labelGuide.ignore,
+        x: dummyTransformable.x,
+        y: dummyTransformable.y,
+        scaleX: dummyTransformable.scaleX,
+        scaleY: dummyTransformable.scaleY,
+        rotation: dummyTransformable.rotation,
+        style: {
+          x: labelStyle.x,
+          y: labelStyle.y,
+          align: labelStyle.align,
+          verticalAlign: labelStyle.verticalAlign,
+          width: labelStyle.width,
+          height: labelStyle.height,
+          fontSize: labelStyle.fontSize
+        },
+        cursor: label.cursor,
+        attachedPos: textConfig.position,
+        attachedRot: textConfig.rotation
+      }
+    });
+  };
+  LabelManager.prototype.addLabelsOfSeries = function (chartView) {
+    var _this = this;
+    this._chartViewList.push(chartView);
+    var seriesModel = chartView.__model;
+    var layoutOption = seriesModel.get('labelLayout');
+    /**
+     * Ignore layouting if it's not specified anything.
+     */
+    if (!(util$1.isFunction(layoutOption) || util$1.keys(layoutOption).length)) {
+      return;
+    }
+    chartView.group.traverse(function (child) {
+      if (child.ignore) {
+        return true; // Stop traverse descendants.
+      }
+      // Only support label being hosted on graphic elements.
+      var textEl = child.getTextContent();
+      var ecData = innerStore.getECData(child);
+      // Can only attach the text on the element with dataIndex
+      if (textEl && !textEl.disableLabelLayout) {
+        _this._addLabel(ecData.dataIndex, ecData.dataType, seriesModel, textEl, layoutOption);
+      }
+    });
+  };
+  LabelManager.prototype.updateLayoutConfig = function (api) {
+    var width = api.getWidth();
+    var height = api.getHeight();
+    function createDragHandler(el, labelLineModel) {
+      return function () {
+        labelGuideHelper.updateLabelLinePoints(el, labelLineModel);
+      };
+    }
+    for (var i = 0; i < this._labelList.length; i++) {
+      var labelItem = this._labelList[i];
+      var label = labelItem.label;
+      var hostEl = label.__hostTarget;
+      var defaultLabelAttr = labelItem.defaultAttr;
+      var layoutOption = void 0;
+      // TODO A global layout option?
+      if (util$1.isFunction(labelItem.layoutOption)) {
+        layoutOption = labelItem.layoutOption(prepareLayoutCallbackParams(labelItem, hostEl));
+      } else {
+        layoutOption = labelItem.layoutOption;
+      }
+      layoutOption = layoutOption || {};
+      labelItem.computedLayoutOption = layoutOption;
+      var degreeToRadian = Math.PI / 180;
+      // TODO hostEl should always exists.
+      // Or label should not have parent because the x, y is all in global space.
+      if (hostEl) {
+        hostEl.setTextConfig({
+          // Force to set local false.
+          local: false,
+          // Ignore position and rotation config on the host el if x or y is changed.
+          position: layoutOption.x != null || layoutOption.y != null ? null : defaultLabelAttr.attachedPos,
+          // Ignore rotation config on the host el if rotation is changed.
+          rotation: layoutOption.rotate != null ? layoutOption.rotate * degreeToRadian : defaultLabelAttr.attachedRot,
+          offset: [layoutOption.dx || 0, layoutOption.dy || 0]
+        });
+      }
+      var needsUpdateLabelLine = false;
+      if (layoutOption.x != null) {
+        // TODO width of chart view.
+        label.x = number.parsePercent(layoutOption.x, width);
+        label.setStyle('x', 0); // Ignore movement in style. TODO: origin.
+        needsUpdateLabelLine = true;
+      } else {
+        label.x = defaultLabelAttr.x;
+        label.setStyle('x', defaultLabelAttr.style.x);
+      }
+      if (layoutOption.y != null) {
+        // TODO height of chart view.
+        label.y = number.parsePercent(layoutOption.y, height);
+        label.setStyle('y', 0); // Ignore movement in style.
+        needsUpdateLabelLine = true;
+      } else {
+        label.y = defaultLabelAttr.y;
+        label.setStyle('y', defaultLabelAttr.style.y);
+      }
+      if (layoutOption.labelLinePoints) {
+        var guideLine = hostEl.getTextGuideLine();
+        if (guideLine) {
+          guideLine.setShape({
+            points: layoutOption.labelLinePoints
+          });
+          // Not update
+          needsUpdateLabelLine = false;
+        }
+      }
+      var labelLayoutStore = labelLayoutInnerStore(label);
+      labelLayoutStore.needsUpdateLabelLine = needsUpdateLabelLine;
+      label.rotation = layoutOption.rotate != null ? layoutOption.rotate * degreeToRadian : defaultLabelAttr.rotation;
+      label.scaleX = defaultLabelAttr.scaleX;
+      label.scaleY = defaultLabelAttr.scaleY;
+      for (var k = 0; k < LABEL_OPTION_TO_STYLE_KEYS.length; k++) {
+        var key = LABEL_OPTION_TO_STYLE_KEYS[k];
+        label.setStyle(key, layoutOption[key] != null ? layoutOption[key] : defaultLabelAttr.style[key]);
+      }
+      if (layoutOption.draggable) {
+        label.draggable = true;
+        label.cursor = 'move';
+        if (hostEl) {
+          var hostModel = labelItem.seriesModel;
+          if (labelItem.dataIndex != null) {
+            var data = labelItem.seriesModel.getData(labelItem.dataType);
+            hostModel = data.getItemModel(labelItem.dataIndex);
+          }
+          label.on('drag', createDragHandler(hostEl, hostModel.getModel('labelLine')));
+        }
+      } else {
+        // TODO Other drag functions?
+        label.off('drag');
+        label.cursor = defaultLabelAttr.cursor;
+      }
+    }
+  };
+  LabelManager.prototype.layout = function (api) {
+    var width = api.getWidth();
+    var height = api.getHeight();
+    var labelList = labelLayoutHelper.prepareLayoutList(this._labelList);
+    var labelsNeedsAdjustOnX = util$1.filter(labelList, function (item) {
+      return item.layoutOption.moveOverlap === 'shiftX';
+    });
+    var labelsNeedsAdjustOnY = util$1.filter(labelList, function (item) {
+      return item.layoutOption.moveOverlap === 'shiftY';
+    });
+    labelLayoutHelper.shiftLayoutOnX(labelsNeedsAdjustOnX, 0, width);
+    labelLayoutHelper.shiftLayoutOnY(labelsNeedsAdjustOnY, 0, height);
+    var labelsNeedsHideOverlap = util$1.filter(labelList, function (item) {
+      return item.layoutOption.hideOverlap;
+    });
+    labelLayoutHelper.hideOverlap(labelsNeedsHideOverlap);
+  };
+  /**
+   * Process all labels. Not only labels with layoutOption.
+   */
+  LabelManager.prototype.processLabelsOverall = function () {
+    var _this = this;
+    util$1.each(this._chartViewList, function (chartView) {
+      var seriesModel = chartView.__model;
+      var ignoreLabelLineUpdate = chartView.ignoreLabelLineUpdate;
+      var animationEnabled = seriesModel.isAnimationEnabled();
+      chartView.group.traverse(function (child) {
+        if (child.ignore && !child.forceLabelAnimation) {
+          return true; // Stop traverse descendants.
+        }
+
+        var needsUpdateLabelLine = !ignoreLabelLineUpdate;
+        var label = child.getTextContent();
+        if (!needsUpdateLabelLine && label) {
+          needsUpdateLabelLine = labelLayoutInnerStore(label).needsUpdateLabelLine;
+        }
+        if (needsUpdateLabelLine) {
+          _this._updateLabelLine(child, seriesModel);
+        }
+        if (animationEnabled) {
+          _this._animateLabels(child, seriesModel);
+        }
+      });
+    });
+  };
+  LabelManager.prototype._updateLabelLine = function (el, seriesModel) {
+    // Only support label being hosted on graphic elements.
+    var textEl = el.getTextContent();
+    // Update label line style.
+    var ecData = innerStore.getECData(el);
+    var dataIndex = ecData.dataIndex;
+    // Only support labelLine on the labels represent data.
+    if (textEl && dataIndex != null) {
+      var data = seriesModel.getData(ecData.dataType);
+      var itemModel = data.getItemModel(dataIndex);
+      var defaultStyle = {};
+      var visualStyle = data.getItemVisual(dataIndex, 'style');
+      if (visualStyle) {
+        var visualType = data.getVisual('drawType');
+        // Default to be same with main color
+        defaultStyle.stroke = visualStyle[visualType];
+      }
+      var labelLineModel = itemModel.getModel('labelLine');
+      labelGuideHelper.setLabelLineStyle(el, labelGuideHelper.getLabelLineStatesModels(itemModel), defaultStyle);
+      labelGuideHelper.updateLabelLinePoints(el, labelLineModel);
+    }
+  };
+  LabelManager.prototype._animateLabels = function (el, seriesModel) {
+    var textEl = el.getTextContent();
+    var guideLine = el.getTextGuideLine();
+    // Animate
+    if (textEl
+    // `forceLabelAnimation` has the highest priority
+    && (el.forceLabelAnimation || !textEl.ignore && !textEl.invisible && !el.disableLabelAnimation && !basicTransition.isElementRemoved(el))) {
+      var layoutStore = labelLayoutInnerStore(textEl);
+      var oldLayout = layoutStore.oldLayout;
+      var ecData = innerStore.getECData(el);
+      var dataIndex = ecData.dataIndex;
+      var newProps = {
+        x: textEl.x,
+        y: textEl.y,
+        rotation: textEl.rotation
+      };
+      var data = seriesModel.getData(ecData.dataType);
+      if (!oldLayout) {
+        textEl.attr(newProps);
+        // Disable fade in animation if value animation is enabled.
+        if (!labelStyle.labelInner(textEl).valueAnimation) {
+          var oldOpacity = util$1.retrieve2(textEl.style.opacity, 1);
+          // Fade in animation
+          textEl.style.opacity = 0;
+          basicTransition.initProps(textEl, {
+            style: {
+              opacity: oldOpacity
+            }
+          }, seriesModel, dataIndex);
+        }
+      } else {
+        textEl.attr(oldLayout);
+        // Make sure the animation from is in the right status.
+        var prevStates = el.prevStates;
+        if (prevStates) {
+          if (util$1.indexOf(prevStates, 'select') >= 0) {
+            textEl.attr(layoutStore.oldLayoutSelect);
+          }
+          if (util$1.indexOf(prevStates, 'emphasis') >= 0) {
+            textEl.attr(layoutStore.oldLayoutEmphasis);
+          }
+        }
+        basicTransition.updateProps(textEl, newProps, seriesModel, dataIndex);
+      }
+      layoutStore.oldLayout = newProps;
+      if (textEl.states.select) {
+        var layoutSelect = layoutStore.oldLayoutSelect = {};
+        extendWithKeys(layoutSelect, newProps, LABEL_LAYOUT_PROPS);
+        extendWithKeys(layoutSelect, textEl.states.select, LABEL_LAYOUT_PROPS);
+      }
+      if (textEl.states.emphasis) {
+        var layoutEmphasis = layoutStore.oldLayoutEmphasis = {};
+        extendWithKeys(layoutEmphasis, newProps, LABEL_LAYOUT_PROPS);
+        extendWithKeys(layoutEmphasis, textEl.states.emphasis, LABEL_LAYOUT_PROPS);
+      }
+      labelStyle.animateLabelValue(textEl, dataIndex, data, seriesModel, seriesModel);
+    }
+    if (guideLine && !guideLine.ignore && !guideLine.invisible) {
+      var layoutStore = labelLineAnimationStore(guideLine);
+      var oldLayout = layoutStore.oldLayout;
+      var newLayout = {
+        points: guideLine.shape.points
+      };
+      if (!oldLayout) {
+        guideLine.setShape(newLayout);
+        guideLine.style.strokePercent = 0;
+        basicTransition.initProps(guideLine, {
+          style: {
+            strokePercent: 1
+          }
+        }, seriesModel);
+      } else {
+        guideLine.attr({
+          shape: oldLayout
+        });
+        basicTransition.updateProps(guideLine, {
+          shape: newLayout
+        }, seriesModel);
+      }
+      layoutStore.oldLayout = newLayout;
+    }
+  };
+  return LabelManager;
+}();
+
+exports["default"] = LabelManager;

package/lib/node_modules/echarts/lib/label/installLabelLayout.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var model = require('../util/model.js');
+var LabelManager = require('./LabelManager.js');
+
+var getLabelManager = model.makeInner();
+function installLabelLayout(registers) {
+  registers.registerUpdateLifecycle('series:beforeupdate', function (ecModel, api, params) {
+    // TODO api provide an namespace that can save stuff per instance
+    var labelManager = getLabelManager(api).labelManager;
+    if (!labelManager) {
+      labelManager = getLabelManager(api).labelManager = new LabelManager["default"]();
+    }
+    labelManager.clearLabels();
+  });
+  registers.registerUpdateLifecycle('series:layoutlabels', function (ecModel, api, params) {
+    var labelManager = getLabelManager(api).labelManager;
+    params.updatedSeries.forEach(function (series) {
+      labelManager.addLabelsOfSeries(api.getViewOfSeriesModel(series));
+    });
+    labelManager.updateLayoutConfig(api);
+    labelManager.layout(api);
+    labelManager.processLabelsOverall();
+  });
+}
+
+exports.installLabelLayout = installLabelLayout;