yahee-components 0.0.70 → 0.0.72

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/matrix/matrixCoordHelper.js

@@ -0,0 +1,106 @@
+import { isArray as F, eqNaN as l, isNumber as H } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { XY as v, WH as E } from "../../util/graphic.js";
+import { mathMax as Y, mathMin as b } from "../../util/number.js";
+var M = {
+  level: 1,
+  leaf: 2,
+  nonLeaf: 3
+}, T = {
+  // No clamp, be falsy, equals to null/undefined. It means if the input part is
+  // null/undefined/NaN/outOfBoundary, the result part is NaN, rather than clamp to
+  // the boundary of the matrix.
+  none: 0,
+  // Clamp, where null/undefined/NaN/outOfBoundary can be used to cover the entire row/column.
+  all: 1,
+  body: 2,
+  corner: 3
+};
+function A(r, n, t) {
+  var a = n[v[t]].getCell(r);
+  return !a && H(r) && r < 0 && (a = n[v[1 - t]].getUnitLayoutInfo(t, Math.round(r))), a;
+}
+function G(r) {
+  var n = r || [];
+  return n[0] = n[0] || [], n[1] = n[1] || [], n[0][0] = n[0][1] = n[1][0] = n[1][1] = NaN, n;
+}
+function J(r, n, t, a, f) {
+  _(r[0], n, f, t, a, 0), _(r[1], n, f, t, a, 1);
+}
+function _(r, n, t, a, f, e) {
+  r[0] = 1 / 0, r[1] = -1 / 0;
+  var y = a[e], C = F(y) ? y : [y], i = C.length, p = !!t;
+  if (i >= 1 ? (S(r, n, C, p, f, e, 0), i > 1 && S(r, n, C, p, f, e, i - 1)) : (process.env.NODE_ENV !== "production" && n && n.push('Should be like [["x1", "x2"], ["y1", "y2"]], or ["x1", "y1"], rather than empty.'), r[0] = r[1] = NaN), p) {
+    var N = -f[v[1 - e]].getLocatorCount(e), X = f[v[e]].getLocatorCount(e) - 1;
+    t === T.body ? N = Y(0, N) : t === T.corner && (X = b(-1, X)), X < N && (N = X = NaN), l(r[0]) && (r[0] = N), l(r[1]) && (r[1] = X), r[0] = Y(b(r[0], X), N), r[1] = Y(b(r[1], X), N);
+  }
+}
+function S(r, n, t, a, f, e, y) {
+  var C = A(t[y], f, e);
+  if (!C) {
+    process.env.NODE_ENV !== "production" && !a && n && n.push("Can not find cell by coord[" + e + "][" + y + "]."), r[0] = r[1] = NaN;
+    return;
+  }
+  var i = C.id[v[e]], p = i, N = W(C);
+  N && (p += N.span[v[e]] - 1), r[0] = b(r[0], i, p), r[1] = Y(r[1], i, p);
+}
+function K(r, n) {
+  return l(r[n][0]) || l(r[n][1]);
+}
+function Q(r, n, t, a) {
+  n = n || P;
+  for (var f = 0; f < a; f++)
+    n[f] = !1;
+  for (; ; ) {
+    for (var e = !1, f = 0; f < a; f++) {
+      var y = t[f];
+      !n[f] && y.cellMergeOwner && V(r, y.locatorRange) && (n[f] = !0, e = !0);
+    }
+    if (!e)
+      break;
+  }
+}
+var P = [];
+function V(r, n) {
+  return !q(r[0], n[0]) || !q(r[1], n[1]) ? !1 : (r[0][0] = b(r[0][0], n[0][0]), r[0][1] = Y(r[0][1], n[0][1]), r[1][0] = b(r[1][0], n[1][0]), r[1][1] = Y(r[1][1], n[1][1]), !0);
+}
+function q(r, n) {
+  return r[1] >= n[0] && r[0] <= n[1];
+}
+function Z(r, n) {
+  r.id.set(n[0][0], n[1][0]), r.span.set(n[0][1] - r.id.x + 1, n[1][1] - r.id.y + 1);
+}
+function $(r, n) {
+  r[0][0] = n[0][0], r[0][1] = n[0][1], r[1][0] = n[1][0], r[1][1] = n[1][1];
+}
+function h(r, n, t, a) {
+  var f = A(n[a][0], t, a), e = A(n[a][1], t, a);
+  r[v[a]] = r[E[a]] = NaN, f && e && (r[v[a]] = f.xy, r[E[a]] = e.xy + e.wh - f.xy);
+}
+function s(r, n, t, a) {
+  return r[v[n]] = t, r[v[1 - n]] = a, r;
+}
+function W(r) {
+  return r && (r.type === M.leaf || r.type === M.nonLeaf) ? r : null;
+}
+function u() {
+  return {
+    x: NaN,
+    y: NaN,
+    width: NaN,
+    height: NaN
+  };
+}
+export {
+  M as MatrixCellLayoutInfoType,
+  T as MatrixClampOption,
+  $ as cloneXYLocatorRange,
+  A as coordDataToAllCellLevelLayout,
+  u as createNaNRectLike,
+  Z as fillIdSpanFromLocatorRange,
+  K as isXYLocatorRangeInvalidOnDim,
+  J as parseCoordRangeOption,
+  G as resetXYLocatorRange,
+  Q as resolveXYLocatorRangeByCellMerge,
+  s as setDimXYValue,
+  h as xyLocatorRangeToRectOneDim
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/matrix/prepareCustom.js

@@ -0,0 +1,23 @@
+function i(a) {
+  var t = a.getRect();
+  return {
+    coordSys: {
+      type: "matrix",
+      x: t.x,
+      y: t.y,
+      width: t.width,
+      height: t.height
+    },
+    api: {
+      coord: function(e, r) {
+        return a.dataToPoint(e, r);
+      },
+      layout: function(e, r) {
+        return a.dataToLayout(e, r);
+      }
+    }
+  };
+}
+export {
+  i as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/parallel/AxisModel.js

@@ -0,0 +1,51 @@
+import { __extends as l } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { clone as c, mixin as f } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import s from "../../model/Component.js";
+import p from "../../model/mixin/makeStyleMapper.js";
+import { asc as m } from "../../util/number.js";
+import { AxisModelCommonMixin as v } from "../axisModelCommonMixin.js";
+var h = (
+  /** @class */
+  function(n) {
+    l(r, n);
+    function r() {
+      var t = n !== null && n.apply(this, arguments) || this;
+      return t.type = r.type, t.activeIntervals = [], t;
+    }
+    return r.prototype.getAreaSelectStyle = function() {
+      return p([
+        ["fill", "color"],
+        ["lineWidth", "borderWidth"],
+        ["stroke", "borderColor"],
+        ["width", "width"],
+        ["opacity", "opacity"]
+        // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+        // So do not transfer decal directly.
+      ])(this.getModel("areaSelectStyle"));
+    }, r.prototype.setActiveIntervals = function(t) {
+      var e = this.activeIntervals = c(t);
+      if (e)
+        for (var i = e.length - 1; i >= 0; i--)
+          m(e[i]);
+    }, r.prototype.getActiveState = function(t) {
+      var e = this.activeIntervals;
+      if (!e.length)
+        return "normal";
+      if (t == null || isNaN(+t))
+        return "inactive";
+      if (e.length === 1) {
+        var i = e[0];
+        if (i[0] <= t && t <= i[1])
+          return "active";
+      } else
+        for (var o = 0, a = e.length; o < a; o++)
+          if (e[o][0] <= t && t <= e[o][1])
+            return "active";
+      return "inactive";
+    }, r;
+  }(s)
+);
+f(h, v);
+export {
+  h as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/parallel/Parallel.js

@@ -0,0 +1,178 @@
+import { createHashMap as C, each as E, clone as b } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { rotate as M, create as P, translate as S } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/matrix.js";
+import { createBoxLayoutReference as B, getLayoutRect as I } from "../../util/layout.js";
+import { createScaleByModel as D, niceScaleExtent as T } from "../axisHelper.js";
+import k from "./ParallelAxis.js";
+import { applyTransform as N } from "../../util/graphic.js";
+import { round as F } from "../../util/number.js";
+import z from "../../component/helper/sliderMove.js";
+var f = E, _ = Math.min, L = Math.max, g = Math.floor, R = Math.ceil, W = F, $ = Math.PI, Y = (
+  /** @class */
+  function() {
+    function l(a, t, x) {
+      this.type = "parallel", this._axesMap = C(), this._axesLayout = {}, this.dimensions = a.dimensions, this._model = a, this._init(a, t, x);
+    }
+    return l.prototype._init = function(a, t, x) {
+      var i = a.dimensions, e = a.parallelAxisIndex;
+      f(i, function(n, o) {
+        var r = e[o], h = t.getComponent("parallelAxis", r), s = this._axesMap.set(n, new k(n, D(h), [0, 0], h.get("type"), r)), v = s.type === "category";
+        s.onBand = v && h.get("boundaryGap"), s.inverse = h.get("inverse"), h.axis = s, s.model = h, s.coordinateSystem = h.coordinateSystem = this;
+      }, this);
+    }, l.prototype.update = function(a, t) {
+      this._updateAxesFromSeries(this._model, a);
+    }, l.prototype.containPoint = function(a) {
+      var t = this._makeLayoutInfo(), x = t.axisBase, i = t.layoutBase, e = t.pixelDimIndex, n = a[1 - e], o = a[e];
+      return n >= x && n <= x + t.axisLength && o >= i && o <= i + t.layoutLength;
+    }, l.prototype.getModel = function() {
+      return this._model;
+    }, l.prototype._updateAxesFromSeries = function(a, t) {
+      t.eachSeries(function(x) {
+        if (a.contains(x, t)) {
+          var i = x.getData();
+          f(this.dimensions, function(e) {
+            var n = this._axesMap.get(e);
+            n.scale.unionExtentFromData(i, i.mapDimension(e)), T(n.scale, n.model);
+          }, this);
+        }
+      }, this);
+    }, l.prototype.resize = function(a, t) {
+      var x = B(a, t).refContainer;
+      this._rect = I(a.getBoxLayoutParams(), x), this._layoutAxes();
+    }, l.prototype.getRect = function() {
+      return this._rect;
+    }, l.prototype._makeLayoutInfo = function() {
+      var a = this._model, t = this._rect, x = ["x", "y"], i = ["width", "height"], e = a.get("layout"), n = e === "horizontal" ? 0 : 1, o = t[i[n]], r = [0, o], h = this.dimensions.length, s = m(a.get("axisExpandWidth"), r), v = m(a.get("axisExpandCount") || 0, [0, h]), u = a.get("axisExpandable") && h > 3 && h > v && v > 1 && s > 0 && o > 0, p = a.get("axisExpandWindow"), d;
+      if (p)
+        d = m(p[1] - p[0], r), p[1] = p[0] + d;
+      else {
+        d = m(s * (v - 1), r);
+        var y = a.get("axisExpandCenter") || g(h / 2);
+        p = [s * y - d / 2], p[1] = p[0] + d;
+      }
+      var c = (o - d) / (h - v);
+      c < 3 && (c = 0);
+      var A = [g(W(p[0] / s, 1)) + 1, R(W(p[1] / s, 1)) - 1], w = c / s * p[0];
+      return {
+        layout: e,
+        pixelDimIndex: n,
+        layoutBase: t[x[n]],
+        layoutLength: o,
+        axisBase: t[x[1 - n]],
+        axisLength: t[i[1 - n]],
+        axisExpandable: u,
+        axisExpandWidth: s,
+        axisCollapseWidth: c,
+        axisExpandWindow: p,
+        axisCount: h,
+        winInnerIndices: A,
+        axisExpandWindow0Pos: w
+      };
+    }, l.prototype._layoutAxes = function() {
+      var a = this._rect, t = this._axesMap, x = this.dimensions, i = this._makeLayoutInfo(), e = i.layout;
+      t.each(function(n) {
+        var o = [0, i.axisLength], r = n.inverse ? 1 : 0;
+        n.setExtent(o[r], o[1 - r]);
+      }), f(x, function(n, o) {
+        var r = (i.axisExpandable ? H : G)(o, i), h = {
+          horizontal: {
+            x: r.position,
+            y: i.axisLength
+          },
+          vertical: {
+            x: 0,
+            y: r.position
+          }
+        }, s = {
+          horizontal: $ / 2,
+          vertical: 0
+        }, v = [h[e].x + a.x, h[e].y + a.y], u = s[e], p = P();
+        M(p, p, u), S(p, p, v), this._axesLayout[n] = {
+          position: v,
+          rotation: u,
+          transform: p,
+          axisNameAvailableWidth: r.axisNameAvailableWidth,
+          axisLabelShow: r.axisLabelShow,
+          nameTruncateMaxWidth: r.nameTruncateMaxWidth,
+          tickDirection: 1,
+          labelDirection: 1
+        };
+      }, this);
+    }, l.prototype.getAxis = function(a) {
+      return this._axesMap.get(a);
+    }, l.prototype.dataToPoint = function(a, t) {
+      return this.axisCoordToPoint(this._axesMap.get(t).dataToCoord(a), t);
+    }, l.prototype.eachActiveState = function(a, t, x, i) {
+      x == null && (x = 0), i == null && (i = a.count());
+      var e = this._axesMap, n = this.dimensions, o = [], r = [];
+      E(n, function(c) {
+        o.push(a.mapDimension(c)), r.push(e.get(c).model);
+      });
+      for (var h = this.hasAxisBrushed(), s = x; s < i; s++) {
+        var v = void 0;
+        if (!h)
+          v = "normal";
+        else {
+          v = "active";
+          for (var u = a.getValues(o, s), p = 0, d = n.length; p < d; p++) {
+            var y = r[p].getActiveState(u[p]);
+            if (y === "inactive") {
+              v = "inactive";
+              break;
+            }
+          }
+        }
+        t(v, s);
+      }
+    }, l.prototype.hasAxisBrushed = function() {
+      for (var a = this.dimensions, t = this._axesMap, x = !1, i = 0, e = a.length; i < e; i++)
+        t.get(a[i]).model.getActiveState() !== "normal" && (x = !0);
+      return x;
+    }, l.prototype.axisCoordToPoint = function(a, t) {
+      var x = this._axesLayout[t];
+      return N([a, 0], x.transform);
+    }, l.prototype.getAxisLayout = function(a) {
+      return b(this._axesLayout[a]);
+    }, l.prototype.getSlidedAxisExpandWindow = function(a) {
+      var t = this._makeLayoutInfo(), x = t.pixelDimIndex, i = t.axisExpandWindow.slice(), e = i[1] - i[0], n = [0, t.axisExpandWidth * (t.axisCount - 1)];
+      if (!this.containPoint(a))
+        return {
+          behavior: "none",
+          axisExpandWindow: i
+        };
+      var o = a[x] - t.layoutBase - t.axisExpandWindow0Pos, r, h = "slide", s = t.axisCollapseWidth, v = this._model.get("axisExpandSlideTriggerArea"), u = v[0] != null;
+      if (s)
+        u && s && o < e * v[0] ? (h = "jump", r = o - e * v[2]) : u && s && o > e * (1 - v[0]) ? (h = "jump", r = o - e * (1 - v[2])) : (r = o - e * v[1]) >= 0 && (r = o - e * (1 - v[1])) <= 0 && (r = 0), r *= t.axisExpandWidth / s, r ? z(r, i, n, "all") : h = "none";
+      else {
+        var p = i[1] - i[0], d = n[1] * o / p;
+        i = [L(0, d - p / 2)], i[1] = _(n[1], i[0] + p), i[0] = i[1] - p;
+      }
+      return {
+        axisExpandWindow: i,
+        behavior: h
+      };
+    }, l;
+  }()
+);
+function m(l, a) {
+  return _(L(l, a[0]), a[1]);
+}
+function G(l, a) {
+  var t = a.layoutLength / (a.axisCount - 1);
+  return {
+    position: t * l,
+    axisNameAvailableWidth: t,
+    axisLabelShow: !0
+  };
+}
+function H(l, a) {
+  var t = a.layoutLength, x = a.axisExpandWidth, i = a.axisCount, e = a.axisCollapseWidth, n = a.winInnerIndices, o, r = e, h = !1, s;
+  return l < n[0] ? (o = l * e, s = e) : l <= n[1] ? (o = a.axisExpandWindow0Pos + l * x - a.axisExpandWindow[0], r = x, h = !0) : (o = t - (i - 1 - l) * e, s = e), {
+    position: o,
+    axisNameAvailableWidth: r,
+    axisLabelShow: h,
+    nameTruncateMaxWidth: s
+  };
+}
+export {
+  Y as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/parallel/ParallelAxis.js

@@ -0,0 +1,18 @@
+import { __extends as s } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import u from "../Axis.js";
+var c = (
+  /** @class */
+  function(r) {
+    s(t, r);
+    function t(e, i, a, l, n) {
+      var o = r.call(this, e, i, a) || this;
+      return o.type = l || "value", o.axisIndex = n, o;
+    }
+    return t.prototype.isHorizontal = function() {
+      return this.coordinateSystem.getModel().get("layout") !== "horizontal";
+    }, t;
+  }(u)
+);
+export {
+  c as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/parallel/ParallelModel.js

@@ -0,0 +1,61 @@
+import { __extends as p } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { merge as r, each as l, filter as s } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import x from "../../model/Component.js";
+var m = (
+  /** @class */
+  function(i) {
+    p(t, i);
+    function t() {
+      var n = i !== null && i.apply(this, arguments) || this;
+      return n.type = t.type, n;
+    }
+    return t.prototype.init = function() {
+      i.prototype.init.apply(this, arguments), this.mergeOption({});
+    }, t.prototype.mergeOption = function(n) {
+      var e = this.option;
+      n && r(e, n, !0), this._initDimensions();
+    }, t.prototype.contains = function(n, e) {
+      var a = n.get("parallelIndex");
+      return a != null && e.getComponent("parallel", a) === this;
+    }, t.prototype.setAxisExpand = function(n) {
+      l(["axisExpandable", "axisExpandCenter", "axisExpandCount", "axisExpandWidth", "axisExpandWindow"], function(e) {
+        n.hasOwnProperty(e) && (this.option[e] = n[e]);
+      }, this);
+    }, t.prototype._initDimensions = function() {
+      var n = this.dimensions = [], e = this.parallelAxisIndex = [], a = s(this.ecModel.queryComponents({
+        mainType: "parallelAxis"
+      }), function(o) {
+        return (o.get("parallelIndex") || 0) === this.componentIndex;
+      }, this);
+      l(a, function(o) {
+        n.push("dim" + o.get("dim")), e.push(o.componentIndex);
+      });
+    }, t.type = "parallel", t.dependencies = ["parallelAxis"], t.layoutMode = "box", t.defaultOption = {
+      // zlevel: 0,
+      z: 0,
+      left: 80,
+      top: 60,
+      right: 80,
+      bottom: 60,
+      // width: {totalWidth} - left - right,
+      // height: {totalHeight} - top - bottom,
+      layout: "horizontal",
+      // FIXME
+      // naming?
+      axisExpandable: !1,
+      axisExpandCenter: null,
+      axisExpandCount: 0,
+      axisExpandWidth: 50,
+      axisExpandRate: 17,
+      axisExpandDebounce: 50,
+      // [out, in, jumpTarget]. In percentage. If use [null, 0.05], null means full.
+      // Do not doc to user until necessary.
+      axisExpandSlideTriggerArea: [-0.15, 0.05, 0.4],
+      axisExpandTriggerOn: "click",
+      parallelAxisDefault: null
+    }, t;
+  }(x)
+);
+export {
+  m as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/parallel/parallelCreator.js

@@ -0,0 +1,20 @@
+import m from "./Parallel.js";
+import { SINGLE_REFERRING as c } from "../../util/model.js";
+function i(t, e) {
+  var n = [];
+  return t.eachComponent("parallel", function(r, a) {
+    var o = new m(r, t, e);
+    o.name = "parallel_" + a, o.resize(r, e), r.coordinateSystem = o, o.model = r, n.push(o);
+  }), t.eachSeries(function(r) {
+    if (r.get("coordinateSystem") === "parallel") {
+      var a = r.getReferringComponents("parallel", c).models[0];
+      r.coordinateSystem = a.coordinateSystem;
+    }
+  }), n;
+}
+var f = {
+  create: i
+};
+export {
+  f as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/parallel/parallelPreprocessor.js

@@ -0,0 +1,25 @@
+import { each as i, isObject as n, merge as p } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { normalizeToArray as f } from "../../util/model.js";
+function o(l) {
+  s(l), u(l);
+}
+function s(l) {
+  if (!l.parallel) {
+    var a = !1;
+    i(l.series, function(e) {
+      e && e.type === "parallel" && (a = !0);
+    }), a && (l.parallel = [{}]);
+  }
+}
+function u(l) {
+  var a = f(l.parallelAxis);
+  i(a, function(e) {
+    if (n(e)) {
+      var t = e.parallelIndex || 0, r = f(l.parallel)[t];
+      r && r.parallelAxisDefault && p(e, r.parallelAxisDefault, !1);
+    }
+  });
+}
+export {
+  o as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/polar/AngleAxis.js

@@ -0,0 +1,29 @@
+import { __extends as T } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { getBoundingRect as A } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/contain/text.js";
+import s from "../Axis.js";
+import { makeInner as y } from "../../util/model.js";
+var C = y(), h = (
+  /** @class */
+  function(v) {
+    T(r, v);
+    function r(t, a) {
+      return v.call(this, "angle", t, a || [0, 360]) || this;
+    }
+    return r.prototype.pointToData = function(t, a) {
+      return this.polar.pointToData(t, a)[this.dim === "radius" ? 0 : 1];
+    }, r.prototype.calculateCategoryInterval = function() {
+      var t = this, a = t.getLabelModel(), c = t.scale, i = c.getExtent(), p = c.count();
+      if (i[1] - i[0] < 1)
+        return 0;
+      var e = i[0], m = t.dataToCoord(e + 1) - t.dataToCoord(e), f = Math.abs(m), g = A(e == null ? "" : e + "", a.getFont(), "center", "top"), x = Math.max(g.height, 7), u = x / f;
+      isNaN(u) && (u = 1 / 0);
+      var o = Math.max(0, Math.floor(u)), n = C(t.model), l = n.lastAutoInterval, d = n.lastTickCount;
+      return l != null && d != null && Math.abs(l - o) <= 1 && Math.abs(d - p) <= 1 && l > o ? o = l : (n.lastTickCount = p, n.lastAutoInterval = o), o;
+    }, r;
+  }(s)
+);
+h.prototype.dataToAngle = s.prototype.dataToCoord;
+h.prototype.angleToData = s.prototype.coordToData;
+export {
+  h as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/polar/AxisModel.js

@@ -0,0 +1,44 @@
+import { __extends as n } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { mixin as e } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import l from "../../model/Component.js";
+import { AxisModelCommonMixin as s } from "../axisModelCommonMixin.js";
+import { SINGLE_REFERRING as a } from "../../util/model.js";
+var r = (
+  /** @class */
+  function(o) {
+    n(t, o);
+    function t() {
+      return o !== null && o.apply(this, arguments) || this;
+    }
+    return t.prototype.getCoordSysModel = function() {
+      return this.getReferringComponents("polar", a).models[0];
+    }, t.type = "polarAxis", t;
+  }(l)
+);
+e(r, s);
+var f = (
+  /** @class */
+  function(o) {
+    n(t, o);
+    function t() {
+      var i = o !== null && o.apply(this, arguments) || this;
+      return i.type = t.type, i;
+    }
+    return t.type = "angleAxis", t;
+  }(r)
+), y = (
+  /** @class */
+  function(o) {
+    n(t, o);
+    function t() {
+      var i = o !== null && o.apply(this, arguments) || this;
+      return i.type = t.type, i;
+    }
+    return t.type = "radiusAxis", t;
+  }(r)
+);
+export {
+  f as AngleAxisModel,
+  r as PolarAxisModel,
+  y as RadiusAxisModel
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/polar/Polar.js

@@ -0,0 +1,93 @@
+import g from "./RadiusAxis.js";
+import p from "./AngleAxis.js";
+var v = ["radius", "angle"], _ = (
+  /** @class */
+  function() {
+    function e(i) {
+      this.dimensions = v, this.type = "polar", this.cx = 0, this.cy = 0, this._radiusAxis = new g(), this._angleAxis = new p(), this.axisPointerEnabled = !0, this.name = i || "", this._radiusAxis.polar = this._angleAxis.polar = this;
+    }
+    return e.prototype.containPoint = function(i) {
+      var t = this.pointToCoord(i);
+      return this._radiusAxis.contain(t[0]) && this._angleAxis.contain(t[1]);
+    }, e.prototype.containData = function(i) {
+      return this._radiusAxis.containData(i[0]) && this._angleAxis.containData(i[1]);
+    }, e.prototype.getAxis = function(i) {
+      var t = "_" + i + "Axis";
+      return this[t];
+    }, e.prototype.getAxes = function() {
+      return [this._radiusAxis, this._angleAxis];
+    }, e.prototype.getAxesByScale = function(i) {
+      var t = [], r = this._angleAxis, s = this._radiusAxis;
+      return r.scale.type === i && t.push(r), s.scale.type === i && t.push(s), t;
+    }, e.prototype.getAngleAxis = function() {
+      return this._angleAxis;
+    }, e.prototype.getRadiusAxis = function() {
+      return this._radiusAxis;
+    }, e.prototype.getOtherAxis = function(i) {
+      var t = this._angleAxis;
+      return i === t ? this._radiusAxis : t;
+    }, e.prototype.getBaseAxis = function() {
+      return this.getAxesByScale("ordinal")[0] || this.getAxesByScale("time")[0] || this.getAngleAxis();
+    }, e.prototype.getTooltipAxes = function(i) {
+      var t = i != null && i !== "auto" ? this.getAxis(i) : this.getBaseAxis();
+      return {
+        baseAxes: [t],
+        otherAxes: [this.getOtherAxis(t)]
+      };
+    }, e.prototype.dataToPoint = function(i, t, r) {
+      return this.coordToPoint([this._radiusAxis.dataToRadius(i[0], t), this._angleAxis.dataToAngle(i[1], t)], r);
+    }, e.prototype.pointToData = function(i, t, r) {
+      r = r || [];
+      var s = this.pointToCoord(i);
+      return r[0] = this._radiusAxis.radiusToData(s[0], t), r[1] = this._angleAxis.angleToData(s[1], t), r;
+    }, e.prototype.pointToCoord = function(i) {
+      var t = i[0] - this.cx, r = i[1] - this.cy, s = this.getAngleAxis(), a = s.getExtent(), o = Math.min(a[0], a[1]), h = Math.max(a[0], a[1]);
+      s.inverse ? o = h - 360 : h = o + 360;
+      var x = Math.sqrt(t * t + r * r);
+      t /= x, r /= x;
+      for (var n = Math.atan2(-r, t) / Math.PI * 180, u = n < o ? 1 : -1; n < o || n > h; )
+        n += u * 360;
+      return [x, n];
+    }, e.prototype.coordToPoint = function(i, t) {
+      t = t || [];
+      var r = i[0], s = i[1] / 180 * Math.PI;
+      return t[0] = Math.cos(s) * r + this.cx, t[1] = -Math.sin(s) * r + this.cy, t;
+    }, e.prototype.getArea = function() {
+      var i = this.getAngleAxis(), t = this.getRadiusAxis(), r = t.getExtent().slice();
+      r[0] > r[1] && r.reverse();
+      var s = i.getExtent(), a = Math.PI / 180, o = 1e-4;
+      return {
+        cx: this.cx,
+        cy: this.cy,
+        r0: r[0],
+        r: r[1],
+        startAngle: -s[0] * a,
+        endAngle: -s[1] * a,
+        clockwise: i.inverse,
+        contain: function(h, x) {
+          var n = h - this.cx, u = x - this.cy, l = n * n + u * u, A = this.r, c = this.r0;
+          return A !== c && l - o <= A * A && l + o >= c * c;
+        },
+        // As the bounding box
+        x: this.cx - r[1],
+        y: this.cy - r[1],
+        width: r[1] * 2,
+        height: r[1] * 2
+      };
+    }, e.prototype.convertToPixel = function(i, t, r) {
+      var s = d(t);
+      return s === this ? this.dataToPoint(r) : null;
+    }, e.prototype.convertFromPixel = function(i, t, r) {
+      var s = d(t);
+      return s === this ? this.pointToData(r) : null;
+    }, e;
+  }()
+);
+function d(e) {
+  var i = e.seriesModel, t = e.polarModel;
+  return t && t.coordinateSystem || i && i.coordinateSystem;
+}
+export {
+  _ as default,
+  v as polarDimensions
+};