office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/coord/geo/geoCreator.js

@@ -0,0 +1,195 @@
+import { extend, each, map, mergeAll, retrieve, createHashMap } from '../../../../zrender/lib/core/util.js';
+import Geo, { geo2DDimensions } from './Geo.js';
+import { getLayoutRect } from '../../util/layout.js';
+import { parsePercent } from '../../util/number.js';
+import geoSourceManager from './geoSourceManager.js';
+import { min, max } from '../../../../zrender/lib/core/vector.js';
+
+/**
+ * Resize method bound to the geo
+ */
+function resizeGeo(geoModel, api) {
+  var boundingCoords = geoModel.get('boundingCoords');
+  if (boundingCoords != null) {
+    var leftTop_1 = boundingCoords[0];
+    var rightBottom_1 = boundingCoords[1];
+    if (!(isFinite(leftTop_1[0]) && isFinite(leftTop_1[1]) && isFinite(rightBottom_1[0]) && isFinite(rightBottom_1[1]))) {
+      if (process.env.NODE_ENV !== 'production') {
+        console.error('Invalid boundingCoords');
+      }
+    } else {
+      // Sample around the lng/lat rect and use projection to calculate actual bounding rect.
+      var projection_1 = this.projection;
+      if (projection_1) {
+        var xMin = leftTop_1[0];
+        var yMin = leftTop_1[1];
+        var xMax = rightBottom_1[0];
+        var yMax = rightBottom_1[1];
+        leftTop_1 = [Infinity, Infinity];
+        rightBottom_1 = [-Infinity, -Infinity];
+        // TODO better way?
+        var sampleLine = function (x0, y0, x1, y1) {
+          var dx = x1 - x0;
+          var dy = y1 - y0;
+          for (var i = 0; i <= 100; i++) {
+            var p = i / 100;
+            var pt = projection_1.project([x0 + dx * p, y0 + dy * p]);
+            min(leftTop_1, leftTop_1, pt);
+            max(rightBottom_1, rightBottom_1, pt);
+          }
+        };
+        // Top
+        sampleLine(xMin, yMin, xMax, yMin);
+        // Right
+        sampleLine(xMax, yMin, xMax, yMax);
+        // Bottom
+        sampleLine(xMax, yMax, xMin, yMax);
+        // Left
+        sampleLine(xMin, yMax, xMax, yMin);
+      }
+      this.setBoundingRect(leftTop_1[0], leftTop_1[1], rightBottom_1[0] - leftTop_1[0], rightBottom_1[1] - leftTop_1[1]);
+    }
+  }
+  var rect = this.getBoundingRect();
+  var centerOption = geoModel.get('layoutCenter');
+  var sizeOption = geoModel.get('layoutSize');
+  var viewWidth = api.getWidth();
+  var viewHeight = api.getHeight();
+  var aspect = rect.width / rect.height * this.aspectScale;
+  var useCenterAndSize = false;
+  var center;
+  var size;
+  if (centerOption && sizeOption) {
+    center = [parsePercent(centerOption[0], viewWidth), parsePercent(centerOption[1], viewHeight)];
+    size = parsePercent(sizeOption, Math.min(viewWidth, viewHeight));
+    if (!isNaN(center[0]) && !isNaN(center[1]) && !isNaN(size)) {
+      useCenterAndSize = true;
+    } else {
+      if (process.env.NODE_ENV !== 'production') {
+        console.warn('Given layoutCenter or layoutSize data are invalid. Use left/top/width/height instead.');
+      }
+    }
+  }
+  var viewRect;
+  if (useCenterAndSize) {
+    viewRect = {};
+    if (aspect > 1) {
+      // Width is same with size
+      viewRect.width = size;
+      viewRect.height = size / aspect;
+    } else {
+      viewRect.height = size;
+      viewRect.width = size * aspect;
+    }
+    viewRect.y = center[1] - viewRect.height / 2;
+    viewRect.x = center[0] - viewRect.width / 2;
+  } else {
+    // Use left/top/width/height
+    var boxLayoutOption = geoModel.getBoxLayoutParams();
+    boxLayoutOption.aspect = aspect;
+    viewRect = getLayoutRect(boxLayoutOption, {
+      width: viewWidth,
+      height: viewHeight
+    });
+  }
+  this.setViewRect(viewRect.x, viewRect.y, viewRect.width, viewRect.height);
+  this.setCenter(geoModel.get('center'), api);
+  this.setZoom(geoModel.get('zoom'));
+}
+// Back compat for ECharts2, where the coord map is set on map series:
+// {type: 'map', geoCoord: {'cityA': [116.46,39.92], 'cityA': [119.12,24.61]}},
+function setGeoCoords(geo, model) {
+  each(model.get('geoCoord'), function (geoCoord, name) {
+    geo.addGeoCoord(name, geoCoord);
+  });
+}
+var GeoCreator = /** @class */function () {
+  function GeoCreator() {
+    // For deciding which dimensions to use when creating list data
+    this.dimensions = geo2DDimensions;
+  }
+  GeoCreator.prototype.create = function (ecModel, api) {
+    var geoList = [];
+    function getCommonGeoProperties(model) {
+      return {
+        nameProperty: model.get('nameProperty'),
+        aspectScale: model.get('aspectScale'),
+        projection: model.get('projection')
+      };
+    }
+    // FIXME Create each time may be slow
+    ecModel.eachComponent('geo', function (geoModel, idx) {
+      var mapName = geoModel.get('map');
+      var geo = new Geo(mapName + idx, mapName, extend({
+        nameMap: geoModel.get('nameMap')
+      }, getCommonGeoProperties(geoModel)));
+      geo.zoomLimit = geoModel.get('scaleLimit');
+      geoList.push(geo);
+      // setGeoCoords(geo, geoModel);
+      geoModel.coordinateSystem = geo;
+      geo.model = geoModel;
+      // Inject resize method
+      geo.resize = resizeGeo;
+      geo.resize(geoModel, api);
+    });
+    ecModel.eachSeries(function (seriesModel) {
+      var coordSys = seriesModel.get('coordinateSystem');
+      if (coordSys === 'geo') {
+        var geoIndex = seriesModel.get('geoIndex') || 0;
+        seriesModel.coordinateSystem = geoList[geoIndex];
+      }
+    });
+    // If has map series
+    var mapModelGroupBySeries = {};
+    ecModel.eachSeriesByType('map', function (seriesModel) {
+      if (!seriesModel.getHostGeoModel()) {
+        var mapType = seriesModel.getMapType();
+        mapModelGroupBySeries[mapType] = mapModelGroupBySeries[mapType] || [];
+        mapModelGroupBySeries[mapType].push(seriesModel);
+      }
+    });
+    each(mapModelGroupBySeries, function (mapSeries, mapType) {
+      var nameMapList = map(mapSeries, function (singleMapSeries) {
+        return singleMapSeries.get('nameMap');
+      });
+      var geo = new Geo(mapType, mapType, extend({
+        nameMap: mergeAll(nameMapList)
+      }, getCommonGeoProperties(mapSeries[0])));
+      geo.zoomLimit = retrieve.apply(null, map(mapSeries, function (singleMapSeries) {
+        return singleMapSeries.get('scaleLimit');
+      }));
+      geoList.push(geo);
+      // Inject resize method
+      geo.resize = resizeGeo;
+      geo.resize(mapSeries[0], api);
+      each(mapSeries, function (singleMapSeries) {
+        singleMapSeries.coordinateSystem = geo;
+        setGeoCoords(geo, singleMapSeries);
+      });
+    });
+    return geoList;
+  };
+  /**
+   * Fill given regions array
+   */
+  GeoCreator.prototype.getFilledRegions = function (originRegionArr, mapName, nameMap, nameProperty) {
+    // Not use the original
+    var regionsArr = (originRegionArr || []).slice();
+    var dataNameMap = createHashMap();
+    for (var i = 0; i < regionsArr.length; i++) {
+      dataNameMap.set(regionsArr[i].name, regionsArr[i]);
+    }
+    var source = geoSourceManager.load(mapName, nameMap, nameProperty);
+    each(source.regions, function (region) {
+      var name = region.name;
+      !dataNameMap.get(name) && regionsArr.push({
+        name: name
+      });
+    });
+    return regionsArr;
+  };
+  return GeoCreator;
+}();
+var geoCreator = new GeoCreator();
+
+export { geoCreator as default };

package/esm/node_modules/echarts/lib/coord/geo/geoSourceManager.js

@@ -0,0 +1,81 @@
+import { createHashMap } from '../../../../zrender/lib/core/util.js';
+import { GeoSVGResource } from './GeoSVGResource.js';
+import { GeoJSONResource } from './GeoJSONResource.js';
+
+var storage = createHashMap();
+var geoSourceManager = {
+  /**
+   * Compatible with previous `echarts.registerMap`.
+   *
+   * @usage
+   * ```js
+   *
+   * echarts.registerMap('USA', geoJson, specialAreas);
+   *
+   * echarts.registerMap('USA', {
+   *     geoJson: geoJson,
+   *     specialAreas: {...}
+   * });
+   * echarts.registerMap('USA', {
+   *     geoJSON: geoJson,
+   *     specialAreas: {...}
+   * });
+   *
+   * echarts.registerMap('airport', {
+   *     svg: svg
+   * }
+   * ```
+   *
+   * Note:
+   * Do not support that register multiple geoJSON or SVG
+   * one map name. Because different geoJSON and SVG have
+   * different unit. It's not easy to make sure how those
+   * units are mapping/normalize.
+   * If intending to use multiple geoJSON or SVG, we can
+   * use multiple geo coordinate system.
+   */
+  registerMap: function (mapName, rawDef, rawSpecialAreas) {
+    if (rawDef.svg) {
+      var resource = new GeoSVGResource(mapName, rawDef.svg);
+      storage.set(mapName, resource);
+    } else {
+      // Recommend:
+      //     echarts.registerMap('eu', { geoJSON: xxx, specialAreas: xxx });
+      // Backward compatibility:
+      //     echarts.registerMap('eu', geoJSON, specialAreas);
+      //     echarts.registerMap('eu', { geoJson: xxx, specialAreas: xxx });
+      var geoJSON = rawDef.geoJson || rawDef.geoJSON;
+      if (geoJSON && !rawDef.features) {
+        rawSpecialAreas = rawDef.specialAreas;
+      } else {
+        geoJSON = rawDef;
+      }
+      var resource = new GeoJSONResource(mapName, geoJSON, rawSpecialAreas);
+      storage.set(mapName, resource);
+    }
+  },
+  getGeoResource: function (mapName) {
+    return storage.get(mapName);
+  },
+  /**
+   * Only for exporting to users.
+   * **MUST NOT** used internally.
+   */
+  getMapForUser: function (mapName) {
+    var resource = storage.get(mapName);
+    // Do not support return SVG until some real requirement come.
+    return resource && resource.type === 'geoJSON' && resource.getMapForUser();
+  },
+  load: function (mapName, nameMap, nameProperty) {
+    var resource = storage.get(mapName);
+    if (!resource) {
+      if (process.env.NODE_ENV !== 'production') {
+        console.error('Map ' + mapName + ' not exists. The GeoJSON of the map must be provided.');
+      }
+      return;
+    }
+    return resource.load(nameMap, nameProperty);
+  }
+};
+
+export { geoSourceManager as default };

package/esm/node_modules/echarts/lib/coord/geo/parseGeoJson.js

@@ -0,0 +1,103 @@
+import { map, filter, each } from '../../../../zrender/lib/core/util.js';
+import { GeoJSONLineStringGeometry, GeoJSONPolygonGeometry, GeoJSONRegion } from './Region.js';
+
+function decode(json) {
+  if (!json.UTF8Encoding) {
+    return json;
+  }
+  var jsonCompressed = json;
+  var encodeScale = jsonCompressed.UTF8Scale;
+  if (encodeScale == null) {
+    encodeScale = 1024;
+  }
+  var features = jsonCompressed.features;
+  each(features, function (feature) {
+    var geometry = feature.geometry;
+    var encodeOffsets = geometry.encodeOffsets;
+    var coordinates = geometry.coordinates;
+    // Geometry may be appeded manually in the script after json loaded.
+    // In this case this geometry is usually not encoded.
+    if (!encodeOffsets) {
+      return;
+    }
+    switch (geometry.type) {
+      case 'LineString':
+        geometry.coordinates = decodeRing(coordinates, encodeOffsets, encodeScale);
+        break;
+      case 'Polygon':
+        decodeRings(coordinates, encodeOffsets, encodeScale);
+        break;
+      case 'MultiLineString':
+        decodeRings(coordinates, encodeOffsets, encodeScale);
+        break;
+      case 'MultiPolygon':
+        each(coordinates, function (rings, idx) {
+          return decodeRings(rings, encodeOffsets[idx], encodeScale);
+        });
+    }
+  });
+  // Has been decoded
+  jsonCompressed.UTF8Encoding = false;
+  return jsonCompressed;
+}
+function decodeRings(rings, encodeOffsets, encodeScale) {
+  for (var c = 0; c < rings.length; c++) {
+    rings[c] = decodeRing(rings[c], encodeOffsets[c], encodeScale);
+  }
+}
+function decodeRing(coordinate, encodeOffsets, encodeScale) {
+  var result = [];
+  var prevX = encodeOffsets[0];
+  var prevY = encodeOffsets[1];
+  for (var i = 0; i < coordinate.length; i += 2) {
+    var x = coordinate.charCodeAt(i) - 64;
+    var y = coordinate.charCodeAt(i + 1) - 64;
+    // ZigZag decoding
+    x = x >> 1 ^ -(x & 1);
+    y = y >> 1 ^ -(y & 1);
+    // Delta deocding
+    x += prevX;
+    y += prevY;
+    prevX = x;
+    prevY = y;
+    // Dequantize
+    result.push([x / encodeScale, y / encodeScale]);
+  }
+  return result;
+}
+function parseGeoJSON(geoJson, nameProperty) {
+  geoJson = decode(geoJson);
+  return map(filter(geoJson.features, function (featureObj) {
+    // Output of mapshaper may have geometry null
+    return featureObj.geometry && featureObj.properties && featureObj.geometry.coordinates.length > 0;
+  }), function (featureObj) {
+    var properties = featureObj.properties;
+    var geo = featureObj.geometry;
+    var geometries = [];
+    switch (geo.type) {
+      case 'Polygon':
+        var coordinates = geo.coordinates;
+        // According to the GeoJSON specification.
+        // First must be exterior, and the rest are all interior(holes).
+        geometries.push(new GeoJSONPolygonGeometry(coordinates[0], coordinates.slice(1)));
+        break;
+      case 'MultiPolygon':
+        each(geo.coordinates, function (item) {
+          if (item[0]) {
+            geometries.push(new GeoJSONPolygonGeometry(item[0], item.slice(1)));
+          }
+        });
+        break;
+      case 'LineString':
+        geometries.push(new GeoJSONLineStringGeometry([geo.coordinates]));
+        break;
+      case 'MultiLineString':
+        geometries.push(new GeoJSONLineStringGeometry(geo.coordinates));
+    }
+    var region = new GeoJSONRegion(properties[nameProperty || 'name'], geometries, properties.cp);
+    region.properties = properties;
+    return region;
+  });
+}
+
+export { parseGeoJSON as default };

package/esm/node_modules/echarts/lib/coord/geo/prepareCustom.js

@@ -0,0 +1,39 @@
+import { bind, map } from '../../../../zrender/lib/core/util.js';
+
+function dataToCoordSize(dataSize, dataItem) {
+  dataItem = dataItem || [0, 0];
+  return map([0, 1], function (dimIdx) {
+    var val = dataItem[dimIdx];
+    var halfSize = dataSize[dimIdx] / 2;
+    var p1 = [];
+    var p2 = [];
+    p1[dimIdx] = val - halfSize;
+    p2[dimIdx] = val + halfSize;
+    p1[1 - dimIdx] = p2[1 - dimIdx] = dataItem[1 - dimIdx];
+    return Math.abs(this.dataToPoint(p1)[dimIdx] - this.dataToPoint(p2)[dimIdx]);
+  }, this);
+}
+function geoPrepareCustom(coordSys) {
+  var rect = coordSys.getBoundingRect();
+  return {
+    coordSys: {
+      type: 'geo',
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height,
+      zoom: coordSys.getZoom()
+    },
+    api: {
+      coord: function (data) {
+        // do not provide "out" and noRoam param,
+        // Compatible with this usage:
+        // echarts.util.map(item.points, api.coord)
+        return coordSys.dataToPoint(data);
+      },
+      size: bind(dataToCoordSize, coordSys)
+    }
+  };
+}
+
+export { geoPrepareCustom as default };

package/esm/node_modules/echarts/lib/coord/parallel/AxisModel.js

@@ -0,0 +1,73 @@
+import { __extends } from 'tslib';
+import { clone, mixin } from '../../../../zrender/lib/core/util.js';
+import ComponentModel from '../../model/Component.js';
+import makeStyleMapper from '../../model/mixin/makeStyleMapper.js';
+import { asc } from '../../util/number.js';
+import { AxisModelCommonMixin } from '../axisModelCommonMixin.js';
+
+var ParallelAxisModel = /** @class */function (_super) {
+  __extends(ParallelAxisModel, _super);
+  function ParallelAxisModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = ParallelAxisModel.type;
+    /**
+     * @readOnly
+     */
+    _this.activeIntervals = [];
+    return _this;
+  }
+  ParallelAxisModel.prototype.getAreaSelectStyle = function () {
+    return makeStyleMapper([['fill', 'color'], ['lineWidth', 'borderWidth'], ['stroke', 'borderColor'], ['width', 'width'], ['opacity', 'opacity']
+    // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+    // So do not transfer decal directly.
+    ])(this.getModel('areaSelectStyle'));
+  };
+  /**
+   * The code of this feature is put on AxisModel but not ParallelAxis,
+   * because axisModel can be alive after echarts updating but instance of
+   * ParallelAxis having been disposed. this._activeInterval should be kept
+   * when action dispatched (i.e. legend click).
+   *
+   * @param intervals `interval.length === 0` means set all active.
+   */
+  ParallelAxisModel.prototype.setActiveIntervals = function (intervals) {
+    var activeIntervals = this.activeIntervals = clone(intervals);
+    // Normalize
+    if (activeIntervals) {
+      for (var i = activeIntervals.length - 1; i >= 0; i--) {
+        asc(activeIntervals[i]);
+      }
+    }
+  };
+  /**
+   * @param value When only attempting detect whether 'no activeIntervals set',
+   *        `value` is not needed to be input.
+   */
+  ParallelAxisModel.prototype.getActiveState = function (value) {
+    var activeIntervals = this.activeIntervals;
+    if (!activeIntervals.length) {
+      return 'normal';
+    }
+    if (value == null || isNaN(+value)) {
+      return 'inactive';
+    }
+    // Simple optimization
+    if (activeIntervals.length === 1) {
+      var interval = activeIntervals[0];
+      if (interval[0] <= value && value <= interval[1]) {
+        return 'active';
+      }
+    } else {
+      for (var i = 0, len = activeIntervals.length; i < len; i++) {
+        if (activeIntervals[i][0] <= value && value <= activeIntervals[i][1]) {
+          return 'active';
+        }
+      }
+    }
+    return 'inactive';
+  };
+  return ParallelAxisModel;
+}(ComponentModel);
+mixin(ParallelAxisModel, AxisModelCommonMixin);
+
+export { ParallelAxisModel as default };