@fecp/designer 5.6.28 → 5.6.29

package/es/node_modules/echarts/lib/component/graphic/GraphicView.mjs

@@ -0,0 +1,307 @@
+import { __extends } from "../../../../tslib/tslib.es6.mjs";
+import { createHashMap, each, indexOf, extend, hasOwn, retrieve2, isFunction, keys } from "../../../../zrender/lib/core/util.mjs";
+import Displayable from "../../../../zrender/lib/graphic/Displayable.mjs";
+import { convertOptionIdName, makeInner } from "../../util/model.mjs";
+import { setTooltipConfig, getShapeClass } from "../../util/graphic.mjs";
+import { positionElement, LOCATION_PARAMS } from "../../util/layout.mjs";
+import { parsePercent } from "../../util/number.mjs";
+import ComponentView from "../../view/Component.mjs";
+import { getECData } from "../../util/innerStore.mjs";
+import { isEC4CompatibleStyle, convertFromEC4CompatibleStyle } from "../../util/styleCompat.mjs";
+import { applyUpdateTransition, updateLeaveTo, isTransitionAll, applyLeaveTransition } from "../../animation/customGraphicTransition.mjs";
+import { updateProps } from "../../animation/basicTransition.mjs";
+import { stopPreviousKeyframeAnimationAndRestore, applyKeyframeAnimation } from "../../animation/customGraphicKeyframeAnimation.mjs";
+import ZRText from "../../../../zrender/lib/graphic/Text.mjs";
+import ZRImage from "../../../../zrender/lib/graphic/Image.mjs";
+import Group from "../../../../zrender/lib/graphic/Group.mjs";
+var nonShapeGraphicElements = {
+  // Reserved but not supported in graphic component.
+  path: null,
+  compoundPath: null,
+  // Supported in graphic component.
+  group: Group,
+  image: ZRImage,
+  text: ZRText
+};
+var inner = makeInner();
+var GraphicComponentView = (
+  /** @class */
+  function(_super) {
+    __extends(GraphicComponentView2, _super);
+    function GraphicComponentView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = GraphicComponentView2.type;
+      return _this;
+    }
+    GraphicComponentView2.prototype.init = function() {
+      this._elMap = createHashMap();
+    };
+    GraphicComponentView2.prototype.render = function(graphicModel, ecModel, api) {
+      if (graphicModel !== this._lastGraphicModel) {
+        this._clear();
+      }
+      this._lastGraphicModel = graphicModel;
+      this._updateElements(graphicModel);
+      this._relocate(graphicModel, api);
+    };
+    GraphicComponentView2.prototype._updateElements = function(graphicModel) {
+      var elOptionsToUpdate = graphicModel.useElOptionsToUpdate();
+      if (!elOptionsToUpdate) {
+        return;
+      }
+      var elMap = this._elMap;
+      var rootGroup = this.group;
+      var globalZ = graphicModel.get("z");
+      var globalZLevel = graphicModel.get("zlevel");
+      each(elOptionsToUpdate, function(elOption) {
+        var id = convertOptionIdName(elOption.id, null);
+        var elExisting = id != null ? elMap.get(id) : null;
+        var parentId = convertOptionIdName(elOption.parentId, null);
+        var targetElParent = parentId != null ? elMap.get(parentId) : rootGroup;
+        var elType = elOption.type;
+        var elOptionStyle = elOption.style;
+        if (elType === "text" && elOptionStyle) {
+          if (elOption.hv && elOption.hv[1]) {
+            elOptionStyle.textVerticalAlign = elOptionStyle.textBaseline = elOptionStyle.verticalAlign = elOptionStyle.align = null;
+          }
+        }
+        var textContentOption = elOption.textContent;
+        var textConfig = elOption.textConfig;
+        if (elOptionStyle && isEC4CompatibleStyle(elOptionStyle, elType, !!textConfig, !!textContentOption)) {
+          var convertResult = convertFromEC4CompatibleStyle(elOptionStyle, elType);
+          if (!textConfig && convertResult.textConfig) {
+            textConfig = elOption.textConfig = convertResult.textConfig;
+          }
+          if (!textContentOption && convertResult.textContent) {
+            textContentOption = convertResult.textContent;
+          }
+        }
+        var elOptionCleaned = getCleanedElOption(elOption);
+        var $action = elOption.$action || "merge";
+        var isMerge = $action === "merge";
+        var isReplace = $action === "replace";
+        if (isMerge) {
+          var isInit = !elExisting;
+          var el_1 = elExisting;
+          if (isInit) {
+            el_1 = createEl(id, targetElParent, elOption.type, elMap);
+          } else {
+            el_1 && (inner(el_1).isNew = false);
+            stopPreviousKeyframeAnimationAndRestore(el_1);
+          }
+          if (el_1) {
+            applyUpdateTransition(el_1, elOptionCleaned, graphicModel, {
+              isInit
+            });
+            updateCommonAttrs(el_1, elOption, globalZ, globalZLevel);
+          }
+        } else if (isReplace) {
+          removeEl(elExisting, elOption, elMap, graphicModel);
+          var el_2 = createEl(id, targetElParent, elOption.type, elMap);
+          if (el_2) {
+            applyUpdateTransition(el_2, elOptionCleaned, graphicModel, {
+              isInit: true
+            });
+            updateCommonAttrs(el_2, elOption, globalZ, globalZLevel);
+          }
+        } else if ($action === "remove") {
+          updateLeaveTo(elExisting, elOption);
+          removeEl(elExisting, elOption, elMap, graphicModel);
+        }
+        var el = elMap.get(id);
+        if (el && textContentOption) {
+          if (isMerge) {
+            var textContentExisting = el.getTextContent();
+            textContentExisting ? textContentExisting.attr(textContentOption) : el.setTextContent(new ZRText(textContentOption));
+          } else if (isReplace) {
+            el.setTextContent(new ZRText(textContentOption));
+          }
+        }
+        if (el) {
+          var clipPathOption = elOption.clipPath;
+          if (clipPathOption) {
+            var clipPathType = clipPathOption.type;
+            var clipPath = void 0;
+            var isInit = false;
+            if (isMerge) {
+              var oldClipPath = el.getClipPath();
+              isInit = !oldClipPath || inner(oldClipPath).type !== clipPathType;
+              clipPath = isInit ? newEl(clipPathType) : oldClipPath;
+            } else if (isReplace) {
+              isInit = true;
+              clipPath = newEl(clipPathType);
+            }
+            el.setClipPath(clipPath);
+            applyUpdateTransition(clipPath, clipPathOption, graphicModel, {
+              isInit
+            });
+            applyKeyframeAnimation(clipPath, clipPathOption.keyframeAnimation, graphicModel);
+          }
+          var elInner = inner(el);
+          el.setTextConfig(textConfig);
+          elInner.option = elOption;
+          setEventData(el, graphicModel, elOption);
+          setTooltipConfig({
+            el,
+            componentModel: graphicModel,
+            itemName: el.name,
+            itemTooltipOption: elOption.tooltip
+          });
+          applyKeyframeAnimation(el, elOption.keyframeAnimation, graphicModel);
+        }
+      });
+    };
+    GraphicComponentView2.prototype._relocate = function(graphicModel, api) {
+      var elOptions = graphicModel.option.elements;
+      var rootGroup = this.group;
+      var elMap = this._elMap;
+      var apiWidth = api.getWidth();
+      var apiHeight = api.getHeight();
+      var xy = ["x", "y"];
+      for (var i = 0; i < elOptions.length; i++) {
+        var elOption = elOptions[i];
+        var id = convertOptionIdName(elOption.id, null);
+        var el = id != null ? elMap.get(id) : null;
+        if (!el || !el.isGroup) {
+          continue;
+        }
+        var parentEl = el.parent;
+        var isParentRoot = parentEl === rootGroup;
+        var elInner = inner(el);
+        var parentElInner = inner(parentEl);
+        elInner.width = parsePercent(elInner.option.width, isParentRoot ? apiWidth : parentElInner.width) || 0;
+        elInner.height = parsePercent(elInner.option.height, isParentRoot ? apiHeight : parentElInner.height) || 0;
+      }
+      for (var i = elOptions.length - 1; i >= 0; i--) {
+        var elOption = elOptions[i];
+        var id = convertOptionIdName(elOption.id, null);
+        var el = id != null ? elMap.get(id) : null;
+        if (!el) {
+          continue;
+        }
+        var parentEl = el.parent;
+        var parentElInner = inner(parentEl);
+        var containerInfo = parentEl === rootGroup ? {
+          width: apiWidth,
+          height: apiHeight
+        } : {
+          width: parentElInner.width,
+          height: parentElInner.height
+        };
+        var layoutPos = {};
+        var layouted = positionElement(el, elOption, containerInfo, null, {
+          hv: elOption.hv,
+          boundingMode: elOption.bounding
+        }, layoutPos);
+        if (!inner(el).isNew && layouted) {
+          var transition = elOption.transition;
+          var animatePos = {};
+          for (var k = 0; k < xy.length; k++) {
+            var key = xy[k];
+            var val = layoutPos[key];
+            if (transition && (isTransitionAll(transition) || indexOf(transition, key) >= 0)) {
+              animatePos[key] = val;
+            } else {
+              el[key] = val;
+            }
+          }
+          updateProps(el, animatePos, graphicModel, 0);
+        } else {
+          el.attr(layoutPos);
+        }
+      }
+    };
+    GraphicComponentView2.prototype._clear = function() {
+      var _this = this;
+      var elMap = this._elMap;
+      elMap.each(function(el) {
+        removeEl(el, inner(el).option, elMap, _this._lastGraphicModel);
+      });
+      this._elMap = createHashMap();
+    };
+    GraphicComponentView2.prototype.dispose = function() {
+      this._clear();
+    };
+    GraphicComponentView2.type = "graphic";
+    return GraphicComponentView2;
+  }(ComponentView)
+);
+function newEl(graphicType) {
+  var Clz = hasOwn(nonShapeGraphicElements, graphicType) ? nonShapeGraphicElements[graphicType] : getShapeClass(graphicType);
+  var el = new Clz({});
+  inner(el).type = graphicType;
+  return el;
+}
+function createEl(id, targetElParent, graphicType, elMap) {
+  var el = newEl(graphicType);
+  targetElParent.add(el);
+  elMap.set(id, el);
+  inner(el).id = id;
+  inner(el).isNew = true;
+  return el;
+}
+function removeEl(elExisting, elOption, elMap, graphicModel) {
+  var existElParent = elExisting && elExisting.parent;
+  if (existElParent) {
+    elExisting.type === "group" && elExisting.traverse(function(el) {
+      removeEl(el, elOption, elMap, graphicModel);
+    });
+    applyLeaveTransition(elExisting, elOption, graphicModel);
+    elMap.removeKey(inner(elExisting).id);
+  }
+}
+function updateCommonAttrs(el, elOption, defaultZ, defaultZlevel) {
+  if (!el.isGroup) {
+    each([
+      ["cursor", Displayable.prototype.cursor],
+      // We should not support configure z and zlevel in the element level.
+      // But seems we didn't limit it previously. So here still use it to avoid breaking.
+      ["zlevel", defaultZlevel || 0],
+      ["z", defaultZ || 0],
+      // z2 must not be null/undefined, otherwise sort error may occur.
+      ["z2", 0]
+    ], function(item) {
+      var prop = item[0];
+      if (hasOwn(elOption, prop)) {
+        el[prop] = retrieve2(elOption[prop], item[1]);
+      } else if (el[prop] == null) {
+        el[prop] = item[1];
+      }
+    });
+  }
+  each(keys(elOption), function(key) {
+    if (key.indexOf("on") === 0) {
+      var val = elOption[key];
+      el[key] = isFunction(val) ? val : null;
+    }
+  });
+  if (hasOwn(elOption, "draggable")) {
+    el.draggable = elOption.draggable;
+  }
+  elOption.name != null && (el.name = elOption.name);
+  elOption.id != null && (el.id = elOption.id);
+}
+function getCleanedElOption(elOption) {
+  elOption = extend({}, elOption);
+  each(["id", "parentId", "$action", "hv", "bounding", "textContent", "clipPath"].concat(LOCATION_PARAMS), function(name) {
+    delete elOption[name];
+  });
+  return elOption;
+}
+function setEventData(el, graphicModel, elOption) {
+  var eventData = getECData(el).eventData;
+  if (!el.silent && !el.ignore && !eventData) {
+    eventData = getECData(el).eventData = {
+      componentType: "graphic",
+      componentIndex: graphicModel.componentIndex,
+      name: el.name
+    };
+  }
+  if (eventData) {
+    eventData.info = elOption.info;
+  }
+}
+export {
+  GraphicComponentView,
+  inner
+};

package/es/node_modules/echarts/lib/component/graphic/install.mjs

@@ -0,0 +1,26 @@
+import { isArray } from "../../../../zrender/lib/core/util.mjs";
+import { GraphicComponentModel } from "./GraphicModel.mjs";
+import { GraphicComponentView } from "./GraphicView.mjs";
+function install(registers) {
+  registers.registerComponentModel(GraphicComponentModel);
+  registers.registerComponentView(GraphicComponentView);
+  registers.registerPreprocessor(function(option) {
+    var graphicOption = option.graphic;
+    if (isArray(graphicOption)) {
+      if (!graphicOption[0] || !graphicOption[0].elements) {
+        option.graphic = [{
+          elements: graphicOption
+        }];
+      } else {
+        option.graphic = [option.graphic[0]];
+      }
+    } else if (graphicOption && !graphicOption.elements) {
+      option.graphic = [{
+        elements: [graphicOption]
+      }];
+    }
+  });
+}
+export {
+  install
+};

package/es/node_modules/echarts/lib/component/grid/install.mjs

@@ -0,0 +1,10 @@
+import { install as install$1 } from "./installSimple.mjs";
+import { install as install$2 } from "../axisPointer/install.mjs";
+import { use } from "../../extension.mjs";
+function install(registers) {
+  use(install$1);
+  use(install$2);
+}
+export {
+  install
+};

package/es/node_modules/echarts/lib/component/grid/installSimple.mjs

@@ -0,0 +1,58 @@
+import { __extends } from "../../../../tslib/tslib.es6.mjs";
+import ComponentView from "../../view/Component.mjs";
+import GridModel from "../../coord/cartesian/GridModel.mjs";
+import "../../util/graphic.mjs";
+import { defaults } from "../../../../zrender/lib/core/util.mjs";
+import { CartesianAxisModel } from "../../coord/cartesian/AxisModel.mjs";
+import axisModelCreator from "../../coord/axisModelCreator.mjs";
+import Grid from "../../coord/cartesian/Grid.mjs";
+import { CartesianXAxisView, CartesianYAxisView } from "../axis/CartesianAxisView.mjs";
+import Rect from "../../../../zrender/lib/graphic/shape/Rect.mjs";
+var GridView = (
+  /** @class */
+  function(_super) {
+    __extends(GridView2, _super);
+    function GridView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = "grid";
+      return _this;
+    }
+    GridView2.prototype.render = function(gridModel, ecModel) {
+      this.group.removeAll();
+      if (gridModel.get("show")) {
+        this.group.add(new Rect({
+          shape: gridModel.coordinateSystem.getRect(),
+          style: defaults({
+            fill: gridModel.get("backgroundColor")
+          }, gridModel.getItemStyle()),
+          silent: true,
+          z2: -1
+        }));
+      }
+    };
+    GridView2.type = "grid";
+    return GridView2;
+  }(ComponentView)
+);
+var extraOption = {
+  // gridIndex: 0,
+  // gridId: '',
+  offset: 0
+};
+function install(registers) {
+  registers.registerComponentView(GridView);
+  registers.registerComponentModel(GridModel);
+  registers.registerCoordinateSystem("cartesian2d", Grid);
+  axisModelCreator(registers, "x", CartesianAxisModel, extraOption);
+  axisModelCreator(registers, "y", CartesianAxisModel, extraOption);
+  registers.registerComponentView(CartesianXAxisView);
+  registers.registerComponentView(CartesianYAxisView);
+  registers.registerPreprocessor(function(option) {
+    if (option.xAxis && option.yAxis && !option.grid) {
+      option.grid = {};
+    }
+  });
+}
+export {
+  install
+};

package/es/node_modules/echarts/lib/component/helper/listComponent.mjs

@@ -0,0 +1,23 @@
+import { normalizeCssArray } from "../../util/format.mjs";
+import Rect from "../../../../zrender/lib/graphic/shape/Rect.mjs";
+function makeBackground(rect, componentModel) {
+  var padding = normalizeCssArray(componentModel.get("padding"));
+  var style = componentModel.getItemStyle(["color", "opacity"]);
+  style.fill = componentModel.get("backgroundColor");
+  rect = new Rect({
+    shape: {
+      x: rect.x - padding[3],
+      y: rect.y - padding[0],
+      width: rect.width + padding[1] + padding[3],
+      height: rect.height + padding[0] + padding[2],
+      r: componentModel.get("borderRadius")
+    },
+    style,
+    silent: true,
+    z2: -1
+  });
+  return rect;
+}
+export {
+  makeBackground
+};

package/es/node_modules/echarts/lib/component/legend/LegendModel.mjs

@@ -0,0 +1,261 @@
+import { __extends } from "../../../../tslib/tslib.es6.mjs";
+import { isArray, each, merge, isString, createHashMap, map, isNumber, filter, indexOf } from "../../../../zrender/lib/core/util.mjs";
+import Model from "../../model/Model.mjs";
+import { isNameSpecified } from "../../util/model.mjs";
+import ComponentModel from "../../model/Component.mjs";
+var getDefaultSelectorOptions = function(ecModel, type) {
+  if (type === "all") {
+    return {
+      type: "all",
+      title: ecModel.getLocaleModel().get(["legend", "selector", "all"])
+    };
+  } else if (type === "inverse") {
+    return {
+      type: "inverse",
+      title: ecModel.getLocaleModel().get(["legend", "selector", "inverse"])
+    };
+  }
+};
+var LegendModel = (
+  /** @class */
+  function(_super) {
+    __extends(LegendModel2, _super);
+    function LegendModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = LegendModel2.type;
+      _this.layoutMode = {
+        type: "box",
+        // legend.width/height are maxWidth/maxHeight actually,
+        // whereas real width/height is calculated by its content.
+        // (Setting {left: 10, right: 10} does not make sense).
+        // So consider the case:
+        // `setOption({legend: {left: 10});`
+        // then `setOption({legend: {right: 10});`
+        // The previous `left` should be cleared by setting `ignoreSize`.
+        ignoreSize: true
+      };
+      return _this;
+    }
+    LegendModel2.prototype.init = function(option, parentModel, ecModel) {
+      this.mergeDefaultAndTheme(option, ecModel);
+      option.selected = option.selected || {};
+      this._updateSelector(option);
+    };
+    LegendModel2.prototype.mergeOption = function(option, ecModel) {
+      _super.prototype.mergeOption.call(this, option, ecModel);
+      this._updateSelector(option);
+    };
+    LegendModel2.prototype._updateSelector = function(option) {
+      var selector = option.selector;
+      var ecModel = this.ecModel;
+      if (selector === true) {
+        selector = option.selector = ["all", "inverse"];
+      }
+      if (isArray(selector)) {
+        each(selector, function(item, index) {
+          isString(item) && (item = {
+            type: item
+          });
+          selector[index] = merge(item, getDefaultSelectorOptions(ecModel, item.type));
+        });
+      }
+    };
+    LegendModel2.prototype.optionUpdated = function() {
+      this._updateData(this.ecModel);
+      var legendData = this._data;
+      if (legendData[0] && this.get("selectedMode") === "single") {
+        var hasSelected = false;
+        for (var i = 0; i < legendData.length; i++) {
+          var name_1 = legendData[i].get("name");
+          if (this.isSelected(name_1)) {
+            this.select(name_1);
+            hasSelected = true;
+            break;
+          }
+        }
+        !hasSelected && this.select(legendData[0].get("name"));
+      }
+    };
+    LegendModel2.prototype._updateData = function(ecModel) {
+      var potentialData = [];
+      var availableNames = [];
+      ecModel.eachRawSeries(function(seriesModel) {
+        var seriesName = seriesModel.name;
+        availableNames.push(seriesName);
+        var isPotential;
+        if (seriesModel.legendVisualProvider) {
+          var provider = seriesModel.legendVisualProvider;
+          var names = provider.getAllNames();
+          if (!ecModel.isSeriesFiltered(seriesModel)) {
+            availableNames = availableNames.concat(names);
+          }
+          if (names.length) {
+            potentialData = potentialData.concat(names);
+          } else {
+            isPotential = true;
+          }
+        } else {
+          isPotential = true;
+        }
+        if (isPotential && isNameSpecified(seriesModel)) {
+          potentialData.push(seriesModel.name);
+        }
+      });
+      this._availableNames = availableNames;
+      var rawData = this.get("data") || potentialData;
+      var legendNameMap = createHashMap();
+      var legendData = map(rawData, function(dataItem) {
+        if (isString(dataItem) || isNumber(dataItem)) {
+          dataItem = {
+            name: dataItem
+          };
+        }
+        if (legendNameMap.get(dataItem.name)) {
+          return null;
+        }
+        legendNameMap.set(dataItem.name, true);
+        return new Model(dataItem, this, this.ecModel);
+      }, this);
+      this._data = filter(legendData, function(item) {
+        return !!item;
+      });
+    };
+    LegendModel2.prototype.getData = function() {
+      return this._data;
+    };
+    LegendModel2.prototype.select = function(name) {
+      var selected = this.option.selected;
+      var selectedMode = this.get("selectedMode");
+      if (selectedMode === "single") {
+        var data = this._data;
+        each(data, function(dataItem) {
+          selected[dataItem.get("name")] = false;
+        });
+      }
+      selected[name] = true;
+    };
+    LegendModel2.prototype.unSelect = function(name) {
+      if (this.get("selectedMode") !== "single") {
+        this.option.selected[name] = false;
+      }
+    };
+    LegendModel2.prototype.toggleSelected = function(name) {
+      var selected = this.option.selected;
+      if (!selected.hasOwnProperty(name)) {
+        selected[name] = true;
+      }
+      this[selected[name] ? "unSelect" : "select"](name);
+    };
+    LegendModel2.prototype.allSelect = function() {
+      var data = this._data;
+      var selected = this.option.selected;
+      each(data, function(dataItem) {
+        selected[dataItem.get("name", true)] = true;
+      });
+    };
+    LegendModel2.prototype.inverseSelect = function() {
+      var data = this._data;
+      var selected = this.option.selected;
+      each(data, function(dataItem) {
+        var name = dataItem.get("name", true);
+        if (!selected.hasOwnProperty(name)) {
+          selected[name] = true;
+        }
+        selected[name] = !selected[name];
+      });
+    };
+    LegendModel2.prototype.isSelected = function(name) {
+      var selected = this.option.selected;
+      return !(selected.hasOwnProperty(name) && !selected[name]) && indexOf(this._availableNames, name) >= 0;
+    };
+    LegendModel2.prototype.getOrient = function() {
+      return this.get("orient") === "vertical" ? {
+        index: 1,
+        name: "vertical"
+      } : {
+        index: 0,
+        name: "horizontal"
+      };
+    };
+    LegendModel2.type = "legend.plain";
+    LegendModel2.dependencies = ["series"];
+    LegendModel2.defaultOption = {
+      // zlevel: 0,
+      z: 4,
+      show: true,
+      orient: "horizontal",
+      left: "center",
+      // right: 'center',
+      top: 0,
+      // bottom: null,
+      align: "auto",
+      backgroundColor: "rgba(0,0,0,0)",
+      borderColor: "#ccc",
+      borderRadius: 0,
+      borderWidth: 0,
+      padding: 5,
+      itemGap: 10,
+      itemWidth: 25,
+      itemHeight: 14,
+      symbolRotate: "inherit",
+      symbolKeepAspect: true,
+      inactiveColor: "#ccc",
+      inactiveBorderColor: "#ccc",
+      inactiveBorderWidth: "auto",
+      itemStyle: {
+        color: "inherit",
+        opacity: "inherit",
+        borderColor: "inherit",
+        borderWidth: "auto",
+        borderCap: "inherit",
+        borderJoin: "inherit",
+        borderDashOffset: "inherit",
+        borderMiterLimit: "inherit"
+      },
+      lineStyle: {
+        width: "auto",
+        color: "inherit",
+        inactiveColor: "#ccc",
+        inactiveWidth: 2,
+        opacity: "inherit",
+        type: "inherit",
+        cap: "inherit",
+        join: "inherit",
+        dashOffset: "inherit",
+        miterLimit: "inherit"
+      },
+      textStyle: {
+        color: "#333"
+      },
+      selectedMode: true,
+      selector: false,
+      selectorLabel: {
+        show: true,
+        borderRadius: 10,
+        padding: [3, 5, 3, 5],
+        fontSize: 12,
+        fontFamily: "sans-serif",
+        color: "#666",
+        borderWidth: 1,
+        borderColor: "#666"
+      },
+      emphasis: {
+        selectorLabel: {
+          show: true,
+          color: "#eee",
+          backgroundColor: "#666"
+        }
+      },
+      selectorPosition: "auto",
+      selectorItemGap: 7,
+      selectorButtonGap: 10,
+      tooltip: {
+        show: false
+      }
+    };
+    return LegendModel2;
+  }(ComponentModel)
+);
+export {
+  LegendModel as default
+};