yahee-components 0.0.70 → 0.0.72

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/CartesianAxisPointer.js

@@ -0,0 +1,77 @@
+import { __extends as h } from "../../../../../../tslib@2.3.0/node_modules/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 m } from "../../coord/cartesian/cartesianAxisHelper.js";
+var R = (
+  /** @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, p = s.get("type"), i = c(g, u).getOtherAxis(u).getGlobalExtent(), o = u.toGlobalCoord(u.dataToCoord(a, !0));
+      if (p && p !== "none") {
+        var v = b(s), d = E[p](u, o, i);
+        d.style = v, t.graphicKey = d.type, t.pointer = d;
+      }
+      var x = m(g.getRect(), l);
+      P(a, t, x, l, s, n);
+    }, r.prototype.getHandleTransform = function(t, a, l) {
+      var s = m(a.axis.grid.getRect(), 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), p = 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 v = (p[1] + p[0]) / 2, d = [v, v];
+      d[i] = o[i];
+      var x = [{
+        verticalAlign: "middle"
+      }, {
+        align: "center"
+      }];
+      return {
+        x: o[0],
+        y: o[1],
+        rotation: t.rotation,
+        cursorPoint: d,
+        tooltipOption: x[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 {
+  R as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/PolarAxisPointer.js

@@ -0,0 +1,83 @@
+import { __extends as u } from "../../../../../../tslib@2.3.0/node_modules/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@6.0.0/node_modules/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/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/SingleAxisPointer.js

@@ -0,0 +1,72 @@
+import { __extends as x } from "../../../../../../tslib@2.3.0/node_modules/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(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
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/axisTrigger.js

@@ -0,0 +1,203 @@
+import { makeInner as H } from "../../util/model.js";
+import { makeKey as b } from "./modelHelper.js";
+import O from "./findPointFromSeries.js";
+import { bind as V, curry as S, each as p, extend as C } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+var B = H();
+function j(e, i, a) {
+  var n = e.currTrigger, t = [e.x, e.y], d = e, r = e.dispatchAction || V(a.dispatchAction, a), s = i.getComponent("axisPointer").coordSysAxesInfo;
+  if (s) {
+    w(t) && (t = O({
+      seriesIndex: d.seriesIndex,
+      // Do not use dataIndexInside from other ec instance.
+      // FIXME: auto detect it?
+      dataIndex: d.dataIndex
+    }, i).point);
+    var o = w(t), u = d.axesInfo, l = s.axesInfo, v = n === "leave" || w(t), c = {}, x = {}, f = {
+      list: [],
+      map: {}
+    }, y = {
+      showPointer: S(L, x),
+      showTooltip: S(E, f)
+    };
+    p(s.coordSysMap, function(h, T) {
+      var g = o || h.containPoint(t);
+      p(s.coordSysAxesInfo[T], function(I, M) {
+        var A = I.axis, m = R(u, I);
+        if (!v && g && (!u || m)) {
+          var P = m && m.value;
+          P == null && !o && (P = A.pointToData(t)), P != null && k(I, P, y, !1, c);
+        }
+      });
+    });
+    var D = {};
+    return p(l, function(h, T) {
+      var g = h.linkGroup;
+      g && !x[T] && p(g.axesInfo, function(I, M) {
+        var A = x[M];
+        if (I !== h && A) {
+          var m = A.value;
+          g.mapper && (m = h.axis.scale.parse(g.mapper(m, N(I), N(h)))), D[h.key] = m;
+        }
+      });
+    }), p(D, function(h, T) {
+      k(l[T], h, y, !0, c);
+    }), G(x, l, c), z(f, t, e, r), F(l, r, a), c;
+  }
+}
+function k(e, i, a, n, t) {
+  var d = e.axis;
+  if (!(d.scale.isBlank() || !d.containData(i))) {
+    if (!e.involveSeries) {
+      a.showPointer(e, i);
+      return;
+    }
+    var r = K(i, e), s = r.payloadBatch, o = r.snapToValue;
+    s[0] && t.seriesIndex == null && C(t, s[0]), !n && e.snap && d.containData(o) && o != null && (i = o), a.showPointer(e, i, s), a.showTooltip(e, r, o);
+  }
+}
+function K(e, i) {
+  var a = i.axis, n = a.dim, t = e, d = [], r = Number.MAX_VALUE, s = -1;
+  return p(i.seriesModels, function(o, u) {
+    var l = o.getData().mapDimensionsAll(n), v, c;
+    if (o.getAxisTooltipData) {
+      var x = o.getAxisTooltipData(l, e, a);
+      c = x.dataIndices, v = x.nestestValue;
+    } else {
+      if (c = o.indicesOfNearest(
+        n,
+        l[0],
+        e,
+        // Add a threshold to avoid find the wrong dataIndex
+        // when data length is not same.
+        // false,
+        a.type === "category" ? 0.5 : null
+      ), !c.length)
+        return;
+      v = o.getData().get(l[0], c[0]);
+    }
+    if (!(v == null || !isFinite(v))) {
+      var f = e - v, y = Math.abs(f);
+      y <= r && ((y < r || f >= 0 && s < 0) && (r = y, s = f, t = v, d.length = 0), p(c, function(D) {
+        d.push({
+          seriesIndex: o.seriesIndex,
+          dataIndexInside: D,
+          dataIndex: o.getData().getRawIndex(D)
+        });
+      }));
+    }
+  }), {
+    payloadBatch: d,
+    snapToValue: t
+  };
+}
+function L(e, i, a, n) {
+  e[i.key] = {
+    value: a,
+    payloadBatch: n
+  };
+}
+function E(e, i, a, n) {
+  var t = a.payloadBatch, d = i.axis, r = d.model, s = i.axisPointerModel;
+  if (!(!i.triggerTooltip || !t.length)) {
+    var o = i.coordSys.model, u = b(o), l = e.map[u];
+    l || (l = e.map[u] = {
+      coordSysId: o.id,
+      coordSysIndex: o.componentIndex,
+      coordSysType: o.type,
+      coordSysMainType: o.mainType,
+      dataByAxis: []
+    }, e.list.push(l)), l.dataByAxis.push({
+      axisDim: d.dim,
+      axisIndex: r.componentIndex,
+      axisType: r.type,
+      axisId: r.id,
+      value: n,
+      // Caustion: viewHelper.getValueLabel is actually on "view stage", which
+      // depends that all models have been updated. So it should not be performed
+      // here. Considering axisPointerModel used here is volatile, which is hard
+      // to be retrieve in TooltipView, we prepare parameters here.
+      valueLabelOpt: {
+        precision: s.get(["label", "precision"]),
+        formatter: s.get(["label", "formatter"])
+      },
+      seriesDataIndices: t.slice()
+    });
+  }
+}
+function G(e, i, a) {
+  var n = a.axesInfo = [];
+  p(i, function(t, d) {
+    var r = t.axisPointerModel.option, s = e[d];
+    s ? (!t.useHandle && (r.status = "show"), r.value = s.value, r.seriesDataIndices = (s.payloadBatch || []).slice()) : !t.useHandle && (r.status = "hide"), r.status === "show" && n.push({
+      axisDim: t.axis.dim,
+      axisIndex: t.axis.model.componentIndex,
+      value: r.value
+    });
+  });
+}
+function z(e, i, a, n) {
+  if (w(i) || !e.list.length) {
+    n({
+      type: "hideTip"
+    });
+    return;
+  }
+  var t = ((e.list[0].dataByAxis[0] || {}).seriesDataIndices || [])[0] || {};
+  n({
+    type: "showTip",
+    escapeConnect: !0,
+    x: i[0],
+    y: i[1],
+    tooltipOption: a.tooltipOption,
+    position: a.position,
+    dataIndexInside: t.dataIndexInside,
+    dataIndex: t.dataIndex,
+    seriesIndex: t.seriesIndex,
+    dataByCoordSys: e.list
+  });
+}
+function F(e, i, a) {
+  var n = a.getZr(), t = "axisPointerLastHighlights", d = B(n)[t] || {}, r = B(n)[t] = {};
+  p(e, function(u, l) {
+    var v = u.axisPointerModel.option;
+    v.status === "show" && u.triggerEmphasis && p(v.seriesDataIndices, function(c) {
+      var x = c.seriesIndex + " | " + c.dataIndex;
+      r[x] = c;
+    });
+  });
+  var s = [], o = [];
+  p(d, function(u, l) {
+    !r[l] && o.push(u);
+  }), p(r, function(u, l) {
+    !d[l] && s.push(u);
+  }), o.length && a.dispatchAction({
+    type: "downplay",
+    escapeConnect: !0,
+    // Not blur others when highlight in axisPointer.
+    notBlur: !0,
+    batch: o
+  }), s.length && a.dispatchAction({
+    type: "highlight",
+    escapeConnect: !0,
+    // Not blur others when highlight in axisPointer.
+    notBlur: !0,
+    batch: s
+  });
+}
+function R(e, i) {
+  for (var a = 0; a < (e || []).length; a++) {
+    var n = e[a];
+    if (i.axis.dim === n.axisDim && i.axis.model.componentIndex === n.axisIndex)
+      return n;
+  }
+}
+function N(e) {
+  var i = e.axis.model, a = {}, n = a.axisDim = e.axis.dim;
+  return a.axisIndex = a[n + "AxisIndex"] = i.componentIndex, a.axisName = a[n + "AxisName"] = i.name, a.axisId = a[n + "AxisId"] = i.id, a;
+}
+function w(e) {
+  return !e || e[0] == null || isNaN(e[0]) || e[1] == null || isNaN(e[1]);
+}
+export {
+  j as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/findPointFromSeries.js

@@ -0,0 +1,36 @@
+import { isArray as I, map as P } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { queryDataIndex as T } from "../../util/model.js";
+function c(s, u) {
+  var o = [], d = s.seriesIndex, n;
+  if (d == null || !(n = u.getSeriesByIndex(d)))
+    return {
+      point: []
+    };
+  var e = n.getData(), i = T(e, s);
+  if (i == null || i < 0 || I(i))
+    return {
+      point: []
+    };
+  var a = e.getItemGraphicEl(i), t = n.coordinateSystem;
+  if (n.getTooltipPosition)
+    o = n.getTooltipPosition(i) || [];
+  else if (t && t.dataToPoint)
+    if (s.isStacked) {
+      var m = t.getBaseAxis(), v = t.getOtherAxis(m), p = v.dim, f = m.dim, g = p === "x" || p === "radius" ? 1 : 0, x = e.mapDimension(f), l = [];
+      l[g] = e.get(x, i), l[1 - g] = e.get(e.getCalculationInfo("stackResultDimension"), i), o = t.dataToPoint(l) || [];
+    } else
+      o = t.dataToPoint(e.getValues(P(t.dimensions, function(y) {
+        return e.mapDimension(y);
+      }), i)) || [];
+  else if (a) {
+    var r = a.getBoundingRect().clone();
+    r.applyTransform(a.transform), o = [r.x + r.width / 2, r.y + r.height / 2];
+  }
+  return {
+    point: o,
+    el: a
+  };
+}
+export {
+  c as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/globalListener.js

@@ -0,0 +1,58 @@
+import { curry as s, each as l } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import u from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/env.js";
+import { makeInner as f } from "../../util/model.js";
+var o = f(), p = l;
+function b(i, r, e) {
+  if (!u.node) {
+    var n = r.getZr();
+    o(n).records || (o(n).records = {}), v(n, r);
+    var t = o(n).records[i] || (o(n).records[i] = {});
+    t.handler = e;
+  }
+}
+function v(i, r) {
+  if (o(i).initialized)
+    return;
+  o(i).initialized = !0, e("click", s(d, "click")), e("mousemove", s(d, "mousemove")), e("globalout", g);
+  function e(n, t) {
+    i.on(n, function(h) {
+      var c = A(r);
+      p(o(i).records, function(a) {
+        a && t(a, h, c.dispatchAction);
+      }), m(c.pendings, r);
+    });
+  }
+}
+function m(i, r) {
+  var e = i.showTip.length, n = i.hideTip.length, t;
+  e ? t = i.showTip[e - 1] : n && (t = i.hideTip[n - 1]), t && (t.dispatchAction = null, r.dispatchAction(t));
+}
+function g(i, r, e) {
+  i.handler("leave", null, e);
+}
+function d(i, r, e, n) {
+  r.handler(i, e, n);
+}
+function A(i) {
+  var r = {
+    showTip: [],
+    hideTip: []
+  }, e = function(n) {
+    var t = r[n.type];
+    t ? t.push(n) : (n.dispatchAction = e, i.dispatchAction(n));
+  };
+  return {
+    dispatchAction: e,
+    pendings: r
+  };
+}
+function k(i, r) {
+  if (!u.node) {
+    var e = r.getZr(), n = (o(e).records || {})[i];
+    n && (o(e).records[i] = null);
+  }
+}
+export {
+  b as register,
+  k as unregister
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/install.js

@@ -0,0 +1,25 @@
+import o from "../axis/AxisView.js";
+import t from "./CartesianAxisPointer.js";
+import n from "./AxisPointerModel.js";
+import s from "./AxisPointerView.js";
+import { isArray as a } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { collect as x } from "./modelHelper.js";
+import P from "./axisTrigger.js";
+function u(r) {
+  o.registerAxisPointerClass("CartesianAxisPointer", t), r.registerComponentModel(n), r.registerComponentView(s), r.registerPreprocessor(function(i) {
+    if (i) {
+      (!i.axisPointer || i.axisPointer.length === 0) && (i.axisPointer = {});
+      var e = i.axisPointer.link;
+      e && !a(e) && (i.axisPointer.link = [e]);
+    }
+  }), r.registerProcessor(r.PRIORITY.PROCESSOR.STATISTIC, function(i, e) {
+    i.getComponent("axisPointer").coordSysAxesInfo = x(i, e);
+  }), r.registerAction({
+    type: "updateAxisPointer",
+    event: "updateAxisPointer",
+    update: ":updateAxisPointer"
+  }, P);
+}
+export {
+  u as install
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/modelHelper.js

@@ -0,0 +1,137 @@
+import G from "../../model/Model.js";
+import { each as g, curry as M, clone as U, defaults as z, isArray as B, indexOf as L } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+function Q(e, t) {
+  var o = {
+    /**
+     * key: makeKey(axis.model)
+     * value: {
+     *      axis,
+     *      coordSys,
+     *      axisPointerModel,
+     *      triggerTooltip,
+     *      triggerEmphasis,
+     *      involveSeries,
+     *      snap,
+     *      seriesModels,
+     *      seriesDataCount
+     * }
+     */
+    axesInfo: {},
+    seriesInvolved: !1,
+    /**
+     * key: makeKey(coordSys.model)
+     * value: Object: key makeKey(axis.model), value: axisInfo
+     */
+    coordSysAxesInfo: {},
+    coordSysMap: {}
+  };
+  return N(o, e, t), o.seriesInvolved && j(o, e), o;
+}
+function N(e, t, o) {
+  var i = t.getComponent("tooltip"), a = t.getComponent("axisPointer"), l = a.get("link", !0) || [], n = [];
+  g(o.getCoordinateSystems(), function(s) {
+    if (!s.axisPointerEnabled)
+      return;
+    var r = h(s.model), u = e.coordSysAxesInfo[r] = {};
+    e.coordSysMap[r] = s;
+    var p = s.model, f = p.getModel("tooltip", i);
+    if (g(s.getAxes(), M(A, !1, null)), s.getTooltipAxes && i && f.get("show")) {
+      var x = f.get("trigger") === "axis", I = f.get(["axisPointer", "type"]) === "cross", E = s.getTooltipAxes(f.get(["axisPointer", "axis"]));
+      (x || I) && g(E.baseAxes, M(A, I ? "cross" : !0, x)), I && g(E.otherAxes, M(A, "cross", !1));
+    }
+    function A(S, c, d) {
+      var v = d.model.getModel("axisPointer", a), D = v.get("show");
+      if (!(!D || D === "auto" && !S && !C(v))) {
+        c == null && (c = v.get("triggerTooltip")), v = S ? O(d, f, a, t, S, c) : v;
+        var k = v.get("snap"), K = v.get("triggerEmphasis"), m = h(d.model), T = c || k || d.type === "category", P = e.axesInfo[m] = {
+          key: m,
+          axis: d,
+          coordSys: s,
+          axisPointerModel: v,
+          triggerTooltip: c,
+          triggerEmphasis: K,
+          involveSeries: T,
+          snap: k,
+          useHandle: C(v),
+          seriesModels: [],
+          linkGroup: null
+        };
+        u[m] = P, e.seriesInvolved = e.seriesInvolved || T;
+        var y = q(l, d);
+        if (y != null) {
+          var w = n[y] || (n[y] = {
+            axesInfo: {}
+          });
+          w.axesInfo[m] = P, w.mapper = l[y].mapper, P.linkGroup = w;
+        }
+      }
+    }
+  });
+}
+function O(e, t, o, i, a, l) {
+  var n = t.getModel("axisPointer"), s = ["type", "snap", "lineStyle", "shadowStyle", "label", "animation", "animationDurationUpdate", "animationEasingUpdate", "z"], r = {};
+  g(s, function(x) {
+    r[x] = U(n.get(x));
+  }), r.snap = e.type !== "category" && !!l, n.get("type") === "cross" && (r.type = "line");
+  var u = r.label || (r.label = {});
+  if (u.show == null && (u.show = !1), a === "cross") {
+    var p = n.get(["label", "show"]);
+    if (u.show = p ?? !0, !l) {
+      var f = r.lineStyle = n.get("crossStyle");
+      f && z(u, f.textStyle);
+    }
+  }
+  return e.model.getModel("axisPointer", new G(r, o, i));
+}
+function j(e, t) {
+  t.eachSeries(function(o) {
+    var i = o.coordinateSystem, a = o.get(["tooltip", "trigger"], !0), l = o.get(["tooltip", "show"], !0);
+    !i || !i.model || a === "none" || a === !1 || a === "item" || l === !1 || o.get(["axisPointer", "show"], !0) === !1 || g(e.coordSysAxesInfo[h(i.model)], function(n) {
+      var s = n.axis;
+      i.getAxis(s.dim) === s && (n.seriesModels.push(o), n.seriesDataCount == null && (n.seriesDataCount = 0), n.seriesDataCount += o.getData().count());
+    });
+  });
+}
+function q(e, t) {
+  for (var o = t.model, i = t.dim, a = 0; a < e.length; a++) {
+    var l = e[a] || {};
+    if (b(l[i + "AxisId"], o.id) || b(l[i + "AxisIndex"], o.componentIndex) || b(l[i + "AxisName"], o.name))
+      return a;
+  }
+}
+function b(e, t) {
+  return e === "all" || B(e) && L(e, t) >= 0 || e === t;
+}
+function R(e) {
+  var t = H(e);
+  if (t) {
+    var o = t.axisPointerModel, i = t.axis.scale, a = o.option, l = o.get("status"), n = o.get("value");
+    n != null && (n = i.parse(n));
+    var s = C(o);
+    l == null && (a.status = s ? "show" : "hide");
+    var r = i.getExtent().slice();
+    r[0] > r[1] && r.reverse(), // Pick a value on axis when initializing.
+    (n == null || n > r[1]) && (n = r[1]), n < r[0] && (n = r[0]), a.value = n, s && (a.status = t.axis.scale.isBlank() ? "hide" : "show");
+  }
+}
+function H(e) {
+  var t = (e.ecModel.getComponent("axisPointer") || {}).coordSysAxesInfo;
+  return t && t.axesInfo[h(e)];
+}
+function W(e) {
+  var t = H(e);
+  return t && t.axisPointerModel;
+}
+function C(e) {
+  return !!e.get(["handle", "show"]);
+}
+function h(e) {
+  return e.type + "||" + e.id;
+}
+export {
+  Q as collect,
+  R as fixValue,
+  H as getAxisInfo,
+  W as getAxisPointerModel,
+  h as makeKey
+};