yahee-components 0.0.70 → 0.0.72

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axis/AxisBuilder.js

@@ -0,0 +1,553 @@
+import { assert as N, retrieve2 as E, retrieve3 as Se, each as V, retrieve as $, extend as ie, isString as ne, filter as Ne, defaults as ee, isObject as De, isFunction as Re, map as Be, isNumber as Ce } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { setTooltipConfig as fe, subPixelOptimizeLine as me } from "../../util/graphic.js";
+import { getECData as ce } from "../../util/innerStore.js";
+import { createTextStyle as pe } from "../../label/labelStyle.js";
+import Ve from "../../model/Model.js";
+import { remRadian as ge, isRadianAroundZero as K } from "../../util/number.js";
+import { normalizeSymbolOffset as Me, createSymbol as Ie } from "../../util/symbol.js";
+import { rotate as Ge, create as be, invert as Pe, identity as We, mul as ze } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/matrix.js";
+import { applyTransform as Z } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/vector.js";
+import { isNameLocationCenter as q, shouldShowAllLabels as Fe } from "../../coord/axisHelper.js";
+import { ensureLabelLayoutWithGeometry as R, computeLabelGeometry2 as He, hideOverlap as je, labelIntersect as Le, labelLayoutApplyTranslation as Ue, setLabelLayoutDirty as Xe, newLabelLayoutWithGeometry as oe } from "../../label/labelLayoutHelper.js";
+import { makeInner as he } from "../../util/model.js";
+import { getAxisBreakHelper as de } from "./axisBreakHelper.js";
+import { AXIS_BREAK_EXPAND_ACTION_TYPE as Ke } from "./axisAction.js";
+import { getScaleBreakHelper as Ze } from "../../scale/break.js";
+import W from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/BoundingRect.js";
+import F from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/Point.js";
+import { copyTransform as le } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/Transformable.js";
+import { createAxisLabelsComputingContext as qe, AxisTickLabelComputingKind as se } from "../../coord/axisTickLabelBuilder.js";
+import te from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Group.js";
+import xe from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Text.js";
+import ye from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Line.js";
+import ke from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Rect.js";
+var D = Math.PI, Ye = [[1, 2, 1, 2], [5, 3, 5, 3], [8, 3, 8, 3]], Je = [[0, 1, 0, 1], [0, 3, 0, 3], [0, 3, 0, 3]], H = he(), Te = he(), Qe = (
+  /** @class */
+  function() {
+    function t(a) {
+      this.recordMap = {}, this.resolveAxisNameOverlap = a;
+    }
+    return t.prototype.ensureRecord = function(a) {
+      var i = a.axis.dim, e = a.componentIndex, r = this.recordMap, n = r[i] || (r[i] = []);
+      return n[e] || (n[e] = {
+        ready: {}
+      });
+    }, t;
+  }()
+);
+function $e(t, a, i, e) {
+  var r = i.axis, n = a.ensureRecord(i), o = [], s, l = re(t.axisName) && q(t.nameLocation);
+  V(e, function(k) {
+    var g = R(k);
+    if (!(!g || g.label.ignore)) {
+      o.push(g);
+      var T = n.transGroup;
+      l && (T.transform ? Pe(P, T.transform) : We(P), g.transform && ze(P, P, g.transform), W.copy(X, g.localRect), X.applyTransform(P), s ? s.union(X) : W.copy(s = new W(0, 0, 0, 0), X));
+    }
+  });
+  var f = Math.abs(n.dirVec.x) > 0.1 ? "x" : "y", v = n.transGroup[f];
+  if (o.sort(function(k, g) {
+    return Math.abs(k.label[f] - v) - Math.abs(g.label[f] - v);
+  }), l && s) {
+    var u = r.getExtent(), c = Math.min(u[0], u[1]), p = Math.max(u[0], u[1]) - c;
+    s.union(new W(c, 0, p, 1));
+  }
+  n.stOccupiedRect = s, n.labelInfoList = o;
+}
+var P = be(), X = new W(0, 0, 0, 0), et = function(t, a, i, e, r, n) {
+  if (q(t.nameLocation)) {
+    var o = n.stOccupiedRect;
+    o && Ae(He({}, o, n.transGroup.transform), e, r);
+  } else
+    tt(n.labelInfoList, n.dirVec, e, r);
+};
+function Ae(t, a, i) {
+  var e = new F();
+  Le(t, a, e, {
+    direction: Math.atan2(i.y, i.x),
+    bidirectional: !1,
+    touchThreshold: 0.05
+  }) && Ue(a, e);
+}
+function tt(t, a, i, e) {
+  for (var r = F.dot(e, a) >= 0, n = 0, o = t.length; n < o; n++) {
+    var s = t[r ? n : o - 1 - n];
+    s.label.ignore || Ae(s, i, e);
+  }
+}
+var G = (
+  /** @class */
+  function() {
+    function t(a, i, e, r) {
+      this.group = new te(), this._axisModel = a, this._api = i, this._local = {}, this._shared = r || new Qe(et), this._resetCfgDetermined(e);
+    }
+    return t.prototype.updateCfg = function(a) {
+      if (process.env.NODE_ENV !== "production") {
+        var i = this._shared.ensureRecord(this._axisModel).ready;
+        N(!i.axisLine && !i.axisTickLabelDetermine), i.axisName = i.axisTickLabelEstimate = !1;
+      }
+      var e = this._cfg.raw;
+      e.position = a.position, e.labelOffset = a.labelOffset, this._resetCfgDetermined(e);
+    }, t.prototype.__getRawCfg = function() {
+      return this._cfg.raw;
+    }, t.prototype._resetCfgDetermined = function(a) {
+      var i = this._axisModel, e = i.getDefaultOption ? i.getDefaultOption() : {}, r = E(a.axisName, i.get("name")), n = i.get("nameMoveOverlap");
+      (n == null || n === "auto") && (n = E(a.defaultNameMoveOverlap, !0));
+      var o = {
+        raw: a,
+        position: a.position,
+        rotation: a.rotation,
+        nameDirection: E(a.nameDirection, 1),
+        tickDirection: E(a.tickDirection, 1),
+        labelDirection: E(a.labelDirection, 1),
+        labelOffset: E(a.labelOffset, 0),
+        silent: E(a.silent, !0),
+        axisName: r,
+        nameLocation: Se(i.get("nameLocation"), e.nameLocation, "end"),
+        shouldNameMoveOverlap: re(r) && n,
+        optionHideOverlap: i.get(["axisLabel", "hideOverlap"]),
+        showMinorTicks: i.get(["minorTick", "show"])
+      };
+      process.env.NODE_ENV !== "production" && (N(o.position != null), N(o.rotation != null)), this._cfg = o;
+      var s = new te({
+        x: o.position[0],
+        y: o.position[1],
+        rotation: o.rotation
+      });
+      s.updateTransform(), this._transformGroup = s;
+      var l = this._shared.ensureRecord(i);
+      l.transGroup = this._transformGroup, l.dirVec = new F(Math.cos(-o.rotation), Math.sin(-o.rotation));
+    }, t.prototype.build = function(a, i) {
+      var e = this;
+      return a || (a = {
+        axisLine: !0,
+        axisTickLabelEstimate: !1,
+        axisTickLabelDetermine: !0,
+        axisName: !0
+      }), V(at, function(r) {
+        a[r] && rt[r](e._cfg, e._local, e._shared, e._axisModel, e.group, e._transformGroup, e._api, i || {});
+      }), this;
+    }, t.innerTextLayout = function(a, i, e) {
+      var r = ge(i - a), n, o;
+      return K(r) ? (o = e > 0 ? "top" : "bottom", n = "center") : K(r - D) ? (o = e > 0 ? "bottom" : "top", n = "center") : (o = "middle", r > 0 && r < D ? n = e > 0 ? "right" : "left" : n = e > 0 ? "left" : "right"), {
+        rotation: r,
+        textAlign: n,
+        textVerticalAlign: o
+      };
+    }, t.makeAxisEventDataBase = function(a) {
+      var i = {
+        componentType: a.mainType,
+        componentIndex: a.componentIndex
+      };
+      return i[a.mainType + "Index"] = a.componentIndex, i;
+    }, t.isLabelSilent = function(a) {
+      var i = a.get("tooltip");
+      return a.get("silent") || !(a.get("triggerEvent") || i && i.show);
+    }, t;
+  }()
+), at = ["axisLine", "axisTickLabelEstimate", "axisTickLabelDetermine", "axisName"], rt = {
+  axisLine: function(t, a, i, e, r, n, o) {
+    if (process.env.NODE_ENV !== "production") {
+      var s = i.ensureRecord(e).ready;
+      N(!s.axisLine), s.axisLine = !0;
+    }
+    var l = e.get(["axisLine", "show"]);
+    if (l === "auto" && (l = !0, t.raw.axisLineAutoShow != null && (l = !!t.raw.axisLineAutoShow)), !!l) {
+      var f = e.axis.getExtent(), v = n.transform, u = [f[0], 0], c = [f[1], 0], p = u[0] > c[0];
+      v && (Z(u, u, v), Z(c, c, v));
+      var k = ie({
+        lineCap: "round"
+      }, e.getModel(["axisLine", "lineStyle"]).getLineStyle()), g = {
+        strokeContainThreshold: t.raw.strokeContainThreshold || 5,
+        silent: !0,
+        z2: 1,
+        style: k
+      };
+      if (e.get(["axisLine", "breakLine"]) && e.axis.scale.hasBreaks())
+        de().buildAxisBreakLine(e, r, n, g);
+      else {
+        var T = new ye(ie({
+          shape: {
+            x1: u[0],
+            y1: u[1],
+            x2: c[0],
+            y2: c[1]
+          }
+        }, g));
+        me(T.shape, T.style.lineWidth), T.anid = "line", r.add(T);
+      }
+      var b = e.get(["axisLine", "symbol"]);
+      if (b != null) {
+        var L = e.get(["axisLine", "symbolSize"]);
+        ne(b) && (b = [b, b]), (ne(L) || Ce(L)) && (L = [L, L]);
+        var B = Me(e.get(["axisLine", "symbolOffset"]) || 0, L), m = L[0], h = L[1];
+        V([{
+          rotate: t.rotation + Math.PI / 2,
+          offset: B[0],
+          r: 0
+        }, {
+          rotate: t.rotation - Math.PI / 2,
+          offset: B[1],
+          r: Math.sqrt((u[0] - c[0]) * (u[0] - c[0]) + (u[1] - c[1]) * (u[1] - c[1]))
+        }], function(x, A) {
+          if (b[A] !== "none" && b[A] != null) {
+            var w = Ie(b[A], -m / 2, -h / 2, m, h, k.stroke, !0), O = x.r + x.offset, y = p ? c : u;
+            w.attr({
+              rotation: x.rotate,
+              x: y[0] + O * Math.cos(t.rotation),
+              y: y[1] - O * Math.sin(t.rotation),
+              silent: !0,
+              z2: 11
+            }), r.add(w);
+          }
+        });
+      }
+    }
+  },
+  /**
+   * [CAUTION] This method can be called multiple times, following the change due to `resetCfg` called
+   *  in size measurement. Thus this method should be idempotent, and should be performant.
+   */
+  axisTickLabelEstimate: function(t, a, i, e, r, n, o, s) {
+    if (process.env.NODE_ENV !== "production") {
+      var l = i.ensureRecord(e).ready;
+      N(!l.axisTickLabelDetermine), l.axisTickLabelEstimate = !0;
+    }
+    var f = ve(a, r, s);
+    f && ue(t, a, i, e, r, n, o, se.estimate);
+  },
+  /**
+   * Finish axis tick label build.
+   * Can be only called once.
+   */
+  axisTickLabelDetermine: function(t, a, i, e, r, n, o, s) {
+    if (process.env.NODE_ENV !== "production") {
+      var l = i.ensureRecord(e).ready;
+      l.axisTickLabelDetermine = !0;
+    }
+    var f = ve(a, r, s);
+    f && ue(t, a, i, e, r, n, o, se.determine);
+    var v = lt(t, r, n, e);
+    ot(t, a.labelLayoutList, v), st(t, r, n, e, t.tickDirection);
+  },
+  /**
+   * [CAUTION] This method can be called multiple times, following the change due to `resetCfg` called
+   *  in size measurement. Thus this method should be idempotent, and should be performant.
+   */
+  axisName: function(t, a, i, e, r, n, o, s) {
+    var l = i.ensureRecord(e);
+    if (process.env.NODE_ENV !== "production") {
+      var f = l.ready;
+      N(f.axisTickLabelEstimate || f.axisTickLabelDetermine), f.axisName = !0;
+    }
+    a.nameEl && (r.remove(a.nameEl), a.nameEl = l.nameLayout = l.nameLocation = null);
+    var v = t.axisName;
+    if (re(v)) {
+      var u = t.nameLocation, c = t.nameDirection, p = e.getModel("nameTextStyle"), k = e.get("nameGap") || 0, g = e.axis.getExtent(), T = e.axis.inverse ? -1 : 1, b = new F(0, 0), L = new F(0, 0);
+      u === "start" ? (b.x = g[0] - T * k, L.x = -T) : u === "end" ? (b.x = g[1] + T * k, L.x = T) : (b.x = (g[0] + g[1]) / 2, b.y = t.labelOffset + c * k, L.y = c);
+      var B = be();
+      L.transform(Ge(B, B, t.rotation));
+      var m = e.get("nameRotate");
+      m != null && (m = m * D / 180);
+      var h, x;
+      q(u) ? h = G.innerTextLayout(
+        t.rotation,
+        m ?? t.rotation,
+        // Adapt to axis.
+        c
+      ) : (h = it(t.rotation, u, m || 0, g), x = t.raw.axisNameAvailableWidth, x != null && (x = Math.abs(x / Math.sin(h.rotation)), !isFinite(x) && (x = null)));
+      var A = p.getFont(), w = e.get("nameTruncate", !0) || {}, O = w.ellipsis, y = $(t.raw.nameTruncateMaxWidth, w.maxWidth, x), M = s.nameMarginLevel || 0, d = new xe({
+        x: b.x,
+        y: b.y,
+        rotation: h.rotation,
+        silent: G.isLabelSilent(e),
+        style: pe(p, {
+          text: v,
+          font: A,
+          overflow: "truncate",
+          width: y,
+          ellipsis: O,
+          fill: p.getTextColor() || e.get(["axisLine", "lineStyle", "color"]),
+          align: p.get("align") || h.textAlign,
+          verticalAlign: p.get("verticalAlign") || h.textVerticalAlign
+        }),
+        z2: 1
+      });
+      if (fe({
+        el: d,
+        componentModel: e,
+        itemName: v
+      }), d.__fullText = v, d.anid = "name", e.get("triggerEvent")) {
+        var C = G.makeAxisEventDataBase(e);
+        C.targetType = "axisName", C.name = v, ce(d).eventData = C;
+      }
+      n.add(d), d.updateTransform(), a.nameEl = d;
+      var j = l.nameLayout = R({
+        label: d,
+        priority: d.z2,
+        defaultAttr: {
+          ignore: d.ignore
+        },
+        marginDefault: q(u) ? Ye[M] : Je[M]
+      });
+      if (l.nameLocation = u, r.add(d), d.decomposeTransform(), t.shouldNameMoveOverlap && j) {
+        var U = i.ensureRecord(e);
+        process.env.NODE_ENV !== "production" && N(U.labelInfoList), i.resolveAxisNameOverlap(t, i, e, j, L, U);
+      }
+    }
+  }
+};
+function ue(t, a, i, e, r, n, o, s) {
+  _e(a) || ut(t, a, r, s, e, o);
+  var l = a.labelLayoutList;
+  vt(t, e, l, n), ct(e, t.rotation, l);
+  var f = t.optionHideOverlap;
+  nt(e, l, f), f && je(
+    // Filter the already ignored labels by the previous overlap resolving methods.
+    Ne(l, function(v) {
+      return v && !v.label.ignore;
+    })
+  ), $e(t, i, e, l);
+}
+function it(t, a, i, e) {
+  var r = ge(i - t), n, o, s = e[0] > e[1], l = a === "start" && !s || a !== "start" && s;
+  return K(r - D / 2) ? (o = l ? "bottom" : "top", n = "center") : K(r - D * 1.5) ? (o = l ? "top" : "bottom", n = "center") : (o = "middle", r < D * 1.5 && r > D / 2 ? n = l ? "left" : "right" : n = l ? "right" : "left"), {
+    rotation: r,
+    textAlign: n,
+    textVerticalAlign: o
+  };
+}
+function nt(t, a, i) {
+  if (Fe(t.axis))
+    return;
+  function e(s, l, f) {
+    var v = R(a[l]), u = R(a[f]);
+    if (!(!v || !u)) {
+      if (s === !1 || v.suggestIgnore) {
+        z(v.label);
+        return;
+      }
+      if (u.suggestIgnore) {
+        z(u.label);
+        return;
+      }
+      var c = 0.1;
+      if (!i) {
+        var p = [0, 0, 0, 0];
+        v = oe({
+          marginForce: p
+        }, v), u = oe({
+          marginForce: p
+        }, u);
+      }
+      Le(v, u, null, {
+        touchThreshold: c
+      }) && z(s ? u.label : v.label);
+    }
+  }
+  var r = t.get(["axisLabel", "showMinLabel"]), n = t.get(["axisLabel", "showMaxLabel"]), o = a.length;
+  e(r, 0, 1), e(n, o - 1, o - 2);
+}
+function ot(t, a, i) {
+  t.showMinorTicks || V(a, function(e) {
+    if (e && e.label.ignore)
+      for (var r = 0; r < i.length; r++) {
+        var n = i[r], o = Te(n), s = H(e.label);
+        if (o.tickValue != null && !o.onBand && o.tickValue === s.tickValue) {
+          z(n);
+          return;
+        }
+      }
+  });
+}
+function z(t) {
+  t && (t.ignore = !0);
+}
+function Ee(t, a, i, e, r) {
+  for (var n = [], o = [], s = [], l = 0; l < t.length; l++) {
+    var f = t[l].coord;
+    o[0] = f, o[1] = 0, s[0] = f, s[1] = i, a && (Z(o, o, a), Z(s, s, a));
+    var v = new ye({
+      shape: {
+        x1: o[0],
+        y1: o[1],
+        x2: s[0],
+        y2: s[1]
+      },
+      style: e,
+      z2: 2,
+      autoBatch: !0,
+      silent: !0
+    });
+    me(v.shape, v.style.lineWidth), v.anid = r + "_" + t[l].tickValue, n.push(v);
+    var u = Te(v);
+    u.onBand = !!t[l].onBand, u.tickValue = t[l].tickValue;
+  }
+  return n;
+}
+function lt(t, a, i, e) {
+  var r = e.axis, n = e.getModel("axisTick"), o = n.get("show");
+  if (o === "auto" && (o = !0, t.raw.axisTickAutoShow != null && (o = !!t.raw.axisTickAutoShow)), !o || r.scale.isBlank())
+    return [];
+  for (var s = n.getModel("lineStyle"), l = t.tickDirection * n.get("length"), f = r.getTicksCoords(), v = Ee(f, i.transform, l, ee(s.getLineStyle(), {
+    stroke: e.get(["axisLine", "lineStyle", "color"])
+  }), "ticks"), u = 0; u < v.length; u++)
+    a.add(v[u]);
+  return v;
+}
+function st(t, a, i, e, r) {
+  var n = e.axis, o = e.getModel("minorTick");
+  if (!(!t.showMinorTicks || n.scale.isBlank())) {
+    var s = n.getMinorTicksCoords();
+    if (s.length)
+      for (var l = o.getModel("lineStyle"), f = r * o.get("length"), v = ee(l.getLineStyle(), ee(e.getModel("axisTick").getLineStyle(), {
+        stroke: e.get(["axisLine", "lineStyle", "color"])
+      })), u = 0; u < s.length; u++)
+        for (var c = Ee(s[u], i.transform, f, v, "minorticks_" + u), p = 0; p < c.length; p++)
+          a.add(c[p]);
+  }
+}
+function ve(t, a, i) {
+  if (_e(t)) {
+    var e = t.axisLabelsCreationContext;
+    process.env.NODE_ENV !== "production" && N(t.labelGroup && e);
+    var r = e.out.noPxChangeTryDetermine;
+    if (i.noPxChange) {
+      for (var n = !0, o = 0; o < r.length; o++)
+        n = n && r[o]();
+      if (n)
+        return !1;
+    }
+    r.length && (a.remove(t.labelGroup), ae(t, null, null, null));
+  }
+  return !0;
+}
+function ut(t, a, i, e, r, n) {
+  var o = r.axis, s = $(t.raw.axisLabelShow, r.get(["axisLabel", "show"])), l = new te();
+  i.add(l);
+  var f = qe(e);
+  if (!s || o.scale.isBlank()) {
+    ae(a, [], l, f);
+    return;
+  }
+  var v = r.getModel("axisLabel"), u = o.getViewLabels(f), c = ($(t.raw.labelRotate, v.get("rotate")) || 0) * D / 180, p = G.innerTextLayout(t.rotation, c, t.labelDirection), k = r.getCategories && r.getCategories(!0), g = [], T = r.get("triggerEvent"), b = 1 / 0, L = -1 / 0;
+  V(u, function(m, h) {
+    var x, A = o.scale.type === "ordinal" ? o.scale.getRawOrdinalNumber(m.tickValue) : m.tickValue, w = m.formattedLabel, O = m.rawLabel, y = v;
+    if (k && k[A]) {
+      var M = k[A];
+      De(M) && M.textStyle && (y = new Ve(M.textStyle, v, r.ecModel));
+    }
+    var d = y.getTextColor() || r.get(["axisLine", "lineStyle", "color"]), C = y.getShallow("align", !0) || p.textAlign, j = E(y.getShallow("alignMinLabel", !0), C), U = E(y.getShallow("alignMaxLabel", !0), C), Y = y.getShallow("verticalAlign", !0) || y.getShallow("baseline", !0) || p.textVerticalAlign, we = E(y.getShallow("verticalAlignMinLabel", !0), Y), Oe = E(y.getShallow("verticalAlignMaxLabel", !0), Y), J = 10 + (((x = m.time) === null || x === void 0 ? void 0 : x.level) || 0);
+    b = Math.min(b, J), L = Math.max(L, J);
+    var S = new xe({
+      // --- transform props start ---
+      // All of the transform props MUST not be set here, but should be set in
+      // `updateAxisLabelChangableProps`, because they may change in estimation,
+      // and need to calculate based on global coord sys by `decomposeTransform`.
+      x: 0,
+      y: 0,
+      rotation: 0,
+      // --- transform props end ---
+      silent: G.isLabelSilent(r),
+      z2: J,
+      style: pe(y, {
+        text: w,
+        align: h === 0 ? j : h === u.length - 1 ? U : C,
+        verticalAlign: h === 0 ? we : h === u.length - 1 ? Oe : Y,
+        fill: Re(d) ? d(
+          // (1) In category axis with data zoom, tick is not the original
+          // index of axis.data. So tick should not be exposed to user
+          // in category axis.
+          // (2) Compatible with previous version, which always use formatted label as
+          // input. But in interval scale the formatted label is like '223,445', which
+          // maked user replace ','. So we modify it to return original val but remain
+          // it as 'string' to avoid error in replacing.
+          o.type === "category" ? O : o.type === "value" ? A + "" : A,
+          h
+        ) : d
+      })
+    });
+    S.anid = "label_" + A;
+    var Q = H(S);
+    if (Q.break = m.break, Q.tickValue = A, Q.layoutRotation = p.rotation, fe({
+      el: S,
+      componentModel: r,
+      itemName: w,
+      formatterParamsExtra: {
+        isTruncated: function() {
+          return S.isTruncated;
+        },
+        value: O,
+        tickIndex: h
+      }
+    }), T) {
+      var I = G.makeAxisEventDataBase(r);
+      I.targetType = "axisLabel", I.value = O, I.tickIndex = h, m.break && (I.break = {
+        // type: labelItem.break.type,
+        start: m.break.parsedBreak.vmin,
+        end: m.break.parsedBreak.vmax
+      }), o.type === "category" && (I.dataIndex = A), ce(S).eventData = I, m.break && mt(r, n, S, m.break);
+    }
+    g.push(S), l.add(S);
+  });
+  var B = Be(g, function(m) {
+    return {
+      label: m,
+      priority: H(m).break ? m.z2 + (L - b + 1) : m.z2,
+      defaultAttr: {
+        ignore: m.ignore
+      }
+    };
+  });
+  ae(a, B, l, f);
+}
+function _e(t) {
+  return !!t.labelLayoutList;
+}
+function ae(t, a, i, e) {
+  t.labelLayoutList = a, t.labelGroup = i, t.axisLabelsCreationContext = e;
+}
+function vt(t, a, i, e) {
+  var r = a.get(["axisLabel", "margin"]);
+  V(i, function(n, o) {
+    var s = R(n);
+    if (s) {
+      var l = s.label, f = H(l);
+      s.suggestIgnore = l.ignore, l.ignore = !1, le(_, ft), _.x = a.axis.dataToCoord(f.tickValue), _.y = t.labelOffset + t.labelDirection * r, _.rotation = f.layoutRotation, e.add(_), _.updateTransform(), e.remove(_), _.decomposeTransform(), le(l, _), l.markRedraw(), Xe(s, !0), R(s);
+    }
+  });
+}
+var _ = new ke(), ft = new ke();
+function re(t) {
+  return !!t;
+}
+function mt(t, a, i, e) {
+  i.on("click", function(r) {
+    var n = {
+      type: Ke,
+      breaks: [{
+        start: e.parsedBreak.breakOption.start,
+        end: e.parsedBreak.breakOption.end
+      }]
+    };
+    n[t.axis.dim + "AxisIndex"] = t.componentIndex, a.dispatchAction(n);
+  });
+}
+function ct(t, a, i) {
+  var e = Ze();
+  if (e) {
+    var r = e.retrieveAxisBreakPairs(i, function(o) {
+      return o && H(o.label).break;
+    }, !0), n = t.get(["breakLabelLayout", "moveOverlap"], !0);
+    (n === !0 || n === "auto") && V(r, function(o) {
+      de().adjustBreakLabelPair(t.axis.inverse, a, [R(i[o[0]]), R(i[o[1]])]);
+    });
+  }
+}
+export {
+  Qe as AxisBuilderSharedContext,
+  G as default,
+  H as getLabelInner,
+  tt as moveIfOverlapByLinearLabels,
+  et as resolveAxisNameOverlapDefault
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axis/AxisView.js

@@ -0,0 +1,40 @@
+import { __extends as p } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { fixValue as x, getAxisPointerModel as l } from "../axisPointer/modelHelper.js";
+import d from "../../view/Component.js";
+var n = {}, h = (
+  /** @class */
+  function(s) {
+    p(t, s);
+    function t() {
+      var i = s !== null && s.apply(this, arguments) || this;
+      return i.type = t.type, i;
+    }
+    return t.prototype.render = function(i, e, o, r) {
+      this.axisPointerClass && x(i), s.prototype.render.apply(this, arguments), this._doUpdateAxisPointerClass(i, o, !0);
+    }, t.prototype.updateAxisPointer = function(i, e, o, r) {
+      this._doUpdateAxisPointerClass(i, o, !1);
+    }, t.prototype.remove = function(i, e) {
+      var o = this._axisPointer;
+      o && o.remove(e);
+    }, t.prototype.dispose = function(i, e) {
+      this._disposeAxisPointer(e), s.prototype.dispose.apply(this, arguments);
+    }, t.prototype._doUpdateAxisPointerClass = function(i, e, o) {
+      var r = t.getAxisPointerClass(this.axisPointerClass);
+      if (r) {
+        var a = l(i);
+        a ? (this._axisPointer || (this._axisPointer = new r())).render(i, a, e, o) : this._disposeAxisPointer(e);
+      }
+    }, t.prototype._disposeAxisPointer = function(i) {
+      this._axisPointer && this._axisPointer.dispose(i), this._axisPointer = null;
+    }, t.registerAxisPointerClass = function(i, e) {
+      if (process.env.NODE_ENV !== "production" && n[i])
+        throw new Error("axisPointer " + i + " exists");
+      n[i] = e;
+    }, t.getAxisPointerClass = function(i) {
+      return i && n[i];
+    }, t.type = "axis", t;
+  }(d)
+);
+export {
+  h as default
+};