@fmdevui/fm-dev 1.0.113 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/cartesian/GridModel.mjs

@@ -0,0 +1,60 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import ComponentModel from '../../model/Component.mjs';
+import { getLayoutParams, mergeLayoutParam } from '../../util/layout.mjs';
+import tokens from '../../visual/tokens.mjs';
+
+// For backward compatibility, do not use a margin. Although the labels might touch the edge of
+// the canvas, the chart canvas probably does not have an border or a different background color within a page.
+var OUTER_BOUNDS_DEFAULT = {
+  left: 0,
+  right: 0,
+  top: 0,
+  bottom: 0
+};
+var OUTER_BOUNDS_CLAMP_DEFAULT = ['25%', '25%'];
+var GridModel = /** @class */function (_super) {
+  __extends(GridModel, _super);
+  function GridModel() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  GridModel.prototype.mergeDefaultAndTheme = function (option, ecModel) {
+    var outerBoundsCp = getLayoutParams(option.outerBounds);
+    _super.prototype.mergeDefaultAndTheme.apply(this, arguments);
+    if (outerBoundsCp && option.outerBounds) {
+      mergeLayoutParam(option.outerBounds, outerBoundsCp);
+    }
+  };
+  GridModel.prototype.mergeOption = function (newOption, ecModel) {
+    _super.prototype.mergeOption.apply(this, arguments);
+    if (this.option.outerBounds && newOption.outerBounds) {
+      mergeLayoutParam(this.option.outerBounds, newOption.outerBounds);
+    }
+  };
+  GridModel.type = 'grid';
+  GridModel.dependencies = ['xAxis', 'yAxis'];
+  GridModel.layoutMode = 'box';
+  GridModel.defaultOption = {
+    show: false,
+    // zlevel: 0,
+    z: 0,
+    left: '15%',
+    top: 65,
+    right: '10%',
+    bottom: 80,
+    // If grid size contain label
+    containLabel: false,
+    outerBoundsMode: 'auto',
+    outerBounds: OUTER_BOUNDS_DEFAULT,
+    outerBoundsContain: 'all',
+    outerBoundsClampWidth: OUTER_BOUNDS_CLAMP_DEFAULT[0],
+    outerBoundsClampHeight: OUTER_BOUNDS_CLAMP_DEFAULT[1],
+    // width: {totalWidth} - left - right,
+    // height: {totalHeight} - top - bottom,
+    backgroundColor: tokens.color.transparent,
+    borderWidth: 1,
+    borderColor: tokens.color.neutral30
+  };
+  return GridModel;
+}(ComponentModel);
+
+export { OUTER_BOUNDS_CLAMP_DEFAULT, OUTER_BOUNDS_DEFAULT, GridModel as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/cartesian/cartesianAxisHelper.mjs

@@ -0,0 +1,126 @@
+import { retrieve, each, retrieve3, keys, assert } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { SINGLE_REFERRING } from '../../util/model.mjs';
+import AxisBuilder from '../../component/axis/AxisBuilder.mjs';
+import { isIntervalOrLogScale } from '../../scale/helper.mjs';
+
+/**
+ * [__CAUTION__]
+ *  MUST guarantee: if only the input `rect` and `axis.extent` changed,
+ *  only `layout.position` changes.
+ *  This character is replied on `grid.contain` calculation in `AxisBuilder`.
+ *  @see updateCartesianAxisViewCommonPartBuilder
+ *
+ * Can only be called after coordinate system creation stage.
+ * (Can be called before coordinate system update stage).
+ */
+function layout(rect, axisModel, opt) {
+  opt = opt || {};
+  var axis = axisModel.axis;
+  var layout = {};
+  var otherAxisOnZeroOf = axis.getAxesOnZeroOf()[0];
+  var rawAxisPosition = axis.position;
+  var axisPosition = otherAxisOnZeroOf ? 'onZero' : rawAxisPosition;
+  var axisDim = axis.dim;
+  var rectBound = [rect.x, rect.x + rect.width, rect.y, rect.y + rect.height];
+  var idx = {
+    left: 0,
+    right: 1,
+    top: 0,
+    bottom: 1,
+    onZero: 2
+  };
+  var axisOffset = axisModel.get('offset') || 0;
+  var posBound = axisDim === 'x' ? [rectBound[2] - axisOffset, rectBound[3] + axisOffset] : [rectBound[0] - axisOffset, rectBound[1] + axisOffset];
+  if (otherAxisOnZeroOf) {
+    var onZeroCoord = otherAxisOnZeroOf.toGlobalCoord(otherAxisOnZeroOf.dataToCoord(0));
+    posBound[idx.onZero] = Math.max(Math.min(onZeroCoord, posBound[1]), posBound[0]);
+  }
+  // Axis position
+  layout.position = [axisDim === 'y' ? posBound[idx[axisPosition]] : rectBound[0], axisDim === 'x' ? posBound[idx[axisPosition]] : rectBound[3]];
+  // Axis rotation
+  layout.rotation = Math.PI / 2 * (axisDim === 'x' ? 0 : 1);
+  // Tick and label direction, x y is axisDim
+  var dirMap = {
+    top: -1,
+    bottom: 1,
+    left: -1,
+    right: 1
+  };
+  layout.labelDirection = layout.tickDirection = layout.nameDirection = dirMap[rawAxisPosition];
+  layout.labelOffset = otherAxisOnZeroOf ? posBound[idx[rawAxisPosition]] - posBound[idx.onZero] : 0;
+  if (axisModel.get(['axisTick', 'inside'])) {
+    layout.tickDirection = -layout.tickDirection;
+  }
+  if (retrieve(opt.labelInside, axisModel.get(['axisLabel', 'inside']))) {
+    layout.labelDirection = -layout.labelDirection;
+  }
+  // Special label rotation
+  var labelRotate = axisModel.get(['axisLabel', 'rotate']);
+  layout.labelRotate = axisPosition === 'top' ? -labelRotate : labelRotate;
+  // Over splitLine and splitArea
+  layout.z2 = 1;
+  return layout;
+}
+function isCartesian2DDeclaredSeries(seriesModel) {
+  return seriesModel.get('coordinateSystem') === 'cartesian2d';
+}
+/**
+ * Note: If pie (or other similar series) use cartesian2d, here
+ *  option `seriesModel.get('coordinateSystem') === 'cartesian2d'`
+ *  and `seriesModel.coordinateSystem !== cartesian2dCoordSysInstance`
+ *  and `seriesModel.boxCoordinateSystem === cartesian2dCoordSysInstance`,
+ *  the logic below is probably wrong, therefore skip it temporarily.
+ */
+function isCartesian2DInjectedAsDataCoordSys(seriesModel) {
+  return seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === 'cartesian2d';
+}
+function findAxisModels(seriesModel) {
+  var axisModelMap = {
+    xAxisModel: null,
+    yAxisModel: null
+  };
+  each(axisModelMap, function (v, key) {
+    var axisType = key.replace(/Model$/, '');
+    var axisModel = seriesModel.getReferringComponents(axisType, SINGLE_REFERRING).models[0];
+    if (process.env.NODE_ENV !== 'production') {
+      if (!axisModel) {
+        throw new Error(axisType + ' "' + retrieve3(seriesModel.get(axisType + 'Index'), seriesModel.get(axisType + 'Id'), 0) + '" not found');
+      }
+    }
+    axisModelMap[key] = axisModel;
+  });
+  return axisModelMap;
+}
+function createCartesianAxisViewCommonPartBuilder(gridRect, cartesians, axisModel, api, ctx, defaultNameMoveOverlap) {
+  var layoutResult = layout(gridRect, axisModel);
+  var axisLineAutoShow = false;
+  var axisTickAutoShow = false;
+  // Not show axisTick or axisLine if other axis is category / time
+  for (var i = 0; i < cartesians.length; i++) {
+    if (isIntervalOrLogScale(cartesians[i].getOtherAxis(axisModel.axis).scale)) {
+      // Still show axis tick or axisLine if other axis is value / log
+      axisLineAutoShow = axisTickAutoShow = true;
+      if (axisModel.axis.type === 'category' && axisModel.axis.onBand) {
+        axisTickAutoShow = false;
+      }
+    }
+  }
+  layoutResult.axisLineAutoShow = axisLineAutoShow;
+  layoutResult.axisTickAutoShow = axisTickAutoShow;
+  layoutResult.defaultNameMoveOverlap = defaultNameMoveOverlap;
+  return new AxisBuilder(axisModel, api, layoutResult, ctx);
+}
+function updateCartesianAxisViewCommonPartBuilder(axisBuilder, gridRect, axisModel) {
+  var newRaw = layout(gridRect, axisModel);
+  if (process.env.NODE_ENV !== 'production') {
+    var oldRaw_1 = axisBuilder.__getRawCfg();
+    each(keys(newRaw), function (prop) {
+      if (prop !== 'position' && prop !== 'labelOffset') {
+        assert(newRaw[prop] === oldRaw_1[prop]);
+      }
+    });
+  }
+  axisBuilder.updateCfg(newRaw);
+}
+
+export { createCartesianAxisViewCommonPartBuilder, findAxisModels, isCartesian2DDeclaredSeries, isCartesian2DInjectedAsDataCoordSys, layout, updateCartesianAxisViewCommonPartBuilder };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/cartesian/prepareCustom.mjs

@@ -0,0 +1,34 @@
+import { map, bind } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+function dataToCoordSize(dataSize, dataItem) {
+  // dataItem is necessary in log axis.
+  dataItem = dataItem || [0, 0];
+  return map(['x', 'y'], function (dim, dimIdx) {
+    var axis = this.getAxis(dim);
+    var val = dataItem[dimIdx];
+    var halfSize = dataSize[dimIdx] / 2;
+    return axis.type === 'category' ? axis.getBandWidth() : Math.abs(axis.dataToCoord(val - halfSize) - axis.dataToCoord(val + halfSize));
+  }, this);
+}
+function cartesianPrepareCustom(coordSys) {
+  var rect = coordSys.master.getRect();
+  return {
+    coordSys: {
+      // The name exposed to user is always 'cartesian2d' but not 'grid'.
+      type: 'cartesian2d',
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height
+    },
+    api: {
+      coord: function (data) {
+        // do not provide "out" param
+        return coordSys.dataToPoint(data);
+      },
+      size: bind(dataToCoordSize, coordSys)
+    }
+  };
+}
+
+export { cartesianPrepareCustom as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/geo/Geo.mjs

@@ -0,0 +1,173 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import { createHashMap, retrieve2, isString, mixin } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import BoundingRect from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/BoundingRect.mjs';
+import View from '../View.mjs';
+import geoSourceManager from './geoSourceManager.mjs';
+import { SINGLE_REFERRING } from '../../util/model.mjs';
+import { warn } from '../../util/log.mjs';
+
+var GEO_DEFAULT_PARAMS = {
+  'geoJSON': {
+    aspectScale: 0.75,
+    invertLongitute: true
+  },
+  'geoSVG': {
+    aspectScale: 1,
+    invertLongitute: false
+  }
+};
+var geo2DDimensions = ['lng', 'lat'];
+var Geo = /** @class */function (_super) {
+  __extends(Geo, _super);
+  function Geo(name, map, opt) {
+    var _this = _super.call(this, name, {
+      api: opt.api,
+      ecModel: opt.ecModel
+    }) || this;
+    _this.dimensions = geo2DDimensions;
+    _this.type = 'geo';
+    // Only store specified name coord via `addGeoCoord`.
+    _this._nameCoordMap = createHashMap();
+    _this.map = map;
+    var projection = opt.projection;
+    var source = geoSourceManager.load(map, opt.nameMap, opt.nameProperty);
+    var resource = geoSourceManager.getGeoResource(map);
+    var resourceType = _this.resourceType = resource ? resource.type : null;
+    var regions = _this.regions = source.regions;
+    var defaultParams = GEO_DEFAULT_PARAMS[resource.type];
+    _this._regionsMap = source.regionsMap;
+    _this.regions = source.regions;
+    if (process.env.NODE_ENV !== 'production' && projection) {
+      // Do some check
+      if (resourceType === 'geoSVG') {
+        if (process.env.NODE_ENV !== 'production') {
+          warn("Map " + map + " with SVG source can't use projection. Only GeoJSON source supports projection.");
+        }
+        projection = null;
+      }
+      if (!(projection.project && projection.unproject)) {
+        if (process.env.NODE_ENV !== 'production') {
+          warn('project and unproject must be both provided in the projeciton.');
+        }
+        projection = null;
+      }
+    }
+    _this.projection = projection;
+    var boundingRect;
+    if (projection) {
+      // Can't reuse the raw bounding rect
+      for (var i = 0; i < regions.length; i++) {
+        var regionRect = regions[i].getBoundingRect(projection);
+        boundingRect = boundingRect || regionRect.clone();
+        boundingRect.union(regionRect);
+      }
+    } else {
+      boundingRect = source.boundingRect;
+    }
+    _this.setBoundingRect(boundingRect.x, boundingRect.y, boundingRect.width, boundingRect.height);
+    // aspectScale and invertLongitute actually is the parameters default raw projection.
+    // So we ignore them if projection is given.
+    // Ignore default aspect scale if projection exits.
+    _this.aspectScale = projection ? 1 : retrieve2(opt.aspectScale, defaultParams.aspectScale);
+    // Not invert longitude if projection exits.
+    _this._invertLongitute = projection ? false : defaultParams.invertLongitute;
+    return _this;
+  }
+  Geo.prototype._transformTo = function (x, y, width, height) {
+    var rect = this.getBoundingRect();
+    var invertLongitute = this._invertLongitute;
+    rect = rect.clone();
+    if (invertLongitute) {
+      // Longitude is inverted.
+      rect.y = -rect.y - rect.height;
+    }
+    var rawTransformable = this._rawTransformable;
+    rawTransformable.transform = rect.calculateTransform(new BoundingRect(x, y, width, height));
+    var rawParent = rawTransformable.parent;
+    rawTransformable.parent = null;
+    rawTransformable.decomposeTransform();
+    rawTransformable.parent = rawParent;
+    if (invertLongitute) {
+      rawTransformable.scaleY = -rawTransformable.scaleY;
+    }
+    this._updateTransform();
+  };
+  Geo.prototype.getRegion = function (name) {
+    return this._regionsMap.get(name);
+  };
+  Geo.prototype.getRegionByCoord = function (coord) {
+    var regions = this.regions;
+    for (var i = 0; i < regions.length; i++) {
+      var region = regions[i];
+      if (region.type === 'geoJSON' && region.contain(coord)) {
+        return regions[i];
+      }
+    }
+  };
+  /**
+   * Add geoCoord for indexing by name
+   */
+  Geo.prototype.addGeoCoord = function (name, geoCoord) {
+    this._nameCoordMap.set(name, geoCoord);
+  };
+  /**
+   * Get geoCoord by name
+   */
+  Geo.prototype.getGeoCoord = function (name) {
+    var region = this._regionsMap.get(name);
+    // Calculate center only on demand.
+    return this._nameCoordMap.get(name) || region && region.getCenter();
+  };
+  Geo.prototype.dataToPoint = function (data, noRoam, out) {
+    if (isString(data)) {
+      // Map area name to geoCoord
+      data = this.getGeoCoord(data);
+    }
+    if (data) {
+      var projection = this.projection;
+      if (projection) {
+        // projection may return null point.
+        data = projection.project(data);
+      }
+      return data && this.projectedToPoint(data, noRoam, out);
+    }
+  };
+  Geo.prototype.pointToData = function (point, reserved, out) {
+    var projection = this.projection;
+    if (projection) {
+      // projection may return null point.
+      point = projection.unproject(point);
+    }
+    // FIXME: if no `point`, should return [NaN, NaN], rather than undefined.
+    //  null/undefined has special meaning in `convertFromPixel`.
+    return point && this.pointToProjected(point, out);
+  };
+  /**
+   * Point to projected data. Same with pointToData when projection is used.
+   */
+  Geo.prototype.pointToProjected = function (point, out) {
+    return _super.prototype.pointToData.call(this, point, 0, out);
+  };
+  Geo.prototype.projectedToPoint = function (projected, noRoam, out) {
+    return _super.prototype.dataToPoint.call(this, projected, noRoam, out);
+  };
+  Geo.prototype.convertToPixel = function (ecModel, finder, value) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? coordSys.dataToPoint(value) : null;
+  };
+  Geo.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? coordSys.pointToData(pixel) : null;
+  };
+  return Geo;
+}(View);
+;
+mixin(Geo, View);
+function getCoordSys(finder) {
+  var geoModel = finder.geoModel;
+  var seriesModel = finder.seriesModel;
+  return geoModel ? geoModel.coordinateSystem : seriesModel ? seriesModel.coordinateSystem // For map series.
+  || (seriesModel.getReferringComponents('geo', SINGLE_REFERRING).models[0] || {}).coordinateSystem : null;
+}
+
+export { Geo as default, geo2DDimensions };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/geo/GeoJSONResource.mjs

@@ -0,0 +1,102 @@
+import { createHashMap, each, hasOwn, isString } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import parseGeoJSON from './parseGeoJson.mjs';
+import fixNanhai from './fix/nanhai.mjs';
+import fixTextCoords from './fix/textCoord.mjs';
+import fixDiaoyuIsland from './fix/diaoyuIsland.mjs';
+import BoundingRect from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/BoundingRect.mjs';
+
+var DEFAULT_NAME_PROPERTY = 'name';
+var GeoJSONResource = /** @class */function () {
+  function GeoJSONResource(mapName, geoJSON, specialAreas) {
+    this.type = 'geoJSON';
+    this._parsedMap = createHashMap();
+    this._mapName = mapName;
+    this._specialAreas = specialAreas;
+    // PENDING: delay the parse to the first usage to rapid up the FMP?
+    this._geoJSON = parseInput(geoJSON);
+  }
+  /**
+   * @param nameMap can be null/undefined
+   * @param nameProperty can be null/undefined
+   */
+  GeoJSONResource.prototype.load = function (nameMap, nameProperty) {
+    nameProperty = nameProperty || DEFAULT_NAME_PROPERTY;
+    var parsed = this._parsedMap.get(nameProperty);
+    if (!parsed) {
+      var rawRegions = this._parseToRegions(nameProperty);
+      parsed = this._parsedMap.set(nameProperty, {
+        regions: rawRegions,
+        boundingRect: calculateBoundingRect(rawRegions)
+      });
+    }
+    var regionsMap = createHashMap();
+    var finalRegions = [];
+    each(parsed.regions, function (region) {
+      var regionName = region.name;
+      // Try use the alias in geoNameMap
+      if (nameMap && hasOwn(nameMap, regionName)) {
+        region = region.cloneShallow(regionName = nameMap[regionName]);
+      }
+      finalRegions.push(region);
+      regionsMap.set(regionName, region);
+    });
+    return {
+      regions: finalRegions,
+      boundingRect: parsed.boundingRect || new BoundingRect(0, 0, 0, 0),
+      regionsMap: regionsMap
+    };
+  };
+  GeoJSONResource.prototype._parseToRegions = function (nameProperty) {
+    var mapName = this._mapName;
+    var geoJSON = this._geoJSON;
+    var rawRegions;
+    // https://jsperf.com/try-catch-performance-overhead
+    try {
+      rawRegions = geoJSON ? parseGeoJSON(geoJSON, nameProperty) : [];
+    } catch (e) {
+      throw new Error('Invalid geoJson format\n' + e.message);
+    }
+    fixNanhai(mapName, rawRegions);
+    each(rawRegions, function (region) {
+      var regionName = region.name;
+      fixTextCoords(mapName, region);
+      fixDiaoyuIsland(mapName, region);
+      // Some area like Alaska in USA map needs to be tansformed
+      // to look better
+      var specialArea = this._specialAreas && this._specialAreas[regionName];
+      if (specialArea) {
+        region.transformTo(specialArea.left, specialArea.top, specialArea.width, specialArea.height);
+      }
+    }, this);
+    return rawRegions;
+  };
+  /**
+   * Only for exporting to users.
+   * **MUST NOT** used internally.
+   */
+  GeoJSONResource.prototype.getMapForUser = function () {
+    return {
+      // For backward compatibility, use geoJson
+      // PENDING: it has been returning them without clone.
+      // do we need to avoid outsite modification?
+      geoJson: this._geoJSON,
+      geoJSON: this._geoJSON,
+      specialAreas: this._specialAreas
+    };
+  };
+  return GeoJSONResource;
+}();
+function calculateBoundingRect(regions) {
+  var rect;
+  for (var i = 0; i < regions.length; i++) {
+    var regionRect = regions[i].getBoundingRect();
+    rect = rect || regionRect.clone();
+    rect.union(regionRect);
+  }
+  return rect;
+}
+function parseInput(source) {
+  return !isString(source) ? source : typeof JSON !== 'undefined' && JSON.parse ? JSON.parse(source) : new Function('return (' + source + ');')();
+}
+
+export { GeoJSONResource };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/geo/GeoModel.mjs

@@ -0,0 +1,166 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import { reduce, createHashMap, isFunction, isString } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { defaultEmphasis } from '../../util/model.mjs';
+import ComponentModel from '../../model/Component.mjs';
+import Model from '../../model/Model.mjs';
+import geoCreator from './geoCreator.mjs';
+import geoSourceManager from './geoSourceManager.mjs';
+import tokens from '../../visual/tokens.mjs';
+
+;
+var GeoModel = /** @class */function (_super) {
+  __extends(GeoModel, _super);
+  function GeoModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = GeoModel.type;
+    return _this;
+  }
+  GeoModel.prototype.init = function (option, parentModel, ecModel) {
+    this.mergeDefaultAndTheme(option, ecModel);
+    var source = geoSourceManager.getGeoResource(option.map);
+    if (source && source.type === 'geoJSON') {
+      var itemStyle = option.itemStyle = option.itemStyle || {};
+      if (!('color' in itemStyle)) {
+        itemStyle.color = option.defaultItemStyleColor || tokens.color.backgroundTint;
+      }
+    }
+    // Default label emphasis `show`
+    defaultEmphasis(option, 'label', ['show']);
+  };
+  GeoModel.prototype.optionUpdated = function () {
+    var _this = this;
+    var option = this.option;
+    option.regions = geoCreator.getFilledRegions(option.regions, option.map, option.nameMap, option.nameProperty);
+    var selectedMap = {};
+    this._optionModelMap = reduce(option.regions || [], function (optionModelMap, regionOpt) {
+      var regionName = regionOpt.name;
+      if (regionName) {
+        optionModelMap.set(regionName, new Model(regionOpt, _this, _this.ecModel));
+        if (regionOpt.selected) {
+          selectedMap[regionName] = true;
+        }
+      }
+      return optionModelMap;
+    }, createHashMap());
+    if (!option.selectedMap) {
+      option.selectedMap = selectedMap;
+    }
+  };
+  /**
+   * Get model of region.
+   */
+  GeoModel.prototype.getRegionModel = function (name) {
+    return this._optionModelMap.get(name) || new Model(null, this, this.ecModel);
+  };
+  /**
+   * Format label
+   * @param name Region name
+   */
+  GeoModel.prototype.getFormattedLabel = function (name, status) {
+    var regionModel = this.getRegionModel(name);
+    var formatter = status === 'normal' ? regionModel.get(['label', 'formatter']) : regionModel.get(['emphasis', 'label', 'formatter']);
+    var params = {
+      name: name
+    };
+    if (isFunction(formatter)) {
+      params.status = status;
+      return formatter(params);
+    } else if (isString(formatter)) {
+      return formatter.replace('{a}', name != null ? name : '');
+    }
+  };
+  GeoModel.prototype.setZoom = function (zoom) {
+    this.option.zoom = zoom;
+  };
+  GeoModel.prototype.setCenter = function (center) {
+    this.option.center = center;
+  };
+  // PENGING If selectedMode is null ?
+  GeoModel.prototype.select = function (name) {
+    var option = this.option;
+    var selectedMode = option.selectedMode;
+    if (!selectedMode) {
+      return;
+    }
+    if (selectedMode !== 'multiple') {
+      option.selectedMap = null;
+    }
+    var selectedMap = option.selectedMap || (option.selectedMap = {});
+    selectedMap[name] = true;
+  };
+  GeoModel.prototype.unSelect = function (name) {
+    var selectedMap = this.option.selectedMap;
+    if (selectedMap) {
+      selectedMap[name] = false;
+    }
+  };
+  GeoModel.prototype.toggleSelected = function (name) {
+    this[this.isSelected(name) ? 'unSelect' : 'select'](name);
+  };
+  GeoModel.prototype.isSelected = function (name) {
+    var selectedMap = this.option.selectedMap;
+    return !!(selectedMap && selectedMap[name]);
+  };
+  GeoModel.type = 'geo';
+  GeoModel.layoutMode = 'box';
+  GeoModel.defaultOption = {
+    // zlevel: 0,
+    z: 0,
+    show: true,
+    left: 'center',
+    top: 'center',
+    // 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
+    silent: false,
+    // Map type
+    map: '',
+    // Define left-top, right-bottom coords to control view
+    // For example, [ [180, 90], [-180, -90] ]
+    boundingCoords: null,
+    // Default on center of map
+    center: null,
+    zoom: 1,
+    scaleLimit: null,
+    // selectedMode: false
+    label: {
+      show: false,
+      color: tokens.color.tertiary
+    },
+    itemStyle: {
+      borderWidth: 0.5,
+      borderColor: tokens.color.border
+    },
+    emphasis: {
+      label: {
+        show: true,
+        color: tokens.color.primary
+      },
+      itemStyle: {
+        color: tokens.color.highlight
+      }
+    },
+    select: {
+      label: {
+        show: true,
+        color: tokens.color.primary
+      },
+      itemStyle: {
+        color: tokens.color.highlight
+      }
+    },
+    regions: []
+    // tooltip: {
+    //     show: false
+    // }
+  };
+  return GeoModel;
+}(ComponentModel);
+
+export { GeoModel as default };