yahee-components 0.0.70 → 0.0.72

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

@@ -0,0 +1,120 @@
+import { __extends as A } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { each as V, isArray as _, defaults as b } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { groupTransition as k, subPixelOptimizeLine as L } from "../../util/graphic.js";
+import H from "./AxisView.js";
+import { rectCoordAxisHandleRemove as R, rectCoordAxisBuildSplitArea as M } from "./axisSplitHelper.js";
+import { getAxisBreakHelper as z } from "./axisBreakHelper.js";
+import { shouldAxisShow as T } from "../../coord/axisHelper.js";
+import P from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Group.js";
+import B from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Line.js";
+var I = ["splitArea", "splitLine", "minorSplitLine", "breakArea"], C = (
+  /** @class */
+  function(t) {
+    A(i, t);
+    function i() {
+      var e = t !== null && t.apply(this, arguments) || this;
+      return e.type = i.type, e.axisPointerClass = "CartesianAxisPointer", e;
+    }
+    return i.prototype.render = function(e, u, v, r) {
+      this.group.removeAll();
+      var l = this._axisGroup;
+      if (this._axisGroup = new P(), this.group.add(this._axisGroup), !!T(e)) {
+        this._axisGroup.add(e.axis.axisBuilder.group), V(I, function(n) {
+          e.get([n, "show"]) && O[n](this, this._axisGroup, e, e.getCoordSysModel(), v);
+        }, this);
+        var c = r && r.type === "changeAxisOrder" && r.isInitSort;
+        c || k(l, this._axisGroup, e), t.prototype.render.call(this, e, u, v, r);
+      }
+    }, i.prototype.remove = function() {
+      R(this);
+    }, i.type = "cartesianAxis", i;
+  }(H)
+), O = {
+  splitLine: function(t, i, e, u, v) {
+    var r = e.axis;
+    if (!r.scale.isBlank()) {
+      var l = e.getModel("splitLine"), c = l.getModel("lineStyle"), n = c.get("color"), m = l.get("showMinLine") !== !1, x = l.get("showMaxLine") !== !1;
+      n = _(n) ? n : [n];
+      for (var a = u.coordinateSystem.getRect(), h = r.isHorizontal(), y = 0, p = r.getTicksCoords({
+        tickModel: l,
+        breakTicks: "none",
+        pruneByBreak: "preserve_extent_bound"
+      }), o = [], s = [], f = c.getLineStyle(), d = 0; d < p.length; d++) {
+        var g = r.toGlobalCoord(p[d].coord);
+        if (!(d === 0 && !m || d === p.length - 1 && !x)) {
+          var w = p[d].tickValue;
+          h ? (o[0] = g, o[1] = a.y, s[0] = g, s[1] = a.y + a.height) : (o[0] = a.x, o[1] = g, s[0] = a.x + a.width, s[1] = g);
+          var G = y++ % n.length, S = new B({
+            anid: w != null ? "line_" + w : null,
+            autoBatch: !0,
+            shape: {
+              x1: o[0],
+              y1: o[1],
+              x2: s[0],
+              y2: s[1]
+            },
+            style: b({
+              stroke: n[G]
+            }, f),
+            silent: !0
+          });
+          L(S.shape, f.lineWidth), i.add(S);
+        }
+      }
+    }
+  },
+  minorSplitLine: function(t, i, e, u, v) {
+    var r = e.axis, l = e.getModel("minorSplitLine"), c = l.getModel("lineStyle"), n = u.coordinateSystem.getRect(), m = r.isHorizontal(), x = r.getMinorTicksCoords();
+    if (x.length)
+      for (var a = [], h = [], y = c.getLineStyle(), p = 0; p < x.length; p++)
+        for (var o = 0; o < x[p].length; o++) {
+          var s = r.toGlobalCoord(x[p][o].coord);
+          m ? (a[0] = s, a[1] = n.y, h[0] = s, h[1] = n.y + n.height) : (a[0] = n.x, a[1] = s, h[0] = n.x + n.width, h[1] = s);
+          var f = new B({
+            anid: "minor_line_" + x[p][o].tickValue,
+            autoBatch: !0,
+            shape: {
+              x1: a[0],
+              y1: a[1],
+              x2: h[0],
+              y2: h[1]
+            },
+            style: y,
+            silent: !0
+          });
+          L(f.shape, y.lineWidth), i.add(f);
+        }
+  },
+  splitArea: function(t, i, e, u, v) {
+    M(t, i, e, u);
+  },
+  breakArea: function(t, i, e, u, v) {
+    var r = z(), l = e.axis.scale;
+    r && l.type !== "ordinal" && r.rectCoordBuildBreakAxis(i, t, e, u.coordinateSystem.getRect(), v);
+  }
+}, W = (
+  /** @class */
+  function(t) {
+    A(i, t);
+    function i() {
+      var e = t !== null && t.apply(this, arguments) || this;
+      return e.type = i.type, e;
+    }
+    return i.type = "xAxis", i;
+  }(C)
+), N = (
+  /** @class */
+  function(t) {
+    A(i, t);
+    function i() {
+      var e = t !== null && t.apply(this, arguments) || this;
+      return e.type = W.type, e;
+    }
+    return i.type = "yAxis", i;
+  }(C)
+);
+export {
+  W as CartesianXAxisView,
+  N as CartesianYAxisView,
+  C as default
+};

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

@@ -0,0 +1,88 @@
+import { __extends as x } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { bind as y, extend as v, map as d } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import g from "./AxisBuilder.js";
+import C from "../helper/BrushController.js";
+import { makeLinearBrushOtherExtent as A, makeRectIsTargetByCursor as B, makeRectPanelClipPath as b } from "../helper/brushHelper.js";
+import { groupTransition as S } from "../../util/graphic.js";
+import _ from "../../view/Component.js";
+import T from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Group.js";
+import w from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/BoundingRect.js";
+var Z = (
+  /** @class */
+  function(e) {
+    x(t, e);
+    function t() {
+      var r = e !== null && e.apply(this, arguments) || this;
+      return r.type = t.type, r;
+    }
+    return t.prototype.init = function(r, i) {
+      e.prototype.init.apply(this, arguments), (this._brushController = new C(i.getZr())).on("brush", y(this._onBrush, this));
+    }, t.prototype.render = function(r, i, o, s) {
+      if (!G(r, i, s)) {
+        this.axisModel = r, this.api = o, this.group.removeAll();
+        var l = this._axisGroup;
+        if (this._axisGroup = new T(), this.group.add(this._axisGroup), !!r.get("show")) {
+          var n = L(r, i), u = n.coordinateSystem, p = r.getAreaSelectStyle(), h = p.width, a = r.axis.dim, f = u.getAxisLayout(a), m = v({
+            strokeContainThreshold: h
+          }, f), c = new g(r, o, m);
+          c.build(), this._axisGroup.add(c.group), this._refreshBrushController(m, p, r, n, h, o), S(l, this._axisGroup, r);
+        }
+      }
+    }, t.prototype._refreshBrushController = function(r, i, o, s, l, n) {
+      var u = o.axis.getExtent(), p = u[1] - u[0], h = Math.min(30, Math.abs(p) * 0.1), a = w.create({
+        x: u[0],
+        y: -l / 2,
+        width: p,
+        height: l
+      });
+      a.x -= h, a.width += 2 * h, this._brushController.mount({
+        enableGlobalPan: !0,
+        rotation: r.rotation,
+        x: r.position[0],
+        y: r.position[1]
+      }).setPanels([{
+        panelId: "pl",
+        clipPath: b(a),
+        isTargetByCursor: B(a, n, s),
+        getLinearBrushOtherExtent: A(a, 0)
+      }]).enableBrush({
+        brushType: "lineX",
+        brushStyle: i,
+        removeOnClick: !0
+      }).updateCovers(I(o));
+    }, t.prototype._onBrush = function(r) {
+      var i = r.areas, o = this.axisModel, s = o.axis, l = d(i, function(n) {
+        return [s.coordToData(n.range[0], !0), s.coordToData(n.range[1], !0)];
+      });
+      (!o.option.realtime === r.isEnd || r.removeOnClick) && this.api.dispatchAction({
+        type: "axisAreaSelect",
+        parallelAxisId: o.id,
+        intervals: l
+      });
+    }, t.prototype.dispose = function() {
+      this._brushController.dispose();
+    }, t.type = "parallelAxis", t;
+  }(_)
+);
+function G(e, t, r) {
+  return r && r.type === "axisAreaSelect" && t.findComponents({
+    mainType: "parallelAxis",
+    query: r
+  })[0] === e;
+}
+function I(e) {
+  var t = e.axis;
+  return d(e.activeIntervals, function(r) {
+    return {
+      brushType: "lineX",
+      panelId: "pl",
+      range: [t.dataToCoord(r[0], !0), t.dataToCoord(r[1], !0)]
+    };
+  });
+}
+function L(e, t) {
+  return t.getComponent("parallel", e.get("parallelIndex"));
+}
+export {
+  Z as default
+};

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

@@ -0,0 +1,117 @@
+import { __extends as y } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { each as m, defaults as d } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import * as M from "../../util/graphic.js";
+import { groupTransition as S, mergePath as A } from "../../util/graphic.js";
+import w from "./AxisBuilder.js";
+import L from "./AxisView.js";
+import E from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Group.js";
+import P from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Sector.js";
+import b from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Circle.js";
+var B = ["splitLine", "splitArea", "minorSplitLine"], q = (
+  /** @class */
+  function(l) {
+    y(a, l);
+    function a() {
+      var e = l !== null && l.apply(this, arguments) || this;
+      return e.type = a.type, e.axisPointerClass = "PolarAxisPointer", e;
+    }
+    return a.prototype.render = function(e, x, f) {
+      if (this.group.removeAll(), !!e.get("show")) {
+        var s = this._axisGroup, o = this._axisGroup = new E();
+        this.group.add(o);
+        var n = e.axis, t = n.polar, u = t.getAngleAxis(), i = n.getTicksCoords(), g = n.getMinorTicksCoords(), r = u.getExtent()[0], v = n.getExtent(), c = R(t, e, r), p = new w(e, f, c);
+        p.build(), o.add(p.group), S(s, o, e), m(B, function(h) {
+          e.get([h, "show"]) && !n.scale.isBlank() && G[h](this.group, e, t, r, v, i, g);
+        }, this);
+      }
+    }, a.type = "radiusAxis", a;
+  }(L)
+), G = {
+  splitLine: function(l, a, e, x, f, s) {
+    var o = a.getModel("splitLine"), n = o.getModel("lineStyle"), t = n.get("color"), u = 0, i = e.getAngleAxis(), g = Math.PI / 180, r = i.getExtent(), v = Math.abs(r[1] - r[0]) === 360 ? "Circle" : "Arc";
+    t = t instanceof Array ? t : [t];
+    for (var c = [], p = 0; p < s.length; p++) {
+      var h = u++ % t.length;
+      c[h] = c[h] || [], c[h].push(new M[v]({
+        shape: {
+          cx: e.cx,
+          cy: e.cy,
+          // ensure circle radius >= 0
+          r: Math.max(s[p].coord, 0),
+          startAngle: -r[0] * g,
+          endAngle: -r[1] * g,
+          clockwise: i.inverse
+        }
+      }));
+    }
+    for (var p = 0; p < c.length; p++)
+      l.add(A(c[p], {
+        style: d({
+          stroke: t[p % t.length],
+          fill: null
+        }, n.getLineStyle()),
+        silent: !0
+      }));
+  },
+  minorSplitLine: function(l, a, e, x, f, s, o) {
+    if (o.length) {
+      for (var n = a.getModel("minorSplitLine"), t = n.getModel("lineStyle"), u = [], i = 0; i < o.length; i++)
+        for (var g = 0; g < o[i].length; g++)
+          u.push(new b({
+            shape: {
+              cx: e.cx,
+              cy: e.cy,
+              r: o[i][g].coord
+            }
+          }));
+      l.add(A(u, {
+        style: d({
+          fill: null
+        }, t.getLineStyle()),
+        silent: !0
+      }));
+    }
+  },
+  splitArea: function(l, a, e, x, f, s) {
+    if (s.length) {
+      var o = a.getModel("splitArea"), n = o.getModel("areaStyle"), t = n.get("color"), u = 0;
+      t = t instanceof Array ? t : [t];
+      for (var i = [], g = s[0].coord, r = 1; r < s.length; r++) {
+        var v = u++ % t.length;
+        i[v] = i[v] || [], i[v].push(new P({
+          shape: {
+            cx: e.cx,
+            cy: e.cy,
+            r0: g,
+            r: s[r].coord,
+            startAngle: 0,
+            endAngle: Math.PI * 2
+          },
+          silent: !0
+        })), g = s[r].coord;
+      }
+      for (var r = 0; r < i.length; r++)
+        l.add(A(i[r], {
+          style: d({
+            fill: t[r % t.length]
+          }, n.getAreaStyle()),
+          silent: !0
+        }));
+    }
+  }
+};
+function R(l, a, e) {
+  return {
+    position: [l.cx, l.cy],
+    rotation: e / 180 * Math.PI,
+    labelDirection: -1,
+    tickDirection: -1,
+    nameDirection: 1,
+    labelRotate: a.getModel("axisLabel").get("rotate"),
+    // Over splitLine and splitArea
+    z2: 1
+  };
+}
+export {
+  q as default
+};

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

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

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

@@ -0,0 +1,52 @@
+import { parseFinder as E } from "../../util/model.js";
+import { each as o, defaults as _ } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+var l = "expandAxisBreak", k = "collapseAxisBreak", B = "toggleAxisBreak", s = "axisbreakchanged", I = {
+  type: l,
+  event: s,
+  update: "update",
+  refineEvent: c
+}, g = {
+  type: k,
+  event: s,
+  update: "update",
+  refineEvent: c
+}, T = {
+  type: B,
+  event: s,
+  update: "update",
+  refineEvent: c
+};
+function c(n, t, a, d) {
+  var e = [];
+  return o(n, function(r) {
+    e = e.concat(r.eventBreaks);
+  }), {
+    eventContent: {
+      breaks: e
+    }
+  };
+}
+function P(n) {
+  n.registerAction(I, t), n.registerAction(g, t), n.registerAction(T, t);
+  function t(a, d) {
+    var e = [], r = E(d, a);
+    function i(x, p) {
+      o(r[x], function(v) {
+        var u = v.updateAxisBreaks(a);
+        o(u.breaks, function(f) {
+          var A;
+          e.push(_((A = {}, A[p] = v.componentIndex, A), f));
+        });
+      });
+    }
+    return i("xAxisModels", "xAxisIndex"), i("yAxisModels", "yAxisIndex"), i("singleAxisModels", "singleAxisIndex"), {
+      eventBreaks: e
+    };
+  }
+}
+export {
+  k as AXIS_BREAK_COLLAPSE_ACTION_TYPE,
+  l as AXIS_BREAK_EXPAND_ACTION_TYPE,
+  B as AXIS_BREAK_TOGGLE_ACTION_TYPE,
+  P as registerAction
+};

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

@@ -0,0 +1,11 @@
+var e = null;
+function i(r) {
+  e || (e = r);
+}
+function l() {
+  return e;
+}
+export {
+  l as getAxisBreakHelper,
+  i as registerAxisBreakHelperImpl
+};