office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/component/visualMap/PiecewiseModel.js

@@ -0,0 +1,397 @@
+import { __extends } from 'tslib';
+import { clone, map, each, isObject } from '../../../../zrender/lib/core/util.js';
+import VisualMapModel from './VisualMapModel.js';
+import VisualMapping from '../../visual/VisualMapping.js';
+import visualDefault from '../../visual/visualDefault.js';
+import { reformIntervals } from '../../util/number.js';
+import { inheritDefaultOption } from '../../util/component.js';
+
+var PiecewiseModel = /** @class */function (_super) {
+  __extends(PiecewiseModel, _super);
+  function PiecewiseModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = PiecewiseModel.type;
+    /**
+     * The order is always [low, ..., high].
+     * [{text: string, interval: Array.<number>}, ...]
+     */
+    _this._pieceList = [];
+    return _this;
+  }
+  PiecewiseModel.prototype.optionUpdated = function (newOption, isInit) {
+    _super.prototype.optionUpdated.apply(this, arguments);
+    this.resetExtent();
+    var mode = this._mode = this._determineMode();
+    this._pieceList = [];
+    resetMethods[this._mode].call(this, this._pieceList);
+    this._resetSelected(newOption, isInit);
+    var categories = this.option.categories;
+    this.resetVisual(function (mappingOption, state) {
+      if (mode === 'categories') {
+        mappingOption.mappingMethod = 'category';
+        mappingOption.categories = clone(categories);
+      } else {
+        mappingOption.dataExtent = this.getExtent();
+        mappingOption.mappingMethod = 'piecewise';
+        mappingOption.pieceList = map(this._pieceList, function (piece) {
+          piece = clone(piece);
+          if (state !== 'inRange') {
+            // FIXME
+            // outOfRange do not support special visual in pieces.
+            piece.visual = null;
+          }
+          return piece;
+        });
+      }
+    });
+  };
+  /**
+   * @protected
+   * @override
+   */
+  PiecewiseModel.prototype.completeVisualOption = function () {
+    // Consider this case:
+    // visualMap: {
+    //      pieces: [{symbol: 'circle', lt: 0}, {symbol: 'rect', gte: 0}]
+    // }
+    // where no inRange/outOfRange set but only pieces. So we should make
+    // default inRange/outOfRange for this case, otherwise visuals that only
+    // appear in `pieces` will not be taken into account in visual encoding.
+    var option = this.option;
+    var visualTypesInPieces = {};
+    var visualTypes = VisualMapping.listVisualTypes();
+    var isCategory = this.isCategory();
+    each(option.pieces, function (piece) {
+      each(visualTypes, function (visualType) {
+        if (piece.hasOwnProperty(visualType)) {
+          visualTypesInPieces[visualType] = 1;
+        }
+      });
+    });
+    each(visualTypesInPieces, function (v, visualType) {
+      var exists = false;
+      each(this.stateList, function (state) {
+        exists = exists || has(option, state, visualType) || has(option.target, state, visualType);
+      }, this);
+      !exists && each(this.stateList, function (state) {
+        (option[state] || (option[state] = {}))[visualType] = visualDefault.get(visualType, state === 'inRange' ? 'active' : 'inactive', isCategory);
+      });
+    }, this);
+    function has(obj, state, visualType) {
+      return obj && obj[state] && obj[state].hasOwnProperty(visualType);
+    }
+    _super.prototype.completeVisualOption.apply(this, arguments);
+  };
+  PiecewiseModel.prototype._resetSelected = function (newOption, isInit) {
+    var thisOption = this.option;
+    var pieceList = this._pieceList;
+    // Selected do not merge but all override.
+    var selected = (isInit ? thisOption : newOption).selected || {};
+    thisOption.selected = selected;
+    // Consider 'not specified' means true.
+    each(pieceList, function (piece, index) {
+      var key = this.getSelectedMapKey(piece);
+      if (!selected.hasOwnProperty(key)) {
+        selected[key] = true;
+      }
+    }, this);
+    if (thisOption.selectedMode === 'single') {
+      // Ensure there is only one selected.
+      var hasSel_1 = false;
+      each(pieceList, function (piece, index) {
+        var key = this.getSelectedMapKey(piece);
+        if (selected[key]) {
+          hasSel_1 ? selected[key] = false : hasSel_1 = true;
+        }
+      }, this);
+    }
+    // thisOption.selectedMode === 'multiple', default: all selected.
+  };
+  /**
+   * @public
+   */
+  PiecewiseModel.prototype.getItemSymbol = function () {
+    return this.get('itemSymbol');
+  };
+  /**
+   * @public
+   */
+  PiecewiseModel.prototype.getSelectedMapKey = function (piece) {
+    return this._mode === 'categories' ? piece.value + '' : piece.index + '';
+  };
+  /**
+   * @public
+   */
+  PiecewiseModel.prototype.getPieceList = function () {
+    return this._pieceList;
+  };
+  /**
+   * @return {string}
+   */
+  PiecewiseModel.prototype._determineMode = function () {
+    var option = this.option;
+    return option.pieces && option.pieces.length > 0 ? 'pieces' : this.option.categories ? 'categories' : 'splitNumber';
+  };
+  /**
+   * @override
+   */
+  PiecewiseModel.prototype.setSelected = function (selected) {
+    this.option.selected = clone(selected);
+  };
+  /**
+   * @override
+   */
+  PiecewiseModel.prototype.getValueState = function (value) {
+    var index = VisualMapping.findPieceIndex(value, this._pieceList);
+    return index != null ? this.option.selected[this.getSelectedMapKey(this._pieceList[index])] ? 'inRange' : 'outOfRange' : 'outOfRange';
+  };
+  /**
+   * @public
+   * @param pieceIndex piece index in visualMapModel.getPieceList()
+   */
+  PiecewiseModel.prototype.findTargetDataIndices = function (pieceIndex) {
+    var result = [];
+    var pieceList = this._pieceList;
+    this.eachTargetSeries(function (seriesModel) {
+      var dataIndices = [];
+      var data = seriesModel.getData();
+      data.each(this.getDataDimensionIndex(data), function (value, dataIndex) {
+        // Should always base on model pieceList, because it is order sensitive.
+        var pIdx = VisualMapping.findPieceIndex(value, pieceList);
+        pIdx === pieceIndex && dataIndices.push(dataIndex);
+      }, this);
+      result.push({
+        seriesId: seriesModel.id,
+        dataIndex: dataIndices
+      });
+    }, this);
+    return result;
+  };
+  /**
+   * @private
+   * @param piece piece.value or piece.interval is required.
+   * @return  Can be Infinity or -Infinity
+   */
+  PiecewiseModel.prototype.getRepresentValue = function (piece) {
+    var representValue;
+    if (this.isCategory()) {
+      representValue = piece.value;
+    } else {
+      if (piece.value != null) {
+        representValue = piece.value;
+      } else {
+        var pieceInterval = piece.interval || [];
+        representValue = pieceInterval[0] === -Infinity && pieceInterval[1] === Infinity ? 0 : (pieceInterval[0] + pieceInterval[1]) / 2;
+      }
+    }
+    return representValue;
+  };
+  PiecewiseModel.prototype.getVisualMeta = function (getColorVisual) {
+    // Do not support category. (category axis is ordinal, numerical)
+    if (this.isCategory()) {
+      return;
+    }
+    var stops = [];
+    var outerColors = ['', ''];
+    var visualMapModel = this;
+    function setStop(interval, valueState) {
+      var representValue = visualMapModel.getRepresentValue({
+        interval: interval
+      }); // Not category
+      if (!valueState) {
+        valueState = visualMapModel.getValueState(representValue);
+      }
+      var color = getColorVisual(representValue, valueState);
+      if (interval[0] === -Infinity) {
+        outerColors[0] = color;
+      } else if (interval[1] === Infinity) {
+        outerColors[1] = color;
+      } else {
+        stops.push({
+          value: interval[0],
+          color: color
+        }, {
+          value: interval[1],
+          color: color
+        });
+      }
+    }
+    // Suplement
+    var pieceList = this._pieceList.slice();
+    if (!pieceList.length) {
+      pieceList.push({
+        interval: [-Infinity, Infinity]
+      });
+    } else {
+      var edge = pieceList[0].interval[0];
+      edge !== -Infinity && pieceList.unshift({
+        interval: [-Infinity, edge]
+      });
+      edge = pieceList[pieceList.length - 1].interval[1];
+      edge !== Infinity && pieceList.push({
+        interval: [edge, Infinity]
+      });
+    }
+    var curr = -Infinity;
+    each(pieceList, function (piece) {
+      var interval = piece.interval;
+      if (interval) {
+        // Fulfill gap.
+        interval[0] > curr && setStop([curr, interval[0]], 'outOfRange');
+        setStop(interval.slice());
+        curr = interval[1];
+      }
+    }, this);
+    return {
+      stops: stops,
+      outerColors: outerColors
+    };
+  };
+  PiecewiseModel.type = 'visualMap.piecewise';
+  PiecewiseModel.defaultOption = inheritDefaultOption(VisualMapModel.defaultOption, {
+    selected: null,
+    minOpen: false,
+    maxOpen: false,
+    align: 'auto',
+    itemWidth: 20,
+    itemHeight: 14,
+    itemSymbol: 'roundRect',
+    pieces: null,
+    categories: null,
+    splitNumber: 5,
+    selectedMode: 'multiple',
+    itemGap: 10,
+    hoverLink: true // Enable hover highlight.
+  });
+
+  return PiecewiseModel;
+}(VisualMapModel);
+/**
+ * Key is this._mode
+ * @type {Object}
+ * @this {module:echarts/component/viusalMap/PiecewiseMode}
+ */
+var resetMethods = {
+  splitNumber: function (outPieceList) {
+    var thisOption = this.option;
+    var precision = Math.min(thisOption.precision, 20);
+    var dataExtent = this.getExtent();
+    var splitNumber = thisOption.splitNumber;
+    splitNumber = Math.max(parseInt(splitNumber, 10), 1);
+    thisOption.splitNumber = splitNumber;
+    var splitStep = (dataExtent[1] - dataExtent[0]) / splitNumber;
+    // Precision auto-adaption
+    while (+splitStep.toFixed(precision) !== splitStep && precision < 5) {
+      precision++;
+    }
+    thisOption.precision = precision;
+    splitStep = +splitStep.toFixed(precision);
+    if (thisOption.minOpen) {
+      outPieceList.push({
+        interval: [-Infinity, dataExtent[0]],
+        close: [0, 0]
+      });
+    }
+    for (var index = 0, curr = dataExtent[0]; index < splitNumber; curr += splitStep, index++) {
+      var max = index === splitNumber - 1 ? dataExtent[1] : curr + splitStep;
+      outPieceList.push({
+        interval: [curr, max],
+        close: [1, 1]
+      });
+    }
+    if (thisOption.maxOpen) {
+      outPieceList.push({
+        interval: [dataExtent[1], Infinity],
+        close: [0, 0]
+      });
+    }
+    reformIntervals(outPieceList);
+    each(outPieceList, function (piece, index) {
+      piece.index = index;
+      piece.text = this.formatValueText(piece.interval);
+    }, this);
+  },
+  categories: function (outPieceList) {
+    var thisOption = this.option;
+    each(thisOption.categories, function (cate) {
+      // FIXME category模式也使用pieceList，但在visualMapping中不是使用pieceList。
+      // 是否改一致。
+      outPieceList.push({
+        text: this.formatValueText(cate, true),
+        value: cate
+      });
+    }, this);
+    // See "Order Rule".
+    normalizeReverse(thisOption, outPieceList);
+  },
+  pieces: function (outPieceList) {
+    var thisOption = this.option;
+    each(thisOption.pieces, function (pieceListItem, index) {
+      if (!isObject(pieceListItem)) {
+        pieceListItem = {
+          value: pieceListItem
+        };
+      }
+      var item = {
+        text: '',
+        index: index
+      };
+      if (pieceListItem.label != null) {
+        item.text = pieceListItem.label;
+      }
+      if (pieceListItem.hasOwnProperty('value')) {
+        var value = item.value = pieceListItem.value;
+        item.interval = [value, value];
+        item.close = [1, 1];
+      } else {
+        // `min` `max` is legacy option.
+        // `lt` `gt` `lte` `gte` is recommended.
+        var interval = item.interval = [];
+        var close_1 = item.close = [0, 0];
+        var closeList = [1, 0, 1];
+        var infinityList = [-Infinity, Infinity];
+        var useMinMax = [];
+        for (var lg = 0; lg < 2; lg++) {
+          var names = [['gte', 'gt', 'min'], ['lte', 'lt', 'max']][lg];
+          for (var i = 0; i < 3 && interval[lg] == null; i++) {
+            interval[lg] = pieceListItem[names[i]];
+            close_1[lg] = closeList[i];
+            useMinMax[lg] = i === 2;
+          }
+          interval[lg] == null && (interval[lg] = infinityList[lg]);
+        }
+        useMinMax[0] && interval[1] === Infinity && (close_1[0] = 0);
+        useMinMax[1] && interval[0] === -Infinity && (close_1[1] = 0);
+        if (process.env.NODE_ENV !== 'production') {
+          if (interval[0] > interval[1]) {
+            console.warn('Piece ' + index + 'is illegal: ' + interval + ' lower bound should not greater then uppper bound.');
+          }
+        }
+        if (interval[0] === interval[1] && close_1[0] && close_1[1]) {
+          // Consider: [{min: 5, max: 5, visual: {...}}, {min: 0, max: 5}],
+          // we use value to lift the priority when min === max
+          item.value = interval[0];
+        }
+      }
+      item.visual = VisualMapping.retrieveVisuals(pieceListItem);
+      outPieceList.push(item);
+    }, this);
+    // See "Order Rule".
+    normalizeReverse(thisOption, outPieceList);
+    // Only pieces
+    reformIntervals(outPieceList);
+    each(outPieceList, function (piece) {
+      var close = piece.close;
+      var edgeSymbols = [['<', '≤'][close[1]], ['>', '≥'][close[0]]];
+      piece.text = piece.text || this.formatValueText(piece.value != null ? piece.value : piece.interval, false, edgeSymbols);
+    }, this);
+  }
+};
+function normalizeReverse(thisOption, pieceList) {
+  var inverse = thisOption.inverse;
+  if (thisOption.orient === 'vertical' ? !inverse : inverse) {
+    pieceList.reverse();
+  }
+}
+
+export { PiecewiseModel as default };

package/esm/node_modules/echarts/lib/component/visualMap/PiecewiseView.js

@@ -0,0 +1,174 @@
+import { __extends } from 'tslib';
+import { retrieve, each, bind, map, clone } from '../../../../zrender/lib/core/util.js';
+import VisualMapView from './VisualMapView.js';
+import '../../util/graphic.js';
+import { createSymbol } from '../../util/symbol.js';
+import { box } from '../../util/layout.js';
+import { makeHighDownBatch, getItemAlign } from './helper.js';
+import { createTextStyle } from '../../label/labelStyle.js';
+import Group from '../../../../zrender/lib/graphic/Group.js';
+import ZRText from '../../../../zrender/lib/graphic/Text.js';
+
+var PiecewiseVisualMapView = /** @class */function (_super) {
+  __extends(PiecewiseVisualMapView, _super);
+  function PiecewiseVisualMapView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = PiecewiseVisualMapView.type;
+    return _this;
+  }
+  PiecewiseVisualMapView.prototype.doRender = function () {
+    var thisGroup = this.group;
+    thisGroup.removeAll();
+    var visualMapModel = this.visualMapModel;
+    var textGap = visualMapModel.get('textGap');
+    var textStyleModel = visualMapModel.textStyleModel;
+    var textFont = textStyleModel.getFont();
+    var textFill = textStyleModel.getTextColor();
+    var itemAlign = this._getItemAlign();
+    var itemSize = visualMapModel.itemSize;
+    var viewData = this._getViewData();
+    var endsText = viewData.endsText;
+    var showLabel = retrieve(visualMapModel.get('showLabel', true), !endsText);
+    endsText && this._renderEndsText(thisGroup, endsText[0], itemSize, showLabel, itemAlign);
+    each(viewData.viewPieceList, function (item) {
+      var piece = item.piece;
+      var itemGroup = new Group();
+      itemGroup.onclick = bind(this._onItemClick, this, piece);
+      this._enableHoverLink(itemGroup, item.indexInModelPieceList);
+      // TODO Category
+      var representValue = visualMapModel.getRepresentValue(piece);
+      this._createItemSymbol(itemGroup, representValue, [0, 0, itemSize[0], itemSize[1]]);
+      if (showLabel) {
+        var visualState = this.visualMapModel.getValueState(representValue);
+        itemGroup.add(new ZRText({
+          style: {
+            x: itemAlign === 'right' ? -textGap : itemSize[0] + textGap,
+            y: itemSize[1] / 2,
+            text: piece.text,
+            verticalAlign: 'middle',
+            align: itemAlign,
+            font: textFont,
+            fill: textFill,
+            opacity: visualState === 'outOfRange' ? 0.5 : 1
+          }
+        }));
+      }
+      thisGroup.add(itemGroup);
+    }, this);
+    endsText && this._renderEndsText(thisGroup, endsText[1], itemSize, showLabel, itemAlign);
+    box(visualMapModel.get('orient'), thisGroup, visualMapModel.get('itemGap'));
+    this.renderBackground(thisGroup);
+    this.positionGroup(thisGroup);
+  };
+  PiecewiseVisualMapView.prototype._enableHoverLink = function (itemGroup, pieceIndex) {
+    var _this = this;
+    itemGroup.on('mouseover', function () {
+      return onHoverLink('highlight');
+    }).on('mouseout', function () {
+      return onHoverLink('downplay');
+    });
+    var onHoverLink = function (method) {
+      var visualMapModel = _this.visualMapModel;
+      // TODO: TYPE More detailed action types
+      visualMapModel.option.hoverLink && _this.api.dispatchAction({
+        type: method,
+        batch: makeHighDownBatch(visualMapModel.findTargetDataIndices(pieceIndex), visualMapModel)
+      });
+    };
+  };
+  PiecewiseVisualMapView.prototype._getItemAlign = function () {
+    var visualMapModel = this.visualMapModel;
+    var modelOption = visualMapModel.option;
+    if (modelOption.orient === 'vertical') {
+      return getItemAlign(visualMapModel, this.api, visualMapModel.itemSize);
+    } else {
+      // horizontal, most case left unless specifying right.
+      var align = modelOption.align;
+      if (!align || align === 'auto') {
+        align = 'left';
+      }
+      return align;
+    }
+  };
+  PiecewiseVisualMapView.prototype._renderEndsText = function (group, text, itemSize, showLabel, itemAlign) {
+    if (!text) {
+      return;
+    }
+    var itemGroup = new Group();
+    var textStyleModel = this.visualMapModel.textStyleModel;
+    itemGroup.add(new ZRText({
+      style: createTextStyle(textStyleModel, {
+        x: showLabel ? itemAlign === 'right' ? itemSize[0] : 0 : itemSize[0] / 2,
+        y: itemSize[1] / 2,
+        verticalAlign: 'middle',
+        align: showLabel ? itemAlign : 'center',
+        text: text
+      })
+    }));
+    group.add(itemGroup);
+  };
+  /**
+   * @private
+   * @return {Object} {peiceList, endsText} The order is the same as screen pixel order.
+   */
+  PiecewiseVisualMapView.prototype._getViewData = function () {
+    var visualMapModel = this.visualMapModel;
+    var viewPieceList = map(visualMapModel.getPieceList(), function (piece, index) {
+      return {
+        piece: piece,
+        indexInModelPieceList: index
+      };
+    });
+    var endsText = visualMapModel.get('text');
+    // Consider orient and inverse.
+    var orient = visualMapModel.get('orient');
+    var inverse = visualMapModel.get('inverse');
+    // Order of model pieceList is always [low, ..., high]
+    if (orient === 'horizontal' ? inverse : !inverse) {
+      viewPieceList.reverse();
+    }
+    // Origin order of endsText is [high, low]
+    else if (endsText) {
+      endsText = endsText.slice().reverse();
+    }
+    return {
+      viewPieceList: viewPieceList,
+      endsText: endsText
+    };
+  };
+  PiecewiseVisualMapView.prototype._createItemSymbol = function (group, representValue, shapeParam) {
+    group.add(createSymbol(
+    // symbol will be string
+    this.getControllerVisual(representValue, 'symbol'), shapeParam[0], shapeParam[1], shapeParam[2], shapeParam[3],
+    // color will be string
+    this.getControllerVisual(representValue, 'color')));
+  };
+  PiecewiseVisualMapView.prototype._onItemClick = function (piece) {
+    var visualMapModel = this.visualMapModel;
+    var option = visualMapModel.option;
+    var selectedMode = option.selectedMode;
+    if (!selectedMode) {
+      return;
+    }
+    var selected = clone(option.selected);
+    var newKey = visualMapModel.getSelectedMapKey(piece);
+    if (selectedMode === 'single' || selectedMode === true) {
+      selected[newKey] = true;
+      each(selected, function (o, key) {
+        selected[key] = key === newKey;
+      });
+    } else {
+      selected[newKey] = !selected[newKey];
+    }
+    this.api.dispatchAction({
+      type: 'selectDataRange',
+      from: this.uid,
+      visualMapId: this.visualMapModel.id,
+      selected: selected
+    });
+  };
+  PiecewiseVisualMapView.type = 'visualMap.piecewise';
+  return PiecewiseVisualMapView;
+}(VisualMapView);
+
+export { PiecewiseVisualMapView as default };