sun-card-design 1.1.34 → 1.1.36

package/dist/mobile/sun-card-design-mobile.es1884.js

@@ -1,110 +1,181 @@
-import { __extends } from "./sun-card-design-mobile.es1725.js";
-import { each, defaults } from "./sun-card-design-mobile.es930.js";
-import AxisBuilder from "./sun-card-design-mobile.es2103.js";
-import { groupTransition, subPixelOptimizeLine, mergePath } from "./sun-card-design-mobile.es1764.js";
-import { layout } from "./sun-card-design-mobile.es2113.js";
-import AxisView from "./sun-card-design-mobile.es1869.js";
-import { rectCoordAxisHandleRemove, rectCoordAxisBuildSplitArea } from "./sun-card-design-mobile.es2104.js";
-import Group from "./sun-card-design-mobile.es1760.js";
-import Line from "./sun-card-design-mobile.es1985.js";
-var axisBuilderAttrs = ["axisLine", "axisTickLabel", "axisName"];
-var selfBuilderAttrs = ["splitArea", "splitLine"];
-var SingleAxisView = (
+import { extend, each, map, mergeAll, retrieve, createHashMap, merge } from "./sun-card-design-mobile.es931.js";
+import Geo, { geo2DDimensions } from "./sun-card-design-mobile.es2118.js";
+import { getLayoutRect } from "./sun-card-design-mobile.es1767.js";
+import { parsePercent } from "./sun-card-design-mobile.es1971.js";
+import geoSourceManager from "./sun-card-design-mobile.es1886.js";
+import { min, max } from "./sun-card-design-mobile.es1974.js";
+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 {
+      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];
+        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);
+          }
+        };
+        sampleLine(xMin, yMin, xMax, yMin);
+        sampleLine(xMax, yMin, xMax, yMax);
+        sampleLine(xMax, yMax, xMin, yMax);
+        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) {
+      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 {
+    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"));
+}
+function setGeoCoords(geo, model) {
+  each(model.get("geoCoord"), function(geoCoord, name) {
+    geo.addGeoCoord(name, geoCoord);
+  });
+}
+var GeoCreator = (
   /** @class */
-  (function(_super) {
-    __extends(SingleAxisView2, _super);
-    function SingleAxisView2() {
-      var _this = _super !== null && _super.apply(this, arguments) || this;
-      _this.type = SingleAxisView2.type;
-      _this.axisPointerClass = "SingleAxisPointer";
-      return _this;
+  (function() {
+    function GeoCreator2() {
+      this.dimensions = geo2DDimensions;
     }
-    SingleAxisView2.prototype.render = function(axisModel, ecModel, api, payload) {
-      var group = this.group;
-      group.removeAll();
-      var oldAxisGroup = this._axisGroup;
-      this._axisGroup = new Group();
-      var layout$1 = layout(axisModel);
-      var axisBuilder = new AxisBuilder(axisModel, layout$1);
-      each(axisBuilderAttrs, axisBuilder.add, axisBuilder);
-      group.add(this._axisGroup);
-      group.add(axisBuilder.getGroup());
-      each(selfBuilderAttrs, function(name) {
-        if (axisModel.get([name, "show"])) {
-          axisElementBuilders[name](this, this.group, this._axisGroup, axisModel);
+    GeoCreator2.prototype.create = function(ecModel, api) {
+      var geoList = [];
+      function getCommonGeoProperties(model) {
+        return {
+          nameProperty: model.get("nameProperty"),
+          aspectScale: model.get("aspectScale"),
+          projection: model.get("projection")
+        };
+      }
+      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);
+        geoModel.coordinateSystem = geo;
+        geo.model = geoModel;
+        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];
         }
-      }, this);
-      groupTransition(oldAxisGroup, this._axisGroup, axisModel);
-      _super.prototype.render.call(this, axisModel, ecModel, api, payload);
-    };
-    SingleAxisView2.prototype.remove = function() {
-      rectCoordAxisHandleRemove(this);
+      });
+      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);
+        geo.resize = resizeGeo;
+        geo.resize(mapSeries[0], api);
+        each(mapSeries, function(singleMapSeries) {
+          singleMapSeries.coordinateSystem = geo;
+          setGeoCoords(geo, singleMapSeries);
+        });
+      });
+      return geoList;
     };
-    SingleAxisView2.type = "singleAxis";
-    return SingleAxisView2;
-  })(AxisView)
-);
-var axisElementBuilders = {
-  splitLine: function(axisView, group, axisGroup, axisModel) {
-    var axis = axisModel.axis;
-    if (axis.scale.isBlank()) {
-      return;
-    }
-    var splitLineModel = axisModel.getModel("splitLine");
-    var lineStyleModel = splitLineModel.getModel("lineStyle");
-    var lineColors = lineStyleModel.get("color");
-    lineColors = lineColors instanceof Array ? lineColors : [lineColors];
-    var lineWidth = lineStyleModel.get("width");
-    var gridRect = axisModel.coordinateSystem.getRect();
-    var isHorizontal = axis.isHorizontal();
-    var splitLines = [];
-    var lineCount = 0;
-    var ticksCoords = axis.getTicksCoords({
-      tickModel: splitLineModel
-    });
-    var p1 = [];
-    var p2 = [];
-    for (var i = 0; i < ticksCoords.length; ++i) {
-      var tickCoord = axis.toGlobalCoord(ticksCoords[i].coord);
-      if (isHorizontal) {
-        p1[0] = tickCoord;
-        p1[1] = gridRect.y;
-        p2[0] = tickCoord;
-        p2[1] = gridRect.y + gridRect.height;
-      } else {
-        p1[0] = gridRect.x;
-        p1[1] = tickCoord;
-        p2[0] = gridRect.x + gridRect.width;
-        p2[1] = tickCoord;
+    GeoCreator2.prototype.getFilledRegions = function(originRegionArr, mapName, nameMap, nameProperty) {
+      var regionsArr = (originRegionArr || []).slice();
+      var dataNameMap = createHashMap();
+      for (var i = 0; i < regionsArr.length; i++) {
+        dataNameMap.set(regionsArr[i].name, regionsArr[i]);
       }
-      var line = new Line({
-        shape: {
-          x1: p1[0],
-          y1: p1[1],
-          x2: p2[0],
-          y2: p2[1]
-        },
-        silent: true
+      var source = geoSourceManager.load(mapName, nameMap, nameProperty);
+      each(source.regions, function(region) {
+        var name = region.name;
+        var regionOption = dataNameMap.get(name);
+        var specifiedGeoJSONRegionStyle = region.properties && region.properties.echartsStyle;
+        if (!regionOption) {
+          regionOption = {
+            name
+          };
+          regionsArr.push(regionOption);
+        }
+        specifiedGeoJSONRegionStyle && merge(regionOption, specifiedGeoJSONRegionStyle);
       });
-      subPixelOptimizeLine(line.shape, lineWidth);
-      var colorIndex = lineCount++ % lineColors.length;
-      splitLines[colorIndex] = splitLines[colorIndex] || [];
-      splitLines[colorIndex].push(line);
-    }
-    var lineStyle = lineStyleModel.getLineStyle(["color"]);
-    for (var i = 0; i < splitLines.length; ++i) {
-      group.add(mergePath(splitLines[i], {
-        style: defaults({
-          stroke: lineColors[i % lineColors.length]
-        }, lineStyle),
-        silent: true
-      }));
-    }
-  },
-  splitArea: function(axisView, group, axisGroup, axisModel) {
-    rectCoordAxisBuildSplitArea(axisView, axisGroup, axisModel, axisModel);
-  }
-};
+      return regionsArr;
+    };
+    return GeoCreator2;
+  })()
+);
+var geoCreator = new GeoCreator();
 export {
-  SingleAxisView as default
+  geoCreator as default
 };

package/dist/mobile/sun-card-design-mobile.es1885.js

@@ -1,65 +1,71 @@
-import { __extends } from "./sun-card-design-mobile.es1725.js";
-import ComponentModel from "./sun-card-design-mobile.es928.js";
-import { AxisModelCommonMixin } from "./sun-card-design-mobile.es2093.js";
-import { mixin } from "./sun-card-design-mobile.es930.js";
-var SingleAxisModel = (
+import { __extends } from "./sun-card-design-mobile.es1726.js";
+import MapDraw from "./sun-card-design-mobile.es2057.js";
+import ComponentView from "./sun-card-design-mobile.es927.js";
+import { getECData } from "./sun-card-design-mobile.es1736.js";
+import { findEventDispatcher } from "./sun-card-design-mobile.es1753.js";
+var GeoView = (
   /** @class */
   (function(_super) {
-    __extends(SingleAxisModel2, _super);
-    function SingleAxisModel2() {
+    __extends(GeoView2, _super);
+    function GeoView2() {
       var _this = _super !== null && _super.apply(this, arguments) || this;
-      _this.type = SingleAxisModel2.type;
+      _this.type = GeoView2.type;
+      _this.focusBlurEnabled = true;
       return _this;
     }
-    SingleAxisModel2.prototype.getCoordSysModel = function() {
-      return this;
+    GeoView2.prototype.init = function(ecModel, api) {
+      this._api = api;
     };
-    SingleAxisModel2.type = "singleAxis";
-    SingleAxisModel2.layoutMode = "box";
-    SingleAxisModel2.defaultOption = {
-      left: "5%",
-      top: "5%",
-      right: "5%",
-      bottom: "5%",
-      type: "value",
-      position: "bottom",
-      orient: "horizontal",
-      axisLine: {
-        show: true,
-        lineStyle: {
-          width: 1,
-          type: "solid"
-        }
-      },
-      // Single coordinate system and single axis is the,
-      // which is used as the parent tooltip model.
-      // same model, so we set default tooltip show as true.
-      tooltip: {
-        show: true
-      },
-      axisTick: {
-        show: true,
-        length: 6,
-        lineStyle: {
-          width: 1
-        }
-      },
-      axisLabel: {
-        show: true,
-        interval: "auto"
-      },
-      splitLine: {
-        show: true,
-        lineStyle: {
-          type: "dashed",
-          opacity: 0.2
-        }
+    GeoView2.prototype.render = function(geoModel, ecModel, api, payload) {
+      this._model = geoModel;
+      if (!geoModel.get("show")) {
+        this._mapDraw && this._mapDraw.remove();
+        this._mapDraw = null;
+        return;
+      }
+      if (!this._mapDraw) {
+        this._mapDraw = new MapDraw(api);
+      }
+      var mapDraw = this._mapDraw;
+      mapDraw.draw(geoModel, ecModel, api, this, payload);
+      mapDraw.group.on("click", this._handleRegionClick, this);
+      mapDraw.group.silent = geoModel.get("silent");
+      this.group.add(mapDraw.group);
+      this.updateSelectStatus(geoModel, ecModel, api);
+    };
+    GeoView2.prototype._handleRegionClick = function(e) {
+      var eventData;
+      findEventDispatcher(e.target, function(current) {
+        return (eventData = getECData(current).eventData) != null;
+      }, true);
+      if (eventData) {
+        this._api.dispatchAction({
+          type: "geoToggleSelect",
+          geoId: this._model.id,
+          name: eventData.name
+        });
       }
     };
-    return SingleAxisModel2;
-  })(ComponentModel)
+    GeoView2.prototype.updateSelectStatus = function(model, ecModel, api) {
+      var _this = this;
+      this._mapDraw.group.traverse(function(node) {
+        var eventData = getECData(node).eventData;
+        if (eventData) {
+          _this._model.isSelected(eventData.name) ? api.enterSelect(node) : api.leaveSelect(node);
+          return true;
+        }
+      });
+    };
+    GeoView2.prototype.findHighDownDispatchers = function(name) {
+      return this._mapDraw && this._mapDraw.findHighDownDispatchers(name, this._model);
+    };
+    GeoView2.prototype.dispose = function() {
+      this._mapDraw && this._mapDraw.remove();
+    };
+    GeoView2.type = "geo";
+    return GeoView2;
+  })(ComponentView)
 );
-mixin(SingleAxisModel, AxisModelCommonMixin.prototype);
 export {
-  SingleAxisModel as default
+  GeoView as default
 };

package/dist/mobile/sun-card-design-mobile.es1886.js

@@ -1,26 +1,75 @@
-import Single, { singleDimensions } from "./sun-card-design-mobile.es2114.js";
-import { SINGLE_REFERRING } from "./sun-card-design-mobile.es1737.js";
-function create(ecModel, api) {
-  var singles = [];
-  ecModel.eachComponent("singleAxis", function(axisModel, idx) {
-    var single = new Single(axisModel, ecModel, api);
-    single.name = "single_" + idx;
-    single.resize(axisModel, api);
-    axisModel.coordinateSystem = single;
-    singles.push(single);
-  });
-  ecModel.eachSeries(function(seriesModel) {
-    if (seriesModel.get("coordinateSystem") === "singleAxis") {
-      var singleAxisModel = seriesModel.getReferringComponents("singleAxis", SINGLE_REFERRING).models[0];
-      seriesModel.coordinateSystem = singleAxisModel && singleAxisModel.coordinateSystem;
+import { createHashMap } from "./sun-card-design-mobile.es931.js";
+import { GeoSVGResource } from "./sun-card-design-mobile.es2119.js";
+import { GeoJSONResource } from "./sun-card-design-mobile.es2120.js";
+var storage = createHashMap();
+const 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 {
+      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);
     }
-  });
-  return singles;
-}
-var singleCreator = {
-  create,
-  dimensions: singleDimensions
+  },
+  getGeoResource: function(mapName) {
+    return storage.get(mapName);
+  },
+  /**
+   * Only for exporting to users.
+   * **MUST NOT** used internally.
+   */
+  getMapForUser: function(mapName) {
+    var resource = storage.get(mapName);
+    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 {
-  singleCreator as default
+  geoSourceManager as default
 };