sun-card-design 1.1.30 → 1.1.31

package/dist/pc/sun-card-design-pc.es2114.js

@@ -1,248 +1,656 @@
-import { __extends } from "./sun-card-design-pc.es1728.js";
-import { createSymbol, normalizeSymbolOffset, normalizeSymbolSize } from "./sun-card-design-pc.es2072.js";
-import { getECData } from "./sun-card-design-pc.es1738.js";
-import { enterEmphasis, leaveEmphasis, toggleHoverEmphasis } from "./sun-card-design-pc.es1739.js";
-import { getDefaultLabel } from "./sun-card-design-pc.es2119.js";
-import { extend } from "./sun-card-design-pc.es933.js";
-import { getLabelStatesModels, setLabelStyle } from "./sun-card-design-pc.es1840.js";
-import ZRImage from "./sun-card-design-pc.es1760.js";
-import { updateProps, saveOldStyle, initProps, removeElement } from "./sun-card-design-pc.es1762.js";
-import Group from "./sun-card-design-pc.es1763.js";
-var Symbol$1 = (
+import { __extends } from "./sun-card-design-pc.es1814.js";
+import { assert, each, bind, merge, clone, map, curry, defaults } from "./sun-card-design-pc.es932.js";
+import Eventful from "./sun-card-design-pc.es1817.js";
+import { transformDirection, getTransform as getTransform$1 } from "./sun-card-design-pc.es1852.js";
+import { take, release } from "./sun-card-design-pc.es2167.js";
+import DataDiffer from "./sun-card-design-pc.es1868.js";
+import Group from "./sun-card-design-pc.es1848.js";
+import Polygon from "./sun-card-design-pc.es1996.js";
+import Polyline from "./sun-card-design-pc.es1992.js";
+import Rect from "./sun-card-design-pc.es1844.js";
+var BRUSH_PANEL_GLOBAL = true;
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathPow = Math.pow;
+var COVER_Z = 1e4;
+var UNSELECT_THRESHOLD = 6;
+var MIN_RESIZE_LINE_WIDTH = 6;
+var MUTEX_RESOURCE_KEY = "globalPan";
+var DIRECTION_MAP = {
+  w: [0, 0],
+  e: [0, 1],
+  n: [1, 0],
+  s: [1, 1]
+};
+var CURSOR_MAP = {
+  w: "ew",
+  e: "ew",
+  n: "ns",
+  s: "ns",
+  ne: "nesw",
+  sw: "nesw",
+  nw: "nwse",
+  se: "nwse"
+};
+var DEFAULT_BRUSH_OPT = {
+  brushStyle: {
+    lineWidth: 2,
+    stroke: "rgba(210,219,238,0.3)",
+    fill: "#D2DBEE"
+  },
+  transformable: true,
+  brushMode: "single",
+  removeOnClick: false
+};
+var baseUID = 0;
+var BrushController = (
   /** @class */
   (function(_super) {
-    __extends(Symbol, _super);
-    function Symbol(data, idx, seriesScope, opts) {
+    __extends(BrushController2, _super);
+    function BrushController2(zr) {
       var _this = _super.call(this) || this;
-      _this.updateData(data, idx, seriesScope, opts);
+      _this._track = [];
+      _this._covers = [];
+      _this._handlers = {};
+      if (process.env.NODE_ENV !== "production") {
+        assert(zr);
+      }
+      _this._zr = zr;
+      _this.group = new Group();
+      _this._uid = "brushController_" + baseUID++;
+      each(pointerHandlers, function(handler, eventName) {
+        this._handlers[eventName] = bind(handler, this);
+      }, _this);
       return _this;
     }
-    Symbol.prototype._createSymbol = function(symbolType, data, idx, symbolSize, keepAspect) {
-      this.removeAll();
-      var symbolPath = createSymbol(symbolType, -1, -1, 2, 2, null, keepAspect);
-      symbolPath.attr({
-        z2: 100,
-        culling: true,
-        scaleX: symbolSize[0] / 2,
-        scaleY: symbolSize[1] / 2
-      });
-      symbolPath.drift = driftSymbol;
-      this._symbolType = symbolType;
-      this.add(symbolPath);
-    };
-    Symbol.prototype.stopSymbolAnimation = function(toLastFrame) {
-      this.childAt(0).stopAnimation(null, toLastFrame);
-    };
-    Symbol.prototype.getSymbolType = function() {
-      return this._symbolType;
-    };
-    Symbol.prototype.getSymbolPath = function() {
-      return this.childAt(0);
-    };
-    Symbol.prototype.highlight = function() {
-      enterEmphasis(this.childAt(0));
-    };
-    Symbol.prototype.downplay = function() {
-      leaveEmphasis(this.childAt(0));
+    BrushController2.prototype.enableBrush = function(brushOption) {
+      if (process.env.NODE_ENV !== "production") {
+        assert(this._mounted);
+      }
+      this._brushType && this._doDisableBrush();
+      brushOption.brushType && this._doEnableBrush(brushOption);
+      return this;
     };
-    Symbol.prototype.setZ = function(zlevel, z) {
-      var symbolPath = this.childAt(0);
-      symbolPath.zlevel = zlevel;
-      symbolPath.z = z;
+    BrushController2.prototype._doEnableBrush = function(brushOption) {
+      var zr = this._zr;
+      if (!this._enableGlobalPan) {
+        take(zr, MUTEX_RESOURCE_KEY, this._uid);
+      }
+      each(this._handlers, function(handler, eventName) {
+        zr.on(eventName, handler);
+      });
+      this._brushType = brushOption.brushType;
+      this._brushOption = merge(clone(DEFAULT_BRUSH_OPT), brushOption, true);
     };
-    Symbol.prototype.setDraggable = function(draggable, hasCursorOption) {
-      var symbolPath = this.childAt(0);
-      symbolPath.draggable = draggable;
-      symbolPath.cursor = !hasCursorOption && draggable ? "move" : symbolPath.cursor;
+    BrushController2.prototype._doDisableBrush = function() {
+      var zr = this._zr;
+      release(zr, MUTEX_RESOURCE_KEY, this._uid);
+      each(this._handlers, function(handler, eventName) {
+        zr.off(eventName, handler);
+      });
+      this._brushType = this._brushOption = null;
     };
-    Symbol.prototype.updateData = function(data, idx, seriesScope, opts) {
-      this.silent = false;
-      var symbolType = data.getItemVisual(idx, "symbol") || "circle";
-      var seriesModel = data.hostModel;
-      var symbolSize = Symbol.getSymbolSize(data, idx);
-      var isInit = symbolType !== this._symbolType;
-      var disableAnimation = opts && opts.disableAnimation;
-      if (isInit) {
-        var keepAspect = data.getItemVisual(idx, "symbolKeepAspect");
-        this._createSymbol(symbolType, data, idx, symbolSize, keepAspect);
+    BrushController2.prototype.setPanels = function(panelOpts) {
+      if (panelOpts && panelOpts.length) {
+        var panels_1 = this._panels = {};
+        each(panelOpts, function(panelOpts2) {
+          panels_1[panelOpts2.panelId] = clone(panelOpts2);
+        });
       } else {
-        var symbolPath = this.childAt(0);
-        symbolPath.silent = false;
-        var target = {
-          scaleX: symbolSize[0] / 2,
-          scaleY: symbolSize[1] / 2
-        };
-        disableAnimation ? symbolPath.attr(target) : updateProps(symbolPath, target, seriesModel, idx);
-        saveOldStyle(symbolPath);
-      }
-      this._updateCommon(data, idx, symbolSize, seriesScope, opts);
-      if (isInit) {
-        var symbolPath = this.childAt(0);
-        if (!disableAnimation) {
-          var target = {
-            scaleX: this._sizeX,
-            scaleY: this._sizeY,
-            style: {
-              // Always fadeIn. Because it has fadeOut animation when symbol is removed..
-              opacity: symbolPath.style.opacity
-            }
-          };
-          symbolPath.scaleX = symbolPath.scaleY = 0;
-          symbolPath.style.opacity = 0;
-          initProps(symbolPath, target, seriesModel, idx);
-        }
+        this._panels = null;
       }
-      if (disableAnimation) {
-        this.childAt(0).stopAnimation("leave");
+      return this;
+    };
+    BrushController2.prototype.mount = function(opt) {
+      opt = opt || {};
+      if (process.env.NODE_ENV !== "production") {
+        this._mounted = true;
       }
+      this._enableGlobalPan = opt.enableGlobalPan;
+      var thisGroup = this.group;
+      this._zr.add(thisGroup);
+      thisGroup.attr({
+        x: opt.x || 0,
+        y: opt.y || 0,
+        rotation: opt.rotation || 0,
+        scaleX: opt.scaleX || 1,
+        scaleY: opt.scaleY || 1
+      });
+      this._transform = thisGroup.getLocalTransform();
+      return this;
     };
-    Symbol.prototype._updateCommon = function(data, idx, symbolSize, seriesScope, opts) {
-      var symbolPath = this.childAt(0);
-      var seriesModel = data.hostModel;
-      var emphasisItemStyle;
-      var blurItemStyle;
-      var selectItemStyle;
-      var focus;
-      var blurScope;
-      var emphasisDisabled;
-      var labelStatesModels;
-      var hoverScale;
-      var cursorStyle;
-      if (seriesScope) {
-        emphasisItemStyle = seriesScope.emphasisItemStyle;
-        blurItemStyle = seriesScope.blurItemStyle;
-        selectItemStyle = seriesScope.selectItemStyle;
-        focus = seriesScope.focus;
-        blurScope = seriesScope.blurScope;
-        labelStatesModels = seriesScope.labelStatesModels;
-        hoverScale = seriesScope.hoverScale;
-        cursorStyle = seriesScope.cursorStyle;
-        emphasisDisabled = seriesScope.emphasisDisabled;
-      }
-      if (!seriesScope || data.hasItemOption) {
-        var itemModel = seriesScope && seriesScope.itemModel ? seriesScope.itemModel : data.getItemModel(idx);
-        var emphasisModel = itemModel.getModel("emphasis");
-        emphasisItemStyle = emphasisModel.getModel("itemStyle").getItemStyle();
-        selectItemStyle = itemModel.getModel(["select", "itemStyle"]).getItemStyle();
-        blurItemStyle = itemModel.getModel(["blur", "itemStyle"]).getItemStyle();
-        focus = emphasisModel.get("focus");
-        blurScope = emphasisModel.get("blurScope");
-        emphasisDisabled = emphasisModel.get("disabled");
-        labelStatesModels = getLabelStatesModels(itemModel);
-        hoverScale = emphasisModel.getShallow("scale");
-        cursorStyle = itemModel.getShallow("cursor");
-      }
-      var symbolRotate = data.getItemVisual(idx, "symbolRotate");
-      symbolPath.attr("rotation", (symbolRotate || 0) * Math.PI / 180 || 0);
-      var symbolOffset = normalizeSymbolOffset(data.getItemVisual(idx, "symbolOffset"), symbolSize);
-      if (symbolOffset) {
-        symbolPath.x = symbolOffset[0];
-        symbolPath.y = symbolOffset[1];
-      }
-      cursorStyle && symbolPath.attr("cursor", cursorStyle);
-      var symbolStyle = data.getItemVisual(idx, "style");
-      var visualColor = symbolStyle.fill;
-      if (symbolPath instanceof ZRImage) {
-        var pathStyle = symbolPath.style;
-        symbolPath.useStyle(extend({
-          // TODO other properties like x, y ?
-          image: pathStyle.image,
-          x: pathStyle.x,
-          y: pathStyle.y,
-          width: pathStyle.width,
-          height: pathStyle.height
-        }, symbolStyle));
-      } else {
-        if (symbolPath.__isEmptyBrush) {
-          symbolPath.useStyle(extend({}, symbolStyle));
+    BrushController2.prototype.updateCovers = function(coverConfigList) {
+      if (process.env.NODE_ENV !== "production") {
+        assert(this._mounted);
+      }
+      coverConfigList = map(coverConfigList, function(coverConfig) {
+        return merge(clone(DEFAULT_BRUSH_OPT), coverConfig, true);
+      });
+      var tmpIdPrefix = "\0-brush-index-";
+      var oldCovers = this._covers;
+      var newCovers = this._covers = [];
+      var controller = this;
+      var creatingCover = this._creatingCover;
+      new DataDiffer(oldCovers, coverConfigList, oldGetKey, getKey).add(addOrUpdate).update(addOrUpdate).remove(remove).execute();
+      return this;
+      function getKey(brushOption, index) {
+        return (brushOption.id != null ? brushOption.id : tmpIdPrefix + index) + "-" + brushOption.brushType;
+      }
+      function oldGetKey(cover, index) {
+        return getKey(cover.__brushOption, index);
+      }
+      function addOrUpdate(newIndex, oldIndex) {
+        var newBrushInternal = coverConfigList[newIndex];
+        if (oldIndex != null && oldCovers[oldIndex] === creatingCover) {
+          newCovers[newIndex] = oldCovers[oldIndex];
         } else {
-          symbolPath.useStyle(symbolStyle);
+          var cover = newCovers[newIndex] = oldIndex != null ? (oldCovers[oldIndex].__brushOption = newBrushInternal, oldCovers[oldIndex]) : endCreating(controller, createCover(controller, newBrushInternal));
+          updateCoverAfterCreation(controller, cover);
         }
-        symbolPath.style.decal = null;
-        symbolPath.setColor(visualColor, opts && opts.symbolInnerColor);
-        symbolPath.style.strokeNoScale = true;
-      }
-      var liftZ = data.getItemVisual(idx, "liftZ");
-      var z2Origin = this._z2;
-      if (liftZ != null) {
-        if (z2Origin == null) {
-          this._z2 = symbolPath.z2;
-          symbolPath.z2 += liftZ;
+      }
+      function remove(oldIndex) {
+        if (oldCovers[oldIndex] !== creatingCover) {
+          controller.group.remove(oldCovers[oldIndex]);
         }
-      } else if (z2Origin != null) {
-        symbolPath.z2 = z2Origin;
-        this._z2 = null;
-      }
-      var useNameLabel = opts && opts.useNameLabel;
-      setLabelStyle(symbolPath, labelStatesModels, {
-        labelFetcher: seriesModel,
-        labelDataIndex: idx,
-        defaultText: getLabelDefaultText,
-        inheritColor: visualColor,
-        defaultOpacity: symbolStyle.opacity
-      });
-      function getLabelDefaultText(idx2) {
-        return useNameLabel ? data.getName(idx2) : getDefaultLabel(data, idx2);
-      }
-      this._sizeX = symbolSize[0] / 2;
-      this._sizeY = symbolSize[1] / 2;
-      var emphasisState = symbolPath.ensureState("emphasis");
-      emphasisState.style = emphasisItemStyle;
-      symbolPath.ensureState("select").style = selectItemStyle;
-      symbolPath.ensureState("blur").style = blurItemStyle;
-      var scaleRatio = hoverScale == null || hoverScale === true ? Math.max(1.1, 3 / this._sizeY) : isFinite(hoverScale) && hoverScale > 0 ? +hoverScale : 1;
-      emphasisState.scaleX = this._sizeX * scaleRatio;
-      emphasisState.scaleY = this._sizeY * scaleRatio;
-      this.setSymbolScale(1);
-      toggleHoverEmphasis(this, focus, blurScope, emphasisDisabled);
-    };
-    Symbol.prototype.setSymbolScale = function(scale) {
-      this.scaleX = this.scaleY = scale;
+      }
     };
-    Symbol.prototype.fadeOut = function(cb, seriesModel, opt) {
-      var symbolPath = this.childAt(0);
-      var dataIndex = getECData(this).dataIndex;
-      var animationOpt = opt && opt.animation;
-      this.silent = symbolPath.silent = true;
-      if (opt && opt.fadeLabel) {
-        var textContent = symbolPath.getTextContent();
-        if (textContent) {
-          removeElement(textContent, {
-            style: {
-              opacity: 0
-            }
-          }, seriesModel, {
-            dataIndex,
-            removeOpt: animationOpt,
-            cb: function() {
-              symbolPath.removeTextContent();
-            }
-          });
+    BrushController2.prototype.unmount = function() {
+      if (process.env.NODE_ENV !== "production") {
+        if (!this._mounted) {
+          return;
         }
-      } else {
-        symbolPath.removeTextContent();
       }
-      removeElement(symbolPath, {
-        style: {
-          opacity: 0
-        },
-        scaleX: 0,
-        scaleY: 0
-      }, seriesModel, {
-        dataIndex,
-        cb,
-        removeOpt: animationOpt
-      });
+      this.enableBrush(false);
+      clearCovers(this);
+      this._zr.remove(this.group);
+      if (process.env.NODE_ENV !== "production") {
+        this._mounted = false;
+      }
+      return this;
     };
-    Symbol.getSymbolSize = function(data, idx) {
-      return normalizeSymbolSize(data.getItemVisual(idx, "symbolSize"));
+    BrushController2.prototype.dispose = function() {
+      this.unmount();
+      this.off();
     };
-    return Symbol;
-  })(Group)
+    return BrushController2;
+  })(Eventful)
 );
-function driftSymbol(dx, dy) {
-  this.parent.drift(dx, dy);
+function createCover(controller, brushOption) {
+  var cover = coverRenderers[brushOption.brushType].createCover(controller, brushOption);
+  cover.__brushOption = brushOption;
+  updateZ(cover, brushOption);
+  controller.group.add(cover);
+  return cover;
+}
+function endCreating(controller, creatingCover) {
+  var coverRenderer = getCoverRenderer(creatingCover);
+  if (coverRenderer.endCreating) {
+    coverRenderer.endCreating(controller, creatingCover);
+    updateZ(creatingCover, creatingCover.__brushOption);
+  }
+  return creatingCover;
+}
+function updateCoverShape(controller, cover) {
+  var brushOption = cover.__brushOption;
+  getCoverRenderer(cover).updateCoverShape(controller, cover, brushOption.range, brushOption);
+}
+function updateZ(cover, brushOption) {
+  var z = brushOption.z;
+  z == null && (z = COVER_Z);
+  cover.traverse(function(el) {
+    el.z = z;
+    el.z2 = z;
+  });
+}
+function updateCoverAfterCreation(controller, cover) {
+  getCoverRenderer(cover).updateCommon(controller, cover);
+  updateCoverShape(controller, cover);
+}
+function getCoverRenderer(cover) {
+  return coverRenderers[cover.__brushOption.brushType];
+}
+function getPanelByPoint(controller, e, localCursorPoint) {
+  var panels = controller._panels;
+  if (!panels) {
+    return BRUSH_PANEL_GLOBAL;
+  }
+  var panel;
+  var transform = controller._transform;
+  each(panels, function(pn) {
+    pn.isTargetByCursor(e, localCursorPoint, transform) && (panel = pn);
+  });
+  return panel;
+}
+function getPanelByCover(controller, cover) {
+  var panels = controller._panels;
+  if (!panels) {
+    return BRUSH_PANEL_GLOBAL;
+  }
+  var panelId = cover.__brushOption.panelId;
+  return panelId != null ? panels[panelId] : BRUSH_PANEL_GLOBAL;
+}
+function clearCovers(controller) {
+  var covers = controller._covers;
+  var originalLength = covers.length;
+  each(covers, function(cover) {
+    controller.group.remove(cover);
+  }, controller);
+  covers.length = 0;
+  return !!originalLength;
+}
+function trigger(controller, opt) {
+  var areas = map(controller._covers, function(cover) {
+    var brushOption = cover.__brushOption;
+    var range = clone(brushOption.range);
+    return {
+      brushType: brushOption.brushType,
+      panelId: brushOption.panelId,
+      range
+    };
+  });
+  controller.trigger("brush", {
+    areas,
+    isEnd: !!opt.isEnd,
+    removeOnClick: !!opt.removeOnClick
+  });
+}
+function shouldShowCover(controller) {
+  var track = controller._track;
+  if (!track.length) {
+    return false;
+  }
+  var p2 = track[track.length - 1];
+  var p1 = track[0];
+  var dx = p2[0] - p1[0];
+  var dy = p2[1] - p1[1];
+  var dist = mathPow(dx * dx + dy * dy, 0.5);
+  return dist > UNSELECT_THRESHOLD;
+}
+function getTrackEnds(track) {
+  var tail = track.length - 1;
+  tail < 0 && (tail = 0);
+  return [track[0], track[tail]];
+}
+function createBaseRectCover(rectRangeConverter, controller, brushOption, edgeNameSequences) {
+  var cover = new Group();
+  cover.add(new Rect({
+    name: "main",
+    style: makeStyle(brushOption),
+    silent: true,
+    draggable: true,
+    cursor: "move",
+    drift: curry(driftRect, rectRangeConverter, controller, cover, ["n", "s", "w", "e"]),
+    ondragend: curry(trigger, controller, {
+      isEnd: true
+    })
+  }));
+  each(edgeNameSequences, function(nameSequence) {
+    cover.add(new Rect({
+      name: nameSequence.join(""),
+      style: {
+        opacity: 0
+      },
+      draggable: true,
+      silent: true,
+      invisible: true,
+      drift: curry(driftRect, rectRangeConverter, controller, cover, nameSequence),
+      ondragend: curry(trigger, controller, {
+        isEnd: true
+      })
+    }));
+  });
+  return cover;
+}
+function updateBaseRect(controller, cover, localRange, brushOption) {
+  var lineWidth = brushOption.brushStyle.lineWidth || 0;
+  var handleSize = mathMax(lineWidth, MIN_RESIZE_LINE_WIDTH);
+  var x = localRange[0][0];
+  var y = localRange[1][0];
+  var xa = x - lineWidth / 2;
+  var ya = y - lineWidth / 2;
+  var x2 = localRange[0][1];
+  var y2 = localRange[1][1];
+  var x2a = x2 - handleSize + lineWidth / 2;
+  var y2a = y2 - handleSize + lineWidth / 2;
+  var width = x2 - x;
+  var height = y2 - y;
+  var widtha = width + lineWidth;
+  var heighta = height + lineWidth;
+  updateRectShape(controller, cover, "main", x, y, width, height);
+  if (brushOption.transformable) {
+    updateRectShape(controller, cover, "w", xa, ya, handleSize, heighta);
+    updateRectShape(controller, cover, "e", x2a, ya, handleSize, heighta);
+    updateRectShape(controller, cover, "n", xa, ya, widtha, handleSize);
+    updateRectShape(controller, cover, "s", xa, y2a, widtha, handleSize);
+    updateRectShape(controller, cover, "nw", xa, ya, handleSize, handleSize);
+    updateRectShape(controller, cover, "ne", x2a, ya, handleSize, handleSize);
+    updateRectShape(controller, cover, "sw", xa, y2a, handleSize, handleSize);
+    updateRectShape(controller, cover, "se", x2a, y2a, handleSize, handleSize);
+  }
+}
+function updateCommon(controller, cover) {
+  var brushOption = cover.__brushOption;
+  var transformable = brushOption.transformable;
+  var mainEl = cover.childAt(0);
+  mainEl.useStyle(makeStyle(brushOption));
+  mainEl.attr({
+    silent: !transformable,
+    cursor: transformable ? "move" : "default"
+  });
+  each([["w"], ["e"], ["n"], ["s"], ["s", "e"], ["s", "w"], ["n", "e"], ["n", "w"]], function(nameSequence) {
+    var el = cover.childOfName(nameSequence.join(""));
+    var globalDir = nameSequence.length === 1 ? getGlobalDirection1(controller, nameSequence[0]) : getGlobalDirection2(controller, nameSequence);
+    el && el.attr({
+      silent: !transformable,
+      invisible: !transformable,
+      cursor: transformable ? CURSOR_MAP[globalDir] + "-resize" : null
+    });
+  });
+}
+function updateRectShape(controller, cover, name, x, y, w, h) {
+  var el = cover.childOfName(name);
+  el && el.setShape(pointsToRect(clipByPanel(controller, cover, [[x, y], [x + w, y + h]])));
+}
+function makeStyle(brushOption) {
+  return defaults({
+    strokeNoScale: true
+  }, brushOption.brushStyle);
+}
+function formatRectRange(x, y, x2, y2) {
+  var min = [mathMin(x, x2), mathMin(y, y2)];
+  var max = [mathMax(x, x2), mathMax(y, y2)];
+  return [
+    [min[0], max[0]],
+    [min[1], max[1]]
+    // y range
+  ];
+}
+function getTransform(controller) {
+  return getTransform$1(controller.group);
+}
+function getGlobalDirection1(controller, localDirName) {
+  var map2 = {
+    w: "left",
+    e: "right",
+    n: "top",
+    s: "bottom"
+  };
+  var inverseMap = {
+    left: "w",
+    right: "e",
+    top: "n",
+    bottom: "s"
+  };
+  var dir = transformDirection(map2[localDirName], getTransform(controller));
+  return inverseMap[dir];
+}
+function getGlobalDirection2(controller, localDirNameSeq) {
+  var globalDir = [getGlobalDirection1(controller, localDirNameSeq[0]), getGlobalDirection1(controller, localDirNameSeq[1])];
+  (globalDir[0] === "e" || globalDir[0] === "w") && globalDir.reverse();
+  return globalDir.join("");
+}
+function driftRect(rectRangeConverter, controller, cover, dirNameSequence, dx, dy) {
+  var brushOption = cover.__brushOption;
+  var rectRange = rectRangeConverter.toRectRange(brushOption.range);
+  var localDelta = toLocalDelta(controller, dx, dy);
+  each(dirNameSequence, function(dirName) {
+    var ind = DIRECTION_MAP[dirName];
+    rectRange[ind[0]][ind[1]] += localDelta[ind[0]];
+  });
+  brushOption.range = rectRangeConverter.fromRectRange(formatRectRange(rectRange[0][0], rectRange[1][0], rectRange[0][1], rectRange[1][1]));
+  updateCoverAfterCreation(controller, cover);
+  trigger(controller, {
+    isEnd: false
+  });
+}
+function driftPolygon(controller, cover, dx, dy) {
+  var range = cover.__brushOption.range;
+  var localDelta = toLocalDelta(controller, dx, dy);
+  each(range, function(point) {
+    point[0] += localDelta[0];
+    point[1] += localDelta[1];
+  });
+  updateCoverAfterCreation(controller, cover);
+  trigger(controller, {
+    isEnd: false
+  });
+}
+function toLocalDelta(controller, dx, dy) {
+  var thisGroup = controller.group;
+  var localD = thisGroup.transformCoordToLocal(dx, dy);
+  var localZero = thisGroup.transformCoordToLocal(0, 0);
+  return [localD[0] - localZero[0], localD[1] - localZero[1]];
+}
+function clipByPanel(controller, cover, data) {
+  var panel = getPanelByCover(controller, cover);
+  return panel && panel !== BRUSH_PANEL_GLOBAL ? panel.clipPath(data, controller._transform) : clone(data);
+}
+function pointsToRect(points) {
+  var xmin = mathMin(points[0][0], points[1][0]);
+  var ymin = mathMin(points[0][1], points[1][1]);
+  var xmax = mathMax(points[0][0], points[1][0]);
+  var ymax = mathMax(points[0][1], points[1][1]);
+  return {
+    x: xmin,
+    y: ymin,
+    width: xmax - xmin,
+    height: ymax - ymin
+  };
+}
+function resetCursor(controller, e, localCursorPoint) {
+  if (
+    // Check active
+    !controller._brushType || isOutsideZrArea(controller, e.offsetX, e.offsetY)
+  ) {
+    return;
+  }
+  var zr = controller._zr;
+  var covers = controller._covers;
+  var currPanel = getPanelByPoint(controller, e, localCursorPoint);
+  if (!controller._dragging) {
+    for (var i = 0; i < covers.length; i++) {
+      var brushOption = covers[i].__brushOption;
+      if (currPanel && (currPanel === BRUSH_PANEL_GLOBAL || brushOption.panelId === currPanel.panelId) && coverRenderers[brushOption.brushType].contain(covers[i], localCursorPoint[0], localCursorPoint[1])) {
+        return;
+      }
+    }
+  }
+  currPanel && zr.setCursorStyle("crosshair");
+}
+function preventDefault(e) {
+  var rawE = e.event;
+  rawE.preventDefault && rawE.preventDefault();
+}
+function mainShapeContain(cover, x, y) {
+  return cover.childOfName("main").contain(x, y);
+}
+function updateCoverByMouse(controller, e, localCursorPoint, isEnd) {
+  var creatingCover = controller._creatingCover;
+  var panel = controller._creatingPanel;
+  var thisBrushOption = controller._brushOption;
+  var eventParams;
+  controller._track.push(localCursorPoint.slice());
+  if (shouldShowCover(controller) || creatingCover) {
+    if (panel && !creatingCover) {
+      thisBrushOption.brushMode === "single" && clearCovers(controller);
+      var brushOption = clone(thisBrushOption);
+      brushOption.brushType = determineBrushType(brushOption.brushType, panel);
+      brushOption.panelId = panel === BRUSH_PANEL_GLOBAL ? null : panel.panelId;
+      creatingCover = controller._creatingCover = createCover(controller, brushOption);
+      controller._covers.push(creatingCover);
+    }
+    if (creatingCover) {
+      var coverRenderer = coverRenderers[determineBrushType(controller._brushType, panel)];
+      var coverBrushOption = creatingCover.__brushOption;
+      coverBrushOption.range = coverRenderer.getCreatingRange(clipByPanel(controller, creatingCover, controller._track));
+      if (isEnd) {
+        endCreating(controller, creatingCover);
+        coverRenderer.updateCommon(controller, creatingCover);
+      }
+      updateCoverShape(controller, creatingCover);
+      eventParams = {
+        isEnd
+      };
+    }
+  } else if (isEnd && thisBrushOption.brushMode === "single" && thisBrushOption.removeOnClick) {
+    if (getPanelByPoint(controller, e, localCursorPoint) && clearCovers(controller)) {
+      eventParams = {
+        isEnd,
+        removeOnClick: true
+      };
+    }
+  }
+  return eventParams;
+}
+function determineBrushType(brushType, panel) {
+  if (brushType === "auto") {
+    if (process.env.NODE_ENV !== "production") {
+      assert(panel && panel.defaultBrushType, 'MUST have defaultBrushType when brushType is "atuo"');
+    }
+    return panel.defaultBrushType;
+  }
+  return brushType;
+}
+var pointerHandlers = {
+  mousedown: function(e) {
+    if (this._dragging) {
+      handleDragEnd(this, e);
+    } else if (!e.target || !e.target.draggable) {
+      preventDefault(e);
+      var localCursorPoint = this.group.transformCoordToLocal(e.offsetX, e.offsetY);
+      this._creatingCover = null;
+      var panel = this._creatingPanel = getPanelByPoint(this, e, localCursorPoint);
+      if (panel) {
+        this._dragging = true;
+        this._track = [localCursorPoint.slice()];
+      }
+    }
+  },
+  mousemove: function(e) {
+    var x = e.offsetX;
+    var y = e.offsetY;
+    var localCursorPoint = this.group.transformCoordToLocal(x, y);
+    resetCursor(this, e, localCursorPoint);
+    if (this._dragging) {
+      preventDefault(e);
+      var eventParams = updateCoverByMouse(this, e, localCursorPoint, false);
+      eventParams && trigger(this, eventParams);
+    }
+  },
+  mouseup: function(e) {
+    handleDragEnd(this, e);
+  }
+};
+function handleDragEnd(controller, e) {
+  if (controller._dragging) {
+    preventDefault(e);
+    var x = e.offsetX;
+    var y = e.offsetY;
+    var localCursorPoint = controller.group.transformCoordToLocal(x, y);
+    var eventParams = updateCoverByMouse(controller, e, localCursorPoint, true);
+    controller._dragging = false;
+    controller._track = [];
+    controller._creatingCover = null;
+    eventParams && trigger(controller, eventParams);
+  }
+}
+function isOutsideZrArea(controller, x, y) {
+  var zr = controller._zr;
+  return x < 0 || x > zr.getWidth() || y < 0 || y > zr.getHeight();
+}
+var coverRenderers = {
+  lineX: getLineRenderer(0),
+  lineY: getLineRenderer(1),
+  rect: {
+    createCover: function(controller, brushOption) {
+      function returnInput(range) {
+        return range;
+      }
+      return createBaseRectCover({
+        toRectRange: returnInput,
+        fromRectRange: returnInput
+      }, controller, brushOption, [["w"], ["e"], ["n"], ["s"], ["s", "e"], ["s", "w"], ["n", "e"], ["n", "w"]]);
+    },
+    getCreatingRange: function(localTrack) {
+      var ends = getTrackEnds(localTrack);
+      return formatRectRange(ends[1][0], ends[1][1], ends[0][0], ends[0][1]);
+    },
+    updateCoverShape: function(controller, cover, localRange, brushOption) {
+      updateBaseRect(controller, cover, localRange, brushOption);
+    },
+    updateCommon,
+    contain: mainShapeContain
+  },
+  polygon: {
+    createCover: function(controller, brushOption) {
+      var cover = new Group();
+      cover.add(new Polyline({
+        name: "main",
+        style: makeStyle(brushOption),
+        silent: true
+      }));
+      return cover;
+    },
+    getCreatingRange: function(localTrack) {
+      return localTrack;
+    },
+    endCreating: function(controller, cover) {
+      cover.remove(cover.childAt(0));
+      cover.add(new Polygon({
+        name: "main",
+        draggable: true,
+        drift: curry(driftPolygon, controller, cover),
+        ondragend: curry(trigger, controller, {
+          isEnd: true
+        })
+      }));
+    },
+    updateCoverShape: function(controller, cover, localRange, brushOption) {
+      cover.childAt(0).setShape({
+        points: clipByPanel(controller, cover, localRange)
+      });
+    },
+    updateCommon,
+    contain: mainShapeContain
+  }
+};
+function getLineRenderer(xyIndex) {
+  return {
+    createCover: function(controller, brushOption) {
+      return createBaseRectCover({
+        toRectRange: function(range) {
+          var rectRange = [range, [0, 100]];
+          xyIndex && rectRange.reverse();
+          return rectRange;
+        },
+        fromRectRange: function(rectRange) {
+          return rectRange[xyIndex];
+        }
+      }, controller, brushOption, [[["w"], ["e"]], [["n"], ["s"]]][xyIndex]);
+    },
+    getCreatingRange: function(localTrack) {
+      var ends = getTrackEnds(localTrack);
+      var min = mathMin(ends[0][xyIndex], ends[1][xyIndex]);
+      var max = mathMax(ends[0][xyIndex], ends[1][xyIndex]);
+      return [min, max];
+    },
+    updateCoverShape: function(controller, cover, localRange, brushOption) {
+      var otherExtent;
+      var panel = getPanelByCover(controller, cover);
+      if (panel !== BRUSH_PANEL_GLOBAL && panel.getLinearBrushOtherExtent) {
+        otherExtent = panel.getLinearBrushOtherExtent(xyIndex);
+      } else {
+        var zr = controller._zr;
+        otherExtent = [0, [zr.getWidth(), zr.getHeight()][1 - xyIndex]];
+      }
+      var rectRange = [localRange, otherExtent];
+      xyIndex && rectRange.reverse();
+      updateBaseRect(controller, cover, rectRange, brushOption);
+    },
+    updateCommon,
+    contain: mainShapeContain
+  };
 }
 export {
-  Symbol$1 as default
+  BrushController as default
 };