office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/chart/map/MapSeries.js

@@ -0,0 +1,206 @@
+import { __extends } from 'tslib';
+import { curry, createHashMap, each } from '../../../../zrender/lib/core/util.js';
+import createSeriesDataSimply from '../helper/createSeriesDataSimply.js';
+import SeriesModel from '../../model/Series.js';
+import geoSourceManager from '../../coord/geo/geoSourceManager.js';
+import { makeSeriesEncodeForNameBased } from '../../data/helper/sourceHelper.js';
+import { createTooltipMarkup } from '../../component/tooltip/tooltipMarkup.js';
+import { createSymbol } from '../../util/symbol.js';
+
+var MapSeries = /** @class */function (_super) {
+  __extends(MapSeries, _super);
+  function MapSeries() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = MapSeries.type;
+    // Only first map series of same mapType will drawMap.
+    _this.needsDrawMap = false;
+    // Group of all map series with same mapType
+    _this.seriesGroup = [];
+    _this.getTooltipPosition = function (dataIndex) {
+      if (dataIndex != null) {
+        var name_1 = this.getData().getName(dataIndex);
+        var geo = this.coordinateSystem;
+        var region = geo.getRegion(name_1);
+        return region && geo.dataToPoint(region.getCenter());
+      }
+    };
+    return _this;
+  }
+  MapSeries.prototype.getInitialData = function (option) {
+    var data = createSeriesDataSimply(this, {
+      coordDimensions: ['value'],
+      encodeDefaulter: curry(makeSeriesEncodeForNameBased, this)
+    });
+    var dataNameMap = createHashMap();
+    var toAppendNames = [];
+    for (var i = 0, len = data.count(); i < len; i++) {
+      var name_2 = data.getName(i);
+      dataNameMap.set(name_2, true);
+    }
+    var geoSource = geoSourceManager.load(this.getMapType(), this.option.nameMap, this.option.nameProperty);
+    each(geoSource.regions, function (region) {
+      var name = region.name;
+      if (!dataNameMap.get(name)) {
+        toAppendNames.push(name);
+      }
+    });
+    // Complete data with missing regions. The consequent processes (like visual
+    // map and render) can not be performed without a "full data". For example,
+    // find `dataIndex` by name.
+    data.appendValues([], toAppendNames);
+    return data;
+  };
+  /**
+   * If no host geo model, return null, which means using a
+   * inner exclusive geo model.
+   */
+  MapSeries.prototype.getHostGeoModel = function () {
+    var geoIndex = this.option.geoIndex;
+    return geoIndex != null ? this.ecModel.getComponent('geo', geoIndex) : null;
+  };
+  MapSeries.prototype.getMapType = function () {
+    return (this.getHostGeoModel() || this).option.map;
+  };
+  // _fillOption(option, mapName) {
+  // Shallow clone
+  // option = zrUtil.extend({}, option);
+  // option.data = geoCreator.getFilledRegions(option.data, mapName, option.nameMap);
+  // return option;
+  // }
+  MapSeries.prototype.getRawValue = function (dataIndex) {
+    // Use value stored in data instead because it is calculated from multiple series
+    // FIXME Provide all value of multiple series ?
+    var data = this.getData();
+    return data.get(data.mapDimension('value'), dataIndex);
+  };
+  /**
+   * Get model of region
+   */
+  MapSeries.prototype.getRegionModel = function (regionName) {
+    var data = this.getData();
+    return data.getItemModel(data.indexOfName(regionName));
+  };
+  /**
+   * Map tooltip formatter
+   */
+  MapSeries.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+    // FIXME orignalData and data is a bit confusing
+    var data = this.getData();
+    var value = this.getRawValue(dataIndex);
+    var name = data.getName(dataIndex);
+    var seriesGroup = this.seriesGroup;
+    var seriesNames = [];
+    for (var i = 0; i < seriesGroup.length; i++) {
+      var otherIndex = seriesGroup[i].originalData.indexOfName(name);
+      var valueDim = data.mapDimension('value');
+      if (!isNaN(seriesGroup[i].originalData.get(valueDim, otherIndex))) {
+        seriesNames.push(seriesGroup[i].name);
+      }
+    }
+    return createTooltipMarkup('section', {
+      header: seriesNames.join(', '),
+      noHeader: !seriesNames.length,
+      blocks: [createTooltipMarkup('nameValue', {
+        name: name,
+        value: value
+      })]
+    });
+  };
+  MapSeries.prototype.setZoom = function (zoom) {
+    this.option.zoom = zoom;
+  };
+  MapSeries.prototype.setCenter = function (center) {
+    this.option.center = center;
+  };
+  MapSeries.prototype.getLegendIcon = function (opt) {
+    var iconType = opt.icon || 'roundRect';
+    var icon = createSymbol(iconType, 0, 0, opt.itemWidth, opt.itemHeight, opt.itemStyle.fill);
+    icon.setStyle(opt.itemStyle);
+    // Map do not use itemStyle.borderWidth as border width
+    icon.style.stroke = 'none';
+    // No rotation because no series visual symbol for map
+    if (iconType.indexOf('empty') > -1) {
+      icon.style.stroke = icon.style.fill;
+      icon.style.fill = '#fff';
+      icon.style.lineWidth = 2;
+    }
+    return icon;
+  };
+  MapSeries.type = 'series.map';
+  MapSeries.dependencies = ['geo'];
+  MapSeries.layoutMode = 'box';
+  MapSeries.defaultOption = {
+    // 一级层叠
+    // zlevel: 0,
+    // 二级层叠
+    z: 2,
+    coordinateSystem: 'geo',
+    // map should be explicitly specified since ec3.
+    map: '',
+    // If `geoIndex` is not specified, a exclusive geo will be
+    // created. Otherwise use the specified geo component, and
+    // `map` and `mapType` are ignored.
+    // geoIndex: 0,
+    // 'center' | 'left' | 'right' | 'x%' | {number}
+    left: 'center',
+    // 'center' | 'top' | 'bottom' | 'x%' | {number}
+    top: 'center',
+    // right
+    // bottom
+    // width:
+    // height
+    // Aspect is width / height. Inited to be geoJson bbox aspect
+    // This parameter is used for scale this aspect
+    // Default value:
+    // for geoSVG source: 1,
+    // for geoJSON source: 0.75.
+    aspectScale: null,
+    // Layout with center and size
+    // If you want to put map in a fixed size box with right aspect ratio
+    // This two properties may be more convenient.
+    // layoutCenter: [50%, 50%]
+    // layoutSize: 100
+    showLegendSymbol: true,
+    // Define left-top, right-bottom coords to control view
+    // For example, [ [180, 90], [-180, -90] ],
+    // higher priority than center and zoom
+    boundingCoords: null,
+    // Default on center of map
+    center: null,
+    zoom: 1,
+    scaleLimit: null,
+    selectedMode: true,
+    label: {
+      show: false,
+      color: '#000'
+    },
+    // scaleLimit: null,
+    itemStyle: {
+      borderWidth: 0.5,
+      borderColor: '#444',
+      areaColor: '#eee'
+    },
+    emphasis: {
+      label: {
+        show: true,
+        color: 'rgb(100,0,0)'
+      },
+      itemStyle: {
+        areaColor: 'rgba(255,215,0,0.8)'
+      }
+    },
+    select: {
+      label: {
+        show: true,
+        color: 'rgb(100,0,0)'
+      },
+      itemStyle: {
+        color: 'rgba(255,215,0,0.8)'
+      }
+    },
+    nameProperty: 'name'
+  };
+  return MapSeries;
+}(SeriesModel);
+
+export { MapSeries as default };

package/esm/node_modules/echarts/lib/chart/map/MapView.js

@@ -0,0 +1,137 @@
+import { __extends } from 'tslib';
+import '../../util/graphic.js';
+import MapDraw from '../../component/helper/MapDraw.js';
+import ChartView from '../../view/Chart.js';
+import { setLabelStyle, getLabelStatesModels } from '../../label/labelStyle.js';
+import { Z2_EMPHASIS_LIFT, setStatesFlag } from '../../util/states.js';
+import Circle from '../../../../zrender/lib/graphic/shape/Circle.js';
+
+var MapView = /** @class */function (_super) {
+  __extends(MapView, _super);
+  function MapView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = MapView.type;
+    return _this;
+  }
+  MapView.prototype.render = function (mapModel, ecModel, api, payload) {
+    // Not render if it is an toggleSelect action from self
+    if (payload && payload.type === 'mapToggleSelect' && payload.from === this.uid) {
+      return;
+    }
+    var group = this.group;
+    group.removeAll();
+    if (mapModel.getHostGeoModel()) {
+      return;
+    }
+    if (this._mapDraw && payload && payload.type === 'geoRoam') {
+      this._mapDraw.resetForLabelLayout();
+    }
+    // Not update map if it is an roam action from self
+    if (!(payload && payload.type === 'geoRoam' && payload.componentType === 'series' && payload.seriesId === mapModel.id)) {
+      if (mapModel.needsDrawMap) {
+        var mapDraw = this._mapDraw || new MapDraw(api);
+        group.add(mapDraw.group);
+        mapDraw.draw(mapModel, ecModel, api, this, payload);
+        this._mapDraw = mapDraw;
+      } else {
+        // Remove drawn map
+        this._mapDraw && this._mapDraw.remove();
+        this._mapDraw = null;
+      }
+    } else {
+      var mapDraw = this._mapDraw;
+      mapDraw && group.add(mapDraw.group);
+    }
+    mapModel.get('showLegendSymbol') && ecModel.getComponent('legend') && this._renderSymbols(mapModel, ecModel, api);
+  };
+  MapView.prototype.remove = function () {
+    this._mapDraw && this._mapDraw.remove();
+    this._mapDraw = null;
+    this.group.removeAll();
+  };
+  MapView.prototype.dispose = function () {
+    this._mapDraw && this._mapDraw.remove();
+    this._mapDraw = null;
+  };
+  MapView.prototype._renderSymbols = function (mapModel, ecModel, api) {
+    var originalData = mapModel.originalData;
+    var group = this.group;
+    originalData.each(originalData.mapDimension('value'), function (value, originalDataIndex) {
+      if (isNaN(value)) {
+        return;
+      }
+      var layout = originalData.getItemLayout(originalDataIndex);
+      if (!layout || !layout.point) {
+        // Not exists in map
+        return;
+      }
+      var point = layout.point;
+      var offset = layout.offset;
+      var circle = new Circle({
+        style: {
+          // Because the special of map draw.
+          // Which needs statistic of multiple series and draw on one map.
+          // And each series also need a symbol with legend color
+          //
+          // Layout and visual are put one the different data
+          // TODO
+          fill: mapModel.getData().getVisual('style').fill
+        },
+        shape: {
+          cx: point[0] + offset * 9,
+          cy: point[1],
+          r: 3
+        },
+        silent: true,
+        // Do not overlap the first series, on which labels are displayed.
+        z2: 8 + (!offset ? Z2_EMPHASIS_LIFT + 1 : 0)
+      });
+      // Only the series that has the first value on the same region is in charge of rendering the label.
+      // But consider the case:
+      // series: [
+      //     {id: 'X', type: 'map', map: 'm', {data: [{name: 'A', value: 11}, {name: 'B', {value: 22}]},
+      //     {id: 'Y', type: 'map', map: 'm', {data: [{name: 'A', value: 21}, {name: 'C', {value: 33}]}
+      // ]
+      // The offset `0` of item `A` is at series `X`, but of item `C` is at series `Y`.
+      // For backward compatibility, we follow the rule that render label `A` by the
+      // settings on series `X` but render label `C` by the settings on series `Y`.
+      if (!offset) {
+        var fullData = mapModel.mainSeries.getData();
+        var name_1 = originalData.getName(originalDataIndex);
+        var fullIndex_1 = fullData.indexOfName(name_1);
+        var itemModel = originalData.getItemModel(originalDataIndex);
+        var labelModel = itemModel.getModel('label');
+        var regionGroup = fullData.getItemGraphicEl(fullIndex_1);
+        // `getFormattedLabel` needs to use `getData` inside. Here
+        // `mapModel.getData()` is shallow cloned from `mainSeries.getData()`.
+        // FIXME
+        // If this is not the `mainSeries`, the item model (like label formatter)
+        // set on original data item will never get. But it has been working
+        // like that from the beginning, and this scenario is rarely encountered.
+        // So it won't be fixed until we have to.
+        setLabelStyle(circle, getLabelStatesModels(itemModel), {
+          labelFetcher: {
+            getFormattedLabel: function (idx, state) {
+              return mapModel.getFormattedLabel(fullIndex_1, state);
+            }
+          },
+          defaultText: name_1
+        });
+        circle.disableLabelAnimation = true;
+        if (!labelModel.get('position')) {
+          circle.setTextConfig({
+            position: 'bottom'
+          });
+        }
+        regionGroup.onHoverStateChange = function (toState) {
+          setStatesFlag(circle, toState);
+        };
+      }
+      group.add(circle);
+    });
+  };
+  MapView.type = 'map';
+  return MapView;
+}(ChartView);
+
+export { MapView as default };

package/esm/node_modules/echarts/lib/chart/map/install.js

@@ -0,0 +1,18 @@
+import { use } from '../../extension.js';
+import MapView from './MapView.js';
+import MapSeries from './MapSeries.js';
+import mapDataStatistic from './mapDataStatistic.js';
+import mapSymbolLayout from './mapSymbolLayout.js';
+import { createLegacyDataSelectAction } from '../../legacy/dataSelectAction.js';
+import { install as install$1 } from '../../component/geo/install.js';
+
+function install(registers) {
+  use(install$1);
+  registers.registerChartView(MapView);
+  registers.registerSeriesModel(MapSeries);
+  registers.registerLayout(mapSymbolLayout);
+  registers.registerProcessor(registers.PRIORITY.PROCESSOR.STATISTIC, mapDataStatistic);
+  createLegacyDataSelectAction('map', registers.registerAction);
+}
+
+export { install };

package/esm/node_modules/echarts/lib/chart/map/mapDataStatistic.js

@@ -0,0 +1,64 @@
+import { each, map } from '../../../../zrender/lib/core/util.js';
+
+// FIXME 公用？
+function dataStatistics(datas, statisticType) {
+  var dataNameMap = {};
+  each(datas, function (data) {
+    data.each(data.mapDimension('value'), function (value, idx) {
+      // Add prefix to avoid conflict with Object.prototype.
+      var mapKey = 'ec-' + data.getName(idx);
+      dataNameMap[mapKey] = dataNameMap[mapKey] || [];
+      if (!isNaN(value)) {
+        dataNameMap[mapKey].push(value);
+      }
+    });
+  });
+  return datas[0].map(datas[0].mapDimension('value'), function (value, idx) {
+    var mapKey = 'ec-' + datas[0].getName(idx);
+    var sum = 0;
+    var min = Infinity;
+    var max = -Infinity;
+    var len = dataNameMap[mapKey].length;
+    for (var i = 0; i < len; i++) {
+      min = Math.min(min, dataNameMap[mapKey][i]);
+      max = Math.max(max, dataNameMap[mapKey][i]);
+      sum += dataNameMap[mapKey][i];
+    }
+    var result;
+    if (statisticType === 'min') {
+      result = min;
+    } else if (statisticType === 'max') {
+      result = max;
+    } else if (statisticType === 'average') {
+      result = sum / len;
+    } else {
+      result = sum;
+    }
+    return len === 0 ? NaN : result;
+  });
+}
+function mapDataStatistic(ecModel) {
+  var seriesGroups = {};
+  ecModel.eachSeriesByType('map', function (seriesModel) {
+    var hostGeoModel = seriesModel.getHostGeoModel();
+    var key = hostGeoModel ? 'o' + hostGeoModel.id : 'i' + seriesModel.getMapType();
+    (seriesGroups[key] = seriesGroups[key] || []).push(seriesModel);
+  });
+  each(seriesGroups, function (seriesList, key) {
+    var data = dataStatistics(map(seriesList, function (seriesModel) {
+      return seriesModel.getData();
+    }), seriesList[0].get('mapValueCalculation'));
+    for (var i = 0; i < seriesList.length; i++) {
+      seriesList[i].originalData = seriesList[i].getData();
+    }
+    // FIXME Put where?
+    for (var i = 0; i < seriesList.length; i++) {
+      seriesList[i].seriesGroup = seriesList;
+      seriesList[i].needsDrawMap = i === 0 && !seriesList[i].getHostGeoModel();
+      seriesList[i].setData(data.cloneShallow());
+      seriesList[i].mainSeries = seriesList[0];
+    }
+  });
+}
+
+export { mapDataStatistic as default };

package/esm/node_modules/echarts/lib/chart/map/mapSymbolLayout.js

@@ -0,0 +1,46 @@
+import { each } from '../../../../zrender/lib/core/util.js';
+
+function mapSymbolLayout(ecModel) {
+  var processedMapType = {};
+  ecModel.eachSeriesByType('map', function (mapSeries) {
+    var mapType = mapSeries.getMapType();
+    if (mapSeries.getHostGeoModel() || processedMapType[mapType]) {
+      return;
+    }
+    var mapSymbolOffsets = {};
+    each(mapSeries.seriesGroup, function (subMapSeries) {
+      var geo = subMapSeries.coordinateSystem;
+      var data = subMapSeries.originalData;
+      if (subMapSeries.get('showLegendSymbol') && ecModel.getComponent('legend')) {
+        data.each(data.mapDimension('value'), function (value, idx) {
+          var name = data.getName(idx);
+          var region = geo.getRegion(name);
+          // If input series.data is [11, 22, '-'/null/undefined, 44],
+          // it will be filled with NaN: [11, 22, NaN, 44] and NaN will
+          // not be drawn. So here must validate if value is NaN.
+          if (!region || isNaN(value)) {
+            return;
+          }
+          var offset = mapSymbolOffsets[name] || 0;
+          var point = geo.dataToPoint(region.getCenter());
+          mapSymbolOffsets[name] = offset + 1;
+          data.setItemLayout(idx, {
+            point: point,
+            offset: offset
+          });
+        });
+      }
+    });
+    // Show label of those region not has legendIcon (which is offset 0)
+    var data = mapSeries.getData();
+    data.each(function (idx) {
+      var name = data.getName(idx);
+      var layout = data.getItemLayout(idx) || {};
+      layout.showLabel = !mapSymbolOffsets[name];
+      data.setItemLayout(idx, layout);
+    });
+    processedMapType[mapType] = true;
+  });
+}
+
+export { mapSymbolLayout as default };

package/esm/node_modules/echarts/lib/chart/parallel/ParallelSeries.js

@@ -0,0 +1,86 @@
+import { __extends } from 'tslib';
+import { bind, each } from '../../../../zrender/lib/core/util.js';
+import SeriesModel from '../../model/Series.js';
+import createSeriesData from '../helper/createSeriesData.js';
+
+var ParallelSeriesModel = /** @class */function (_super) {
+  __extends(ParallelSeriesModel, _super);
+  function ParallelSeriesModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = ParallelSeriesModel.type;
+    _this.visualStyleAccessPath = 'lineStyle';
+    _this.visualDrawType = 'stroke';
+    return _this;
+  }
+  ParallelSeriesModel.prototype.getInitialData = function (option, ecModel) {
+    return createSeriesData(null, this, {
+      useEncodeDefaulter: bind(makeDefaultEncode, null, this)
+    });
+  };
+  /**
+   * User can get data raw indices on 'axisAreaSelected' event received.
+   *
+   * @return Raw indices
+   */
+  ParallelSeriesModel.prototype.getRawIndicesByActiveState = function (activeState) {
+    var coordSys = this.coordinateSystem;
+    var data = this.getData();
+    var indices = [];
+    coordSys.eachActiveState(data, function (theActiveState, dataIndex) {
+      if (activeState === theActiveState) {
+        indices.push(data.getRawIndex(dataIndex));
+      }
+    });
+    return indices;
+  };
+  ParallelSeriesModel.type = 'series.parallel';
+  ParallelSeriesModel.dependencies = ['parallel'];
+  ParallelSeriesModel.defaultOption = {
+    // zlevel: 0,
+    z: 2,
+    coordinateSystem: 'parallel',
+    parallelIndex: 0,
+    label: {
+      show: false
+    },
+    inactiveOpacity: 0.05,
+    activeOpacity: 1,
+    lineStyle: {
+      width: 1,
+      opacity: 0.45,
+      type: 'solid'
+    },
+    emphasis: {
+      label: {
+        show: false
+      }
+    },
+    progressive: 500,
+    smooth: false,
+    animationEasing: 'linear'
+  };
+  return ParallelSeriesModel;
+}(SeriesModel);
+function makeDefaultEncode(seriesModel) {
+  // The mapping of parallelAxis dimension to data dimension can
+  // be specified in parallelAxis.option.dim. For example, if
+  // parallelAxis.option.dim is 'dim3', it mapping to the third
+  // dimension of data. But `data.encode` has higher priority.
+  // Moreover, parallelModel.dimension should not be regarded as data
+  // dimensions. Consider dimensions = ['dim4', 'dim2', 'dim6'];
+  var parallelModel = seriesModel.ecModel.getComponent('parallel', seriesModel.get('parallelIndex'));
+  if (!parallelModel) {
+    return;
+  }
+  var encodeDefine = {};
+  each(parallelModel.dimensions, function (axisDim) {
+    var dataDimIndex = convertDimNameToNumber(axisDim);
+    encodeDefine[axisDim] = dataDimIndex;
+  });
+  return encodeDefine;
+}
+function convertDimNameToNumber(dimName) {
+  return +dimName.replace('dim', '');
+}
+
+export { ParallelSeriesModel as default };