web-core-tcm 0.0.59 → 0.0.61

package/dist/node_modules/echarts/lib/component/axis/SingleAxisView.js

@@ -0,0 +1,70 @@
+import { __extends as G } from "../../../../tslib/tslib.es6.js";
+import { each as c, defaults as L } from "../../../../zrender/lib/core/util.js";
+import S from "./AxisBuilder.js";
+import { groupTransition as B, subPixelOptimizeLine as C, mergePath as _ } from "../../util/graphic.js";
+import { layout as P } from "../../coord/single/singleAxisHelper.js";
+import V from "./AxisView.js";
+import { rectCoordAxisHandleRemove as b, rectCoordAxisBuildSplitArea as k } from "./axisSplitHelper.js";
+import z from "../../../../zrender/lib/graphic/Group.js";
+import H from "../../../../zrender/lib/graphic/shape/Line.js";
+var R = ["axisLine", "axisTickLabel", "axisName"], T = ["splitArea", "splitLine"], K = (
+  /** @class */
+  (function(a) {
+    G(t, a);
+    function t() {
+      var i = a !== null && a.apply(this, arguments) || this;
+      return i.type = t.type, i.axisPointerClass = "SingleAxisPointer", i;
+    }
+    return t.prototype.render = function(i, o, l, h) {
+      var n = this.group;
+      n.removeAll();
+      var e = this._axisGroup;
+      this._axisGroup = new z();
+      var f = P(i), r = new S(i, f);
+      c(R, r.add, r), n.add(this._axisGroup), n.add(r.getGroup()), c(T, function(g) {
+        i.get([g, "show"]) && E[g](this, this.group, this._axisGroup, i);
+      }, this), B(e, this._axisGroup, i), a.prototype.render.call(this, i, o, l, h);
+    }, t.prototype.remove = function() {
+      b(this);
+    }, t.type = "singleAxis", t;
+  })(V)
+), E = {
+  splitLine: function(a, t, i, o) {
+    var l = o.axis;
+    if (!l.scale.isBlank()) {
+      var h = o.getModel("splitLine"), n = h.getModel("lineStyle"), e = n.get("color");
+      e = e instanceof Array ? e : [e];
+      for (var f = n.get("width"), r = o.coordinateSystem.getRect(), g = l.isHorizontal(), v = [], A = 0, x = l.getTicksCoords({
+        tickModel: h
+      }), p = [], u = [], s = 0; s < x.length; ++s) {
+        var m = l.toGlobalCoord(x[s].coord);
+        g ? (p[0] = m, p[1] = r.y, u[0] = m, u[1] = r.y + r.height) : (p[0] = r.x, p[1] = m, u[0] = r.x + r.width, u[1] = m);
+        var y = new H({
+          shape: {
+            x1: p[0],
+            y1: p[1],
+            x2: u[0],
+            y2: u[1]
+          },
+          silent: !0
+        });
+        C(y.shape, f);
+        var d = A++ % e.length;
+        v[d] = v[d] || [], v[d].push(y);
+      }
+      for (var w = n.getLineStyle(["color"]), s = 0; s < v.length; ++s)
+        t.add(_(v[s], {
+          style: L({
+            stroke: e[s % e.length]
+          }, w),
+          silent: !0
+        }));
+    }
+  },
+  splitArea: function(a, t, i, o) {
+    k(a, i, o, o);
+  }
+};
+export {
+  K as default
+};

package/dist/node_modules/echarts/lib/component/axis/axisSplitHelper.js

@@ -0,0 +1,53 @@
+import { createHashMap as b, isArray as B, defaults as H } from "../../../../zrender/lib/core/util.js";
+import { makeInner as G } from "../../util/model.js";
+import x from "../../../../zrender/lib/graphic/shape/Rect.js";
+var u = G();
+function T(s, h, A, k) {
+  var o = A.axis;
+  if (!o.scale.isBlank()) {
+    var C = A.getModel("splitArea"), g = C.getModel("areaStyle"), a = g.get("color"), n = k.coordinateSystem.getRect(), e = o.getTicksCoords({
+      tickModel: C,
+      clamp: !0
+    });
+    if (e.length) {
+      var f = a.length, m = u(s).splitAreaColors, S = b(), l = 0;
+      if (m)
+        for (var r = 0; r < e.length; r++) {
+          var y = m.get(e[r].tickValue);
+          if (y != null) {
+            l = (y + (f - 1) * r) % f;
+            break;
+          }
+        }
+      var v = o.toGlobalCoord(e[0].coord), R = g.getAreaStyle();
+      a = B(a) ? a : [a];
+      for (var r = 1; r < e.length; r++) {
+        var M = o.toGlobalCoord(e[r].coord), t = void 0, i = void 0, d = void 0, c = void 0;
+        o.isHorizontal() ? (t = v, i = n.y, d = M - t, c = n.height, v = t + d) : (t = n.x, i = v, d = n.width, c = M - i, v = i + c);
+        var p = e[r - 1].tickValue;
+        p != null && S.set(p, l), h.add(new x({
+          anid: p != null ? "area_" + p : null,
+          shape: {
+            x: t,
+            y: i,
+            width: d,
+            height: c
+          },
+          style: H({
+            fill: a[l]
+          }, R),
+          autoBatch: !0,
+          silent: !0
+        })), l = (l + 1) % f;
+      }
+      u(s).splitAreaColors = S;
+    }
+  }
+}
+function _(s) {
+  u(s).splitAreaColors = null;
+}
+export {
+  T as rectCoordAxisBuildSplitArea,
+  _ as rectCoordAxisHandleRemove
+};

package/dist/node_modules/echarts/lib/component/axis/parallelAxisAction.js

@@ -0,0 +1,25 @@
+var a = {
+  type: "axisAreaSelect",
+  event: "axisAreaSelected"
+  // update: 'updateVisual'
+};
+function l(i) {
+  i.registerAction(a, function(e, n) {
+    n.eachComponent({
+      mainType: "parallelAxis",
+      query: e
+    }, function(t) {
+      t.axis.model.setActiveIntervals(e.intervals);
+    });
+  }), i.registerAction("parallelAxisExpand", function(e, n) {
+    n.eachComponent({
+      mainType: "parallel",
+      query: e
+    }, function(t) {
+      t.setAxisExpand(e);
+    });
+  });
+}
+export {
+  l as installParallelActions
+};

package/dist/node_modules/echarts/lib/component/axisPointer/AxisPointerModel.js

@@ -0,0 +1,71 @@
+import { __extends as r } from "../../../../tslib/tslib.es6.js";
+import a from "../../model/Component.js";
+var n = (
+  /** @class */
+  (function(t) {
+    r(o, t);
+    function o() {
+      var e = t !== null && t.apply(this, arguments) || this;
+      return e.type = o.type, e;
+    }
+    return o.type = "axisPointer", o.defaultOption = {
+      // 'auto' means that show when triggered by tooltip or handle.
+      show: "auto",
+      // zlevel: 0,
+      z: 50,
+      type: "line",
+      // axispointer triggered by tootip determine snap automatically,
+      // see `modelHelper`.
+      snap: !1,
+      triggerTooltip: !0,
+      triggerEmphasis: !0,
+      value: null,
+      status: null,
+      link: [],
+      // Do not set 'auto' here, otherwise global animation: false
+      // will not effect at this axispointer.
+      animation: null,
+      animationDurationUpdate: 200,
+      lineStyle: {
+        color: "#B9BEC9",
+        width: 1,
+        type: "dashed"
+      },
+      shadowStyle: {
+        color: "rgba(210,219,238,0.2)"
+      },
+      label: {
+        show: !0,
+        formatter: null,
+        precision: "auto",
+        margin: 3,
+        color: "#fff",
+        padding: [5, 7, 5, 7],
+        backgroundColor: "auto",
+        borderColor: null,
+        borderWidth: 0,
+        borderRadius: 3
+      },
+      handle: {
+        show: !1,
+        // eslint-disable-next-line
+        icon: "M10.7,11.9v-1.3H9.3v1.3c-4.9,0.3-8.8,4.4-8.8,9.4c0,5,3.9,9.1,8.8,9.4h1.3c4.9-0.3,8.8-4.4,8.8-9.4C19.5,16.3,15.6,12.2,10.7,11.9z M13.3,24.4H6.7v-1.2h6.6z M13.3,22H6.7v-1.2h6.6z M13.3,19.6H6.7v-1.2h6.6z",
+        size: 45,
+        // handle margin is from symbol center to axis, which is stable when circular move.
+        margin: 50,
+        // color: '#1b8bbd'
+        // color: '#2f4554'
+        color: "#333",
+        shadowBlur: 3,
+        shadowColor: "#aaa",
+        shadowOffsetX: 0,
+        shadowOffsetY: 2,
+        // For mobile performance
+        throttle: 40
+      }
+    }, o;
+  })(a)
+);
+export {
+  n as default
+};

package/dist/node_modules/echarts/lib/component/axisPointer/AxisPointerView.js

@@ -0,0 +1,31 @@
+import { __extends as m } from "../../../../tslib/tslib.es6.js";
+import { register as g, unregister as f } from "./globalListener.js";
+import u from "../../view/Component.js";
+var y = (
+  /** @class */
+  (function(n) {
+    m(t, n);
+    function t() {
+      var e = n !== null && n.apply(this, arguments) || this;
+      return e.type = t.type, e;
+    }
+    return t.prototype.render = function(e, o, a) {
+      var p = o.getComponent("tooltip"), s = e.get("triggerOn") || p && p.get("triggerOn") || "mousemove|click";
+      g("axisPointer", a, function(r, i, l) {
+        s !== "none" && (r === "leave" || s.indexOf(r) >= 0) && l({
+          type: "updateAxisPointer",
+          currTrigger: r,
+          x: i && i.offsetX,
+          y: i && i.offsetY
+        });
+      });
+    }, t.prototype.remove = function(e, o) {
+      f("axisPointer", o);
+    }, t.prototype.dispose = function(e, o) {
+      f("axisPointer", o);
+    }, t.type = "axisPointer", t;
+  })(u)
+);
+export {
+  y as default
+};

package/dist/node_modules/echarts/lib/component/axisPointer/BaseAxisPointer.js

@@ -0,0 +1,185 @@
+import { curry as E, clone as x, bind as H, isArray as P, isObject as v, each as w } from "../../../../zrender/lib/core/util.js";
+import * as z from "../../util/graphic.js";
+import { createIcon as S } from "../../util/graphic.js";
+import { getAxisInfo as T } from "./modelHelper.js";
+import { stop as M } from "../../../../zrender/lib/core/event.js";
+import { createOrUpdate as I, clear as D } from "../../util/throttle.js";
+import { makeInner as L } from "../../util/model.js";
+import V from "../../../../zrender/lib/graphic/Group.js";
+import C from "../../../../zrender/lib/graphic/Text.js";
+import { updateProps as K } from "../../animation/basicTransition.js";
+var u = L(), _ = x, p = H, Y = (
+  /** @class */
+  (function() {
+    function r() {
+      this._dragging = !1, this.animationThreshold = 15;
+    }
+    return r.prototype.render = function(e, t, a, i) {
+      var o = t.get("value"), l = t.get("status");
+      if (this._axisModel = e, this._axisPointerModel = t, this._api = a, !(!i && this._lastValue === o && this._lastStatus === l)) {
+        this._lastValue = o, this._lastStatus = l;
+        var n = this._group, s = this._handle;
+        if (!l || l === "hide") {
+          n && n.hide(), s && s.hide();
+          return;
+        }
+        n && n.show(), s && s.show();
+        var h = {};
+        this.makeElOption(h, o, e, t, a);
+        var f = h.graphicKey;
+        f !== this._lastGraphicKey && this.clear(a), this._lastGraphicKey = f;
+        var A = this._moveAnimation = this.determineAnimation(e, t);
+        if (!n)
+          n = this._group = new V(), this.createPointerEl(n, h, e, t), this.createLabelEl(n, h, e, t), a.getZr().add(n);
+        else {
+          var c = E(g, t, A);
+          this.updatePointerEl(n, h, c), this.updateLabelEl(n, h, c, t);
+        }
+        y(n, t, !0), this._renderHandle(o);
+      }
+    }, r.prototype.remove = function(e) {
+      this.clear(e);
+    }, r.prototype.dispose = function(e) {
+      this.clear(e);
+    }, r.prototype.determineAnimation = function(e, t) {
+      var a = t.get("animation"), i = e.axis, o = i.type === "category", l = t.get("snap");
+      if (!l && !o)
+        return !1;
+      if (a === "auto" || a == null) {
+        var n = this.animationThreshold;
+        if (o && i.getBandWidth() > n)
+          return !0;
+        if (l) {
+          var s = T(e).seriesDataCount, h = i.getExtent();
+          return Math.abs(h[0] - h[1]) / s > n;
+        }
+        return !1;
+      }
+      return a === !0;
+    }, r.prototype.makeElOption = function(e, t, a, i, o) {
+    }, r.prototype.createPointerEl = function(e, t, a, i) {
+      var o = t.pointer;
+      if (o) {
+        var l = u(e).pointerEl = new z[o.type](_(t.pointer));
+        e.add(l);
+      }
+    }, r.prototype.createLabelEl = function(e, t, a, i) {
+      if (t.label) {
+        var o = u(e).labelEl = new C(_(t.label));
+        e.add(o), m(o, i);
+      }
+    }, r.prototype.updatePointerEl = function(e, t, a) {
+      var i = u(e).pointerEl;
+      i && t.pointer && (i.setStyle(t.pointer.style), a(i, {
+        shape: t.pointer.shape
+      }));
+    }, r.prototype.updateLabelEl = function(e, t, a, i) {
+      var o = u(e).labelEl;
+      o && (o.setStyle(t.label.style), a(o, {
+        // Consider text length change in vertical axis, animation should
+        // be used on shape, otherwise the effect will be weird.
+        // TODOTODO
+        // shape: elOption.label.shape,
+        x: t.label.x,
+        y: t.label.y
+      }), m(o, i));
+    }, r.prototype._renderHandle = function(e) {
+      if (!(this._dragging || !this.updateHandleTransform)) {
+        var t = this._axisPointerModel, a = this._api.getZr(), i = this._handle, o = t.getModel("handle"), l = t.get("status");
+        if (!o.get("show") || !l || l === "hide") {
+          i && a.remove(i), this._handle = null;
+          return;
+        }
+        var n;
+        this._handle || (n = !0, i = this._handle = S(o.get("icon"), {
+          cursor: "move",
+          draggable: !0,
+          onmousemove: function(h) {
+            M(h.event);
+          },
+          onmousedown: p(this._onHandleDragMove, this, 0, 0),
+          drift: p(this._onHandleDragMove, this),
+          ondragend: p(this._onHandleDragEnd, this)
+        }), a.add(i)), y(i, t, !1), i.setStyle(o.getItemStyle(null, ["color", "borderColor", "borderWidth", "opacity", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY"]));
+        var s = o.get("size");
+        P(s) || (s = [s, s]), i.scaleX = s[0] / 2, i.scaleY = s[1] / 2, I(this, "_doDispatchAxisPointer", o.get("throttle") || 0, "fixRate"), this._moveHandleToValue(e, n);
+      }
+    }, r.prototype._moveHandleToValue = function(e, t) {
+      g(this._axisPointerModel, !t && this._moveAnimation, this._handle, d(this.getHandleTransform(e, this._axisModel, this._axisPointerModel)));
+    }, r.prototype._onHandleDragMove = function(e, t) {
+      var a = this._handle;
+      if (a) {
+        this._dragging = !0;
+        var i = this.updateHandleTransform(d(a), [e, t], this._axisModel, this._axisPointerModel);
+        this._payloadInfo = i, a.stopAnimation(), a.attr(d(i)), u(a).lastProp = null, this._doDispatchAxisPointer();
+      }
+    }, r.prototype._doDispatchAxisPointer = function() {
+      var e = this._handle;
+      if (e) {
+        var t = this._payloadInfo, a = this._axisModel;
+        this._api.dispatchAction({
+          type: "updateAxisPointer",
+          x: t.cursorPoint[0],
+          y: t.cursorPoint[1],
+          tooltipOption: t.tooltipOption,
+          axesInfo: [{
+            axisDim: a.axis.dim,
+            axisIndex: a.componentIndex
+          }]
+        });
+      }
+    }, r.prototype._onHandleDragEnd = function() {
+      this._dragging = !1;
+      var e = this._handle;
+      if (e) {
+        var t = this._axisPointerModel.get("value");
+        this._moveHandleToValue(t), this._api.dispatchAction({
+          type: "hideTip"
+        });
+      }
+    }, r.prototype.clear = function(e) {
+      this._lastValue = null, this._lastStatus = null;
+      var t = e.getZr(), a = this._group, i = this._handle;
+      t && a && (this._lastGraphicKey = null, a && t.remove(a), i && t.remove(i), this._group = null, this._handle = null, this._payloadInfo = null), D(this, "_doDispatchAxisPointer");
+    }, r.prototype.doClear = function() {
+    }, r.prototype.buildLabel = function(e, t, a) {
+      return a = a || 0, {
+        x: e[a],
+        y: e[1 - a],
+        width: t[a],
+        height: t[1 - a]
+      };
+    }, r;
+  })()
+);
+function g(r, e, t, a) {
+  b(u(t).lastProp, a) || (u(t).lastProp = a, e ? K(t, a, r) : (t.stopAnimation(), t.attr(a)));
+}
+function b(r, e) {
+  if (v(r) && v(e)) {
+    var t = !0;
+    return w(e, function(a, i) {
+      t = t && b(r[i], a);
+    }), !!t;
+  } else
+    return r === e;
+}
+function m(r, e) {
+  r[e.get(["label", "show"]) ? "show" : "hide"]();
+}
+function d(r) {
+  return {
+    x: r.x || 0,
+    y: r.y || 0,
+    rotation: r.rotation || 0
+  };
+}
+function y(r, e, t) {
+  var a = e.get("z"), i = e.get("zlevel");
+  r && r.traverse(function(o) {
+    o.type !== "group" && (a != null && (o.z = a), i != null && (o.zlevel = i), o.silent = t);
+  });
+}
+export {
+  Y as default
+};

package/dist/node_modules/echarts/lib/component/axisPointer/CartesianAxisPointer.js

@@ -0,0 +1,85 @@
+import { __extends as h } from "../../../../tslib/tslib.es6.js";
+import y from "./BaseAxisPointer.js";
+import { buildElStyle as b, buildCartesianSingleLabelElOption as P, getTransformedPosition as A, makeRectShape as C, makeLineShape as I } from "./viewHelper.js";
+import { layout as x } from "../../coord/cartesian/cartesianAxisHelper.js";
+var k = (
+  /** @class */
+  (function(e) {
+    h(r, e);
+    function r() {
+      return e !== null && e.apply(this, arguments) || this;
+    }
+    return r.prototype.makeElOption = function(t, a, l, s, n) {
+      var u = l.axis, g = u.grid, d = s.get("type"), i = c(g, u).getOtherAxis(u).getGlobalExtent(), o = u.toGlobalCoord(u.dataToCoord(a, !0));
+      if (d && d !== "none") {
+        var m = b(s), p = E[d](u, o, i);
+        p.style = m, t.graphicKey = p.type, t.pointer = p;
+      }
+      var v = x(g.model, l);
+      P(
+        // @ts-ignore
+        a,
+        t,
+        v,
+        l,
+        s,
+        n
+      );
+    }, r.prototype.getHandleTransform = function(t, a, l) {
+      var s = x(a.axis.grid.model, a, {
+        labelInside: !1
+      });
+      s.labelMargin = l.get(["handle", "margin"]);
+      var n = A(a.axis, t, s);
+      return {
+        x: n[0],
+        y: n[1],
+        rotation: s.rotation + (s.labelDirection < 0 ? Math.PI : 0)
+      };
+    }, r.prototype.updateHandleTransform = function(t, a, l, s) {
+      var n = l.axis, u = n.grid, g = n.getGlobalExtent(!0), d = c(u, n).getOtherAxis(n).getGlobalExtent(), i = n.dim === "x" ? 0 : 1, o = [t.x, t.y];
+      o[i] += a[i], o[i] = Math.min(g[1], o[i]), o[i] = Math.max(g[0], o[i]);
+      var m = (d[1] + d[0]) / 2, p = [m, m];
+      p[i] = o[i];
+      var v = [{
+        verticalAlign: "middle"
+      }, {
+        align: "center"
+      }];
+      return {
+        x: o[0],
+        y: o[1],
+        rotation: t.rotation,
+        cursorPoint: p,
+        tooltipOption: v[i]
+      };
+    }, r;
+  })(y)
+);
+function c(e, r) {
+  var t = {};
+  return t[r.dim + "AxisIndex"] = r.index, e.getCartesian(t);
+}
+var E = {
+  line: function(e, r, t) {
+    var a = I([r, t[0]], [r, t[1]], f(e));
+    return {
+      type: "Line",
+      subPixelOptimize: !0,
+      shape: a
+    };
+  },
+  shadow: function(e, r, t) {
+    var a = Math.max(1, e.getBandWidth()), l = t[1] - t[0];
+    return {
+      type: "Rect",
+      shape: C([r - a / 2, t[0]], [a, l], f(e))
+    };
+  }
+};
+function f(e) {
+  return e.dim === "x" ? 0 : 1;
+}
+export {
+  k as default
+};

package/dist/node_modules/echarts/lib/component/axisPointer/PolarAxisPointer.js

@@ -0,0 +1,83 @@
+import { __extends as u } from "../../../../tslib/tslib.es6.js";
+import A from "./BaseAxisPointer.js";
+import { applyTransform as P } from "../../util/graphic.js";
+import { buildElStyle as b, buildLabelElOption as T, makeSectorShape as f, makeLineShape as S } from "./viewHelper.js";
+import { rotate as E, create as I, translate as L } from "../../../../zrender/lib/core/matrix.js";
+import B from "../axis/AxisBuilder.js";
+var q = (
+  /** @class */
+  (function(n) {
+    u(t, n);
+    function t() {
+      return n !== null && n.apply(this, arguments) || this;
+    }
+    return t.prototype.makeElOption = function(a, e, i, r, d) {
+      var o = i.axis;
+      o.dim === "angle" && (this.animationThreshold = Math.PI / 18);
+      var c = o.polar, s = c.getOtherAxis(o), h = s.getExtent(), m = o.dataToCoord(e), v = r.get("type");
+      if (v && v !== "none") {
+        var y = b(r), g = C[v](o, c, m, h);
+        g.style = y, a.graphicKey = g.type, a.pointer = g;
+      }
+      var x = r.get(["label", "margin"]), l = k(e, i, r, c, x);
+      T(a, i, r, d, l);
+    }, t;
+  })(A)
+);
+function k(n, t, a, e, i) {
+  var r = t.axis, d = r.dataToCoord(n), o = e.getAngleAxis().getExtent()[0];
+  o = o / 180 * Math.PI;
+  var c = e.getRadiusAxis().getExtent(), s, h, m;
+  if (r.dim === "radius") {
+    var v = I();
+    E(v, v, o), L(v, v, [e.cx, e.cy]), s = P([d, -i], v);
+    var y = t.getModel("axisLabel").get("rotate") || 0, g = B.innerTextLayout(o, y * Math.PI / 180, -1);
+    h = g.textAlign, m = g.textVerticalAlign;
+  } else {
+    var x = c[1];
+    s = e.coordToPoint([x + i, d]);
+    var l = e.cx, p = e.cy;
+    h = Math.abs(s[0] - l) / x < 0.3 ? "center" : s[0] > l ? "left" : "right", m = Math.abs(s[1] - p) / x < 0.3 ? "middle" : s[1] > p ? "top" : "bottom";
+  }
+  return {
+    position: s,
+    align: h,
+    verticalAlign: m
+  };
+}
+var C = {
+  line: function(n, t, a, e) {
+    return n.dim === "angle" ? {
+      type: "Line",
+      shape: S(t.coordToPoint([e[0], a]), t.coordToPoint([e[1], a]))
+    } : {
+      type: "Circle",
+      shape: {
+        cx: t.cx,
+        cy: t.cy,
+        r: a
+      }
+    };
+  },
+  shadow: function(n, t, a, e) {
+    var i = Math.max(1, n.getBandWidth()), r = Math.PI / 180;
+    return n.dim === "angle" ? {
+      type: "Sector",
+      shape: f(
+        t.cx,
+        t.cy,
+        e[0],
+        e[1],
+        // In ECharts y is negative if angle is positive
+        (-a - i / 2) * r,
+        (-a + i / 2) * r
+      )
+    } : {
+      type: "Sector",
+      shape: f(t.cx, t.cy, a - i / 2, a + i / 2, 0, Math.PI * 2)
+    };
+  }
+};
+export {
+  q as default
+};

package/dist/node_modules/echarts/lib/component/axisPointer/SingleAxisPointer.js

@@ -0,0 +1,80 @@
+import { __extends as x } from "../../../../tslib/tslib.es6.js";
+import S from "./BaseAxisPointer.js";
+import { buildElStyle as P, buildCartesianSingleLabelElOption as b, getTransformedPosition as T, makeRectShape as A, makeLineShape as E } from "./viewHelper.js";
+import { layout as f } from "../../coord/single/singleAxisHelper.js";
+var h = ["x", "y"], H = ["width", "height"], W = (
+  /** @class */
+  (function(e) {
+    x(r, e);
+    function r() {
+      return e !== null && e.apply(this, arguments) || this;
+    }
+    return r.prototype.makeElOption = function(t, n, o, l, u) {
+      var s = o.axis, a = s.coordinateSystem, c = d(a, 1 - m(s)), i = a.dataToPoint(n)[0], p = l.get("type");
+      if (p && p !== "none") {
+        var y = P(l), v = I[p](s, i, c);
+        v.style = y, t.graphicKey = v.type, t.pointer = v;
+      }
+      var g = f(o);
+      b(
+        // @ts-ignore
+        n,
+        t,
+        g,
+        o,
+        l,
+        u
+      );
+    }, r.prototype.getHandleTransform = function(t, n, o) {
+      var l = f(n, {
+        labelInside: !1
+      });
+      l.labelMargin = o.get(["handle", "margin"]);
+      var u = T(n.axis, t, l);
+      return {
+        x: u[0],
+        y: u[1],
+        rotation: l.rotation + (l.labelDirection < 0 ? Math.PI : 0)
+      };
+    }, r.prototype.updateHandleTransform = function(t, n, o, l) {
+      var u = o.axis, s = u.coordinateSystem, a = m(u), c = d(s, a), i = [t.x, t.y];
+      i[a] += n[a], i[a] = Math.min(c[1], i[a]), i[a] = Math.max(c[0], i[a]);
+      var p = d(s, 1 - a), y = (p[1] + p[0]) / 2, v = [y, y];
+      return v[a] = i[a], {
+        x: i[0],
+        y: i[1],
+        rotation: t.rotation,
+        cursorPoint: v,
+        tooltipOption: {
+          verticalAlign: "middle"
+        }
+      };
+    }, r;
+  })(S)
+), I = {
+  line: function(e, r, t) {
+    var n = E([r, t[0]], [r, t[1]], m(e));
+    return {
+      type: "Line",
+      subPixelOptimize: !0,
+      shape: n
+    };
+  },
+  shadow: function(e, r, t) {
+    var n = e.getBandWidth(), o = t[1] - t[0];
+    return {
+      type: "Rect",
+      shape: A([r - n / 2, t[0]], [n, o], m(e))
+    };
+  }
+};
+function m(e) {
+  return e.isHorizontal() ? 0 : 1;
+}
+function d(e, r) {
+  var t = e.getRect();
+  return [t[h[r]], t[h[r]] + t[H[r]]];
+}
+export {
+  W as default
+};