yahee-components 0.0.70 → 0.0.72

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

@@ -0,0 +1,95 @@
+import { __extends as T } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { applyTransform as l, copy as y } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/vector.js";
+import { copy as v, create as d, invert as _ } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/matrix.js";
+import p from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/BoundingRect.js";
+import m from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/Transformable.js";
+import { parsePercent as f } from "../util/number.js";
+import { clone as g } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { clampByZoomLimit as w } from "../component/helper/roamHelper.js";
+var h = l, P = (
+  /** @class */
+  function(i) {
+    T(o, i);
+    function o(r, e) {
+      var t = i.call(this) || this;
+      return t.type = "view", t.dimensions = ["x", "y"], t._roamTransformable = new m(), t._rawTransformable = new m(), t.name = r, t._opt = e, t;
+    }
+    return o.prototype.setBoundingRect = function(r, e, t, n) {
+      return this._rect = new p(r, e, t, n), this._updateCenterAndZoom(), this._rect;
+    }, o.prototype.getBoundingRect = function() {
+      return this._rect;
+    }, o.prototype.setViewRect = function(r, e, t, n) {
+      this._transformTo(r, e, t, n), this._viewRect = new p(r, e, t, n);
+    }, o.prototype._transformTo = function(r, e, t, n) {
+      var s = this.getBoundingRect(), a = this._rawTransformable;
+      a.transform = s.calculateTransform(new p(r, e, t, n));
+      var c = a.parent;
+      a.parent = null, a.decomposeTransform(), a.parent = c, this._updateTransform();
+    }, o.prototype.setCenter = function(r) {
+      var e = this._opt;
+      e && e.api && e.ecModel && e.ecModel.getShallow("legacyViewCoordSysCenterBase") && r && (r = [f(r[0], e.api.getWidth()), f(r[1], e.api.getWidth())]), this._centerOption = g(r), this._updateCenterAndZoom();
+    }, o.prototype.setZoom = function(r) {
+      this._zoom = w(r || 1, this.zoomLimit), this._updateCenterAndZoom();
+    }, o.prototype.getDefaultCenter = function() {
+      var r = this.getBoundingRect(), e = r.x + r.width / 2, t = r.y + r.height / 2;
+      return [e, t];
+    }, o.prototype.getCenter = function() {
+      return this._center || this.getDefaultCenter();
+    }, o.prototype.getZoom = function() {
+      return this._zoom || 1;
+    }, o.prototype.getRoamTransform = function() {
+      return this._roamTransformable.getLocalTransform();
+    }, o.prototype._updateCenterAndZoom = function() {
+      var r = this._centerOption, e = this._rect;
+      r && e && (this._center = [f(r[0], e.width, e.x), f(r[1], e.height, e.y)]);
+      var t = this._rawTransformable.getLocalTransform(), n = this._roamTransformable, s = this.getDefaultCenter(), a = this.getCenter(), c = this.getZoom();
+      a = l([], a, t), s = l([], s, t), n.originX = a[0], n.originY = a[1], n.x = s[0] - a[0], n.y = s[1] - a[1], n.scaleX = n.scaleY = c, this._updateTransform();
+    }, o.prototype._updateTransform = function() {
+      var r = this._roamTransformable, e = this._rawTransformable;
+      e.parent = r, r.updateTransform(), e.updateTransform(), v(this.transform || (this.transform = []), e.transform || d()), this._rawTransform = e.getLocalTransform(), this.invTransform = this.invTransform || [], _(this.invTransform, this.transform), this.decomposeTransform();
+    }, o.prototype.getTransformInfo = function() {
+      var r = this._rawTransformable, e = this._roamTransformable, t = new m();
+      return t.transform = e.transform, t.decomposeTransform(), {
+        roam: {
+          x: t.x,
+          y: t.y,
+          scaleX: t.scaleX,
+          scaleY: t.scaleY
+        },
+        raw: {
+          x: r.x,
+          y: r.y,
+          scaleX: r.scaleX,
+          scaleY: r.scaleY
+        }
+      };
+    }, o.prototype.getViewRect = function() {
+      return this._viewRect;
+    }, o.prototype.getViewRectAfterRoam = function() {
+      var r = this.getBoundingRect().clone();
+      return r.applyTransform(this.transform), r;
+    }, o.prototype.dataToPoint = function(r, e, t) {
+      var n = e ? this._rawTransform : this.transform;
+      return t = t || [], n ? h(t, r, n) : y(t, r);
+    }, o.prototype.pointToData = function(r, e, t) {
+      t = t || [];
+      var n = this.invTransform;
+      return n ? h(t, r, n) : (t[0] = r[0], t[1] = r[1], t);
+    }, o.prototype.convertToPixel = function(r, e, t) {
+      var n = u(e);
+      return n === this ? n.dataToPoint(t) : null;
+    }, o.prototype.convertFromPixel = function(r, e, t) {
+      var n = u(e);
+      return n === this ? n.pointToData(t) : null;
+    }, o.prototype.containPoint = function(r) {
+      return this.getViewRectAfterRoam().contain(r[0], r[1]);
+    }, o.dimensions = ["x", "y"], o;
+  }(m)
+);
+function u(i) {
+  var o = i.seriesModel;
+  return o ? o.coordinateSystem : null;
+}
+export {
+  P as default
+};

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

@@ -0,0 +1,40 @@
+import { round as p, getPrecisionSafe as h } from "../util/number.js";
+import b from "../scale/Interval.js";
+import { getScaleExtent as w, retrieveAxisBreaksOption as S } from "./axisHelper.js";
+import { warn as y } from "../util/log.js";
+import { logTransform as O, increaseInterval as u, isValueNice as A } from "../scale/helper.js";
+function D(i, v, f) {
+  var m, l = b.prototype, c = l.getTicks.call(f), T = l.getTicks.call(f, {
+    expandToNicedExtent: !0
+  }), n = c.length - 1, E = l.getInterval.call(f), s = w(i, v), t = s.extent, o = s.fixMin, x = s.fixMax;
+  i.type === "log" && (t = O(i.base, t, !0)), i.setBreaksFromOption(S(v)), i.setExtent(t[0], t[1]), i.calcNiceExtent({
+    splitNumber: n,
+    fixMin: o,
+    fixMax: x
+  });
+  var k = l.getExtent.call(i);
+  o && (t[0] = k[0]), x && (t[1] = k[1]);
+  var e = l.getInterval.call(i), a = t[0], r = t[1];
+  if (o && x)
+    e = (r - a) / n;
+  else if (o)
+    for (r = t[0] + e * n; r < t[1] && isFinite(r) && isFinite(t[1]); )
+      e = u(e), r = t[0] + e * n;
+  else if (x)
+    for (a = t[1] - e * n; a > t[0] && isFinite(a) && isFinite(t[0]); )
+      e = u(e), a = t[1] - e * n;
+  else {
+    var F = i.getTicks().length - 1;
+    F > n && (e = u(e));
+    var g = e * n;
+    r = Math.ceil(t[1] / e) * e, a = p(r - g), a < 0 && t[0] >= 0 ? (a = 0, r = p(g)) : r > 0 && t[1] <= 0 && (r = 0, a = -p(g));
+  }
+  var d = (c[0].value - T[0].value) / E, N = (c[n].value - T[n].value) / E;
+  if (l.setExtent.call(i, a + e * d, r + e * N), l.setInterval.call(i, e), (d || N) && l.setNiceExtent.call(i, a + e, r - e), process.env.NODE_ENV !== "production") {
+    var I = l.getTicks.call(i);
+    I[1] && (!A(e) || h(I[1].value) > h(e)) && y("The ticks may be not readable when set min: " + v.get("min") + ", max: " + v.get("max") + (" and alignTicks: true. (" + ((m = v.axis) === null || m === void 0 ? void 0 : m.dim) + "AxisIndex: " + v.componentIndex + ")"), !0);
+  }
+}
+export {
+  D as alignScaleTicks
+};

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

@@ -0,0 +1,9 @@
+var e = {
+  value: 1,
+  category: 1,
+  time: 1,
+  log: 1
+};
+export {
+  e as AXIS_TYPES
+};

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

@@ -0,0 +1,195 @@
+import { defaults as l, merge as a } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import e from "../visual/tokens.js";
+var o = {
+  show: !0,
+  // zlevel: 0,
+  z: 0,
+  // Inverse the axis.
+  inverse: !1,
+  // Axis name displayed.
+  name: "",
+  // 'start' | 'middle' | 'end'
+  nameLocation: "end",
+  // By degree. By default auto rotate by nameLocation.
+  nameRotate: null,
+  nameTruncate: {
+    maxWidth: null,
+    ellipsis: "...",
+    placeholder: "."
+  },
+  // Use global text style by default.
+  nameTextStyle: {
+    // textMargin: never, // The default value will be specified based on `nameLocation`.
+  },
+  // The gap between axisName and axisLine.
+  nameGap: 15,
+  // Default `false` to support tooltip.
+  silent: !1,
+  // Default `false` to avoid legacy user event listener fail.
+  triggerEvent: !1,
+  tooltip: {
+    show: !1
+  },
+  axisPointer: {},
+  axisLine: {
+    show: !0,
+    onZero: !0,
+    onZeroAxisIndex: null,
+    lineStyle: {
+      color: e.color.axisLine,
+      width: 1,
+      type: "solid"
+    },
+    // The arrow at both ends the the axis.
+    symbol: ["none", "none"],
+    symbolSize: [10, 15],
+    breakLine: !0
+  },
+  axisTick: {
+    show: !0,
+    // Whether axisTick is inside the grid or outside the grid.
+    inside: !1,
+    // The length of axisTick.
+    length: 5,
+    lineStyle: {
+      width: 1
+    }
+  },
+  axisLabel: {
+    show: !0,
+    // Whether axisLabel is inside the grid or outside the grid.
+    inside: !1,
+    rotate: 0,
+    // true | false | null/undefined (auto)
+    showMinLabel: null,
+    // true | false | null/undefined (auto)
+    showMaxLabel: null,
+    margin: 8,
+    // formatter: null,
+    fontSize: 12,
+    color: e.color.axisLabel,
+    // In scenarios like axis labels, when labels text's progression direction matches the label
+    // layout direction (e.g., when all letters are in a single line), extra start/end margin is
+    // needed to prevent the text from appearing visually joined. In the other case, when lables
+    // are stacked (e.g., having rotation or horizontal labels on yAxis), the layout needs to be
+    // compact, so NO extra top/bottom margin should be applied.
+    textMargin: [0, 3]
+  },
+  splitLine: {
+    show: !0,
+    showMinLine: !0,
+    showMaxLine: !0,
+    lineStyle: {
+      color: e.color.axisSplitLine,
+      width: 1,
+      type: "solid"
+    }
+  },
+  splitArea: {
+    show: !1,
+    areaStyle: {
+      color: [e.color.backgroundTint, e.color.backgroundTransparent]
+    }
+  },
+  breakArea: {
+    show: !0,
+    itemStyle: {
+      color: e.color.neutral00,
+      // Break border color should be darker than the splitLine
+      // because it has opacity and should be more prominent
+      borderColor: e.color.border,
+      borderWidth: 1,
+      borderType: [3, 3],
+      opacity: 0.6
+    },
+    zigzagAmplitude: 4,
+    zigzagMinSpan: 4,
+    zigzagMaxSpan: 20,
+    zigzagZ: 100,
+    expandOnClick: !0
+  },
+  breakLabelLayout: {
+    moveOverlap: "auto"
+  }
+}, t = a({
+  // The gap at both ends of the axis. For categoryAxis, boolean.
+  boundaryGap: !0,
+  // Set false to faster category collection.
+  deduplication: null,
+  jitter: 0,
+  jitterOverlap: !0,
+  jitterMargin: 2,
+  // splitArea: {
+  // show: false
+  // },
+  splitLine: {
+    show: !1
+  },
+  axisTick: {
+    // If tick is align with label when boundaryGap is true
+    alignWithLabel: !1,
+    interval: "auto",
+    show: "auto"
+  },
+  axisLabel: {
+    interval: "auto"
+  }
+}, o), i = a({
+  boundaryGap: [0, 0],
+  axisLine: {
+    // Not shown when other axis is categoryAxis in cartesian
+    show: "auto"
+  },
+  axisTick: {
+    // Not shown when other axis is categoryAxis in cartesian
+    show: "auto"
+  },
+  // TODO
+  // min/max: [30, datamin, 60] or [20, datamin] or [datamin, 60]
+  splitNumber: 5,
+  minorTick: {
+    // Minor tick, not available for cateogry axis.
+    show: !1,
+    // Split number of minor ticks. The value should be in range of (0, 100)
+    splitNumber: 5,
+    // Length of minor tick
+    length: 3,
+    // Line style
+    lineStyle: {
+      // Default to be same with axisTick
+    }
+  },
+  minorSplitLine: {
+    show: !1,
+    lineStyle: {
+      color: e.color.axisMinorSplitLine,
+      width: 1
+    }
+  }
+}, o), r = a({
+  splitNumber: 6,
+  axisLabel: {
+    // To eliminate labels that are not nice
+    showMinLabel: !1,
+    showMaxLabel: !1,
+    rich: {
+      primary: {
+        fontWeight: "bold"
+      }
+    }
+  },
+  splitLine: {
+    show: !1
+  }
+}, i), n = l({
+  logBase: 10
+}, i);
+const h = {
+  category: t,
+  value: i,
+  time: r,
+  log: n
+};
+export {
+  h as default
+};

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

@@ -0,0 +1,182 @@
+import { each as m, keys as y, isString as M, isFunction as d } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import w from "../scale/Ordinal.js";
+import h from "../scale/Interval.js";
+import E from "../scale/Scale.js";
+import { prepareLayoutBarSeries as L, makeColumnLayout as O, retrieveColumnLayout as I } from "../layout/barGrid.js";
+import k from "../scale/Time.js";
+import S from "../scale/Log.js";
+import { getStackedDimension as A } from "../data/helper/dataStackHelper.js";
+import { ensureScaleRawExtentInfo as F } from "./scaleRawExtentInfo.js";
+import { parseTimeAxisLabelFormatter as C } from "../util/time.js";
+import { getScaleBreakHelper as b } from "../scale/break.js";
+import { error as p } from "../util/log.js";
+function N(e, t) {
+  var n = e.type, a = F(e, t, e.getExtent()).calculate();
+  e.setBlank(a.isBlank);
+  var r = a.min, i = a.max, o = t.ecModel;
+  if (o && n === "time") {
+    var l = L("bar", o), u = !1;
+    if (m(l, function(s) {
+      u = u || s.getBaseAxis() === t.axis;
+    }), u) {
+      var v = O(l), f = B(r, i, t, v);
+      r = f.min, i = f.max;
+    }
+  }
+  return {
+    extent: [r, i],
+    // "fix" means "fixed", the value should not be
+    // changed in the subsequent steps.
+    fixMin: a.minFixed,
+    fixMax: a.maxFixed
+  };
+}
+function B(e, t, n, a) {
+  var r = n.axis.getExtent(), i = Math.abs(r[1] - r[0]), o = I(a, n.axis);
+  if (o === void 0)
+    return {
+      min: e,
+      max: t
+    };
+  var l = 1 / 0;
+  m(o, function(c) {
+    l = Math.min(c.offset, l);
+  });
+  var u = -1 / 0;
+  m(o, function(c) {
+    u = Math.max(c.offset + c.width, u);
+  }), l = Math.abs(l), u = Math.abs(u);
+  var v = l + u, f = t - e, s = 1 - (l + u) / i, g = f / s - f;
+  return t += g * (u / v), e -= g * (l / v), {
+    min: e,
+    max: t
+  };
+}
+function Y(e, t) {
+  var n = t, a = N(e, n), r = a.extent, i = n.get("splitNumber");
+  e instanceof S && (e.base = n.get("logBase"));
+  var o = e.type, l = n.get("interval"), u = o === "interval" || o === "time";
+  e.setBreaksFromOption(T(n)), e.setExtent(r[0], r[1]), e.calcNiceExtent({
+    splitNumber: i,
+    fixMin: a.fixMin,
+    fixMax: a.fixMax,
+    minInterval: u ? n.get("minInterval") : null,
+    maxInterval: u ? n.get("maxInterval") : null
+  }), l != null && e.setInterval && e.setInterval(l);
+}
+function $(e, t) {
+  if (t = t || e.get("type"), t)
+    switch (t) {
+      // Buildin scale
+      case "category":
+        return new w({
+          ordinalMeta: e.getOrdinalMeta ? e.getOrdinalMeta() : e.getCategories(),
+          extent: [1 / 0, -1 / 0]
+        });
+      case "time":
+        return new k({
+          locale: e.ecModel.getLocaleModel(),
+          useUTC: e.ecModel.get("useUTC")
+        });
+      default:
+        return new (E.getClass(t) || h)();
+    }
+}
+function _(e) {
+  var t = e.scale.getExtent(), n = t[0], a = t[1];
+  return !(n > 0 && a > 0 || n < 0 && a < 0);
+}
+function H(e) {
+  var t = e.getLabelModel().get("formatter");
+  if (e.type === "time") {
+    var n = C(t);
+    return function(r, i) {
+      return e.scale.getFormattedLabel(r, i, n);
+    };
+  } else {
+    if (M(t))
+      return function(r) {
+        var i = e.scale.getLabel(r), o = t.replace("{value}", i ?? "");
+        return o;
+      };
+    if (d(t)) {
+      if (e.type === "category")
+        return function(r, i) {
+          return t(
+            x(e, r),
+            r.value - e.scale.getExtent()[0],
+            null
+            // Using `null` just for backward compat.
+          );
+        };
+      var a = b();
+      return function(r, i) {
+        var o = null;
+        return a && (o = a.makeAxisLabelFormatterParamBreak(o, r.break)), t(x(e, r), i, o);
+      };
+    } else
+      return function(r) {
+        return e.scale.getLabel(r);
+      };
+  }
+}
+function x(e, t) {
+  return e.type === "category" ? e.scale.getLabel(t) : t.value;
+}
+function D(e) {
+  var t = e.get("interval");
+  return t ?? "auto";
+}
+function ee(e) {
+  return e.type === "category" && D(e.getLabelModel()) === 0;
+}
+function R(e, t) {
+  var n = {};
+  return m(e.mapDimensionsAll(t), function(a) {
+    n[A(e, a)] = !0;
+  }), y(n);
+}
+function te(e, t, n) {
+  t && m(R(t, n), function(a) {
+    var r = t.getApproximateExtent(a);
+    r[0] < e[0] && (e[0] = r[0]), r[1] > e[1] && (e[1] = r[1]);
+  });
+}
+function re(e) {
+  return e === "middle" || e === "center";
+}
+function ne(e) {
+  return e.getShallow("show");
+}
+function T(e) {
+  var t = e.get("breaks", !0);
+  if (t != null) {
+    if (!b()) {
+      process.env.NODE_ENV !== "production" && p('Must `import {AxisBreak} from "echarts/features.js"; use(AxisBreak);` first if using breaks option.');
+      return;
+    }
+    if (!V(e.axis)) {
+      process.env.NODE_ENV !== "production" && p("Axis '" + e.axis.dim + "'-'" + e.axis.type + "' does not support break.");
+      return;
+    }
+    return t;
+  }
+}
+function V(e) {
+  return (e.dim === "x" || e.dim === "y" || e.dim === "z" || e.dim === "single") && e.type !== "category";
+}
+export {
+  $ as createScaleByModel,
+  x as getAxisRawValue,
+  R as getDataDimensionsOnAxis,
+  D as getOptionCategoryInterval,
+  N as getScaleExtent,
+  _ as ifAxisCrossZero,
+  re as isNameLocationCenter,
+  H as makeLabelFormatter,
+  Y as niceScaleExtent,
+  T as retrieveAxisBreaksOption,
+  ne as shouldAxisShow,
+  ee as shouldShowAllLabels,
+  te as unionAxisExtentFromData
+};

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

@@ -0,0 +1,15 @@
+var t = (
+  /** @class */
+  function() {
+    function o() {
+    }
+    return o.prototype.getNeedCrossZero = function() {
+      var n = this.option;
+      return !n.scale;
+    }, o.prototype.getCoordSysModel = function() {
+    }, o;
+  }()
+);
+export {
+  t as AxisModelCommonMixin
+};

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

@@ -0,0 +1,46 @@
+import { __extends as h } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import c from "./axisDefault.js";
+import { fetchLayoutMode as M, getLayoutParams as A, mergeLayoutParam as v } from "../util/layout.js";
+import x from "../data/OrdinalMeta.js";
+import { AXIS_TYPES as _ } from "./axisCommonTypes.js";
+import { each as O, merge as i } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { getAxisBreakHelper as k } from "../component/axis/axisBreakHelper.js";
+function T(o, n, f, l) {
+  O(_, function(B, a) {
+    var d = i(i({}, c[a], !0), l, !0), m = (
+      /** @class */
+      function(u) {
+        h(e, u);
+        function e() {
+          var t = u !== null && u.apply(this, arguments) || this;
+          return t.type = n + "Axis." + a, t;
+        }
+        return e.prototype.mergeDefaultAndTheme = function(t, r) {
+          var p = M(this), y = p ? A(t) : {}, g = r.getTheme();
+          i(t, g.get(a + "Axis")), i(t, this.getDefaultOption()), t.type = s(t), p && v(t, y, p);
+        }, e.prototype.optionUpdated = function() {
+          var t = this.option;
+          t.type === "category" && (this.__ordinalMeta = x.createByAxisModel(this));
+        }, e.prototype.getCategories = function(t) {
+          var r = this.option;
+          if (r.type === "category")
+            return t ? r.data : this.__ordinalMeta.categories;
+        }, e.prototype.getOrdinalMeta = function() {
+          return this.__ordinalMeta;
+        }, e.prototype.updateAxisBreaks = function(t) {
+          var r = k();
+          return r ? r.updateModelAxisBreak(this, t) : {
+            breaks: []
+          };
+        }, e.type = n + "Axis." + a, e.defaultOption = d, e;
+      }(f)
+    );
+    o.registerComponentModel(m);
+  }), o.registerSubTypeDefaulter(n + "Axis", s);
+}
+function s(o) {
+  return o.type || (o.data ? "category" : "value");
+}
+export {
+  T as default
+};