yahee-components 0.0.70 → 0.0.71

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/scale/breakImpl.js

@@ -0,0 +1,311 @@
+import { map as P, find as A, each as l, clone as _, isString as S, trim as N, assert as k } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { error as d } from "../util/log.js";
+import { registerScaleBreakHelperImpl as R } from "./break.js";
+import { round as M } from "../util/number.js";
+var F = (
+  /** @class */
+  function() {
+    function n() {
+      this.breaks = [], this._elapsedExtent = [1 / 0, -1 / 0];
+    }
+    return n.prototype.setBreaks = function(t) {
+      this.breaks = t.breaks;
+    }, n.prototype.update = function(t) {
+      T(this, t);
+      var i = this._elapsedExtent;
+      i[0] = this.elapse(t[0]), i[1] = this.elapse(t[1]);
+    }, n.prototype.hasBreaks = function() {
+      return !!this.breaks.length;
+    }, n.prototype.calcNiceTickMultiple = function(t, i) {
+      for (var p = 0; p < this.breaks.length; p++) {
+        var v = this.breaks[p];
+        if (v.vmin < t && t < v.vmax) {
+          var a = i(t, v.vmax);
+          return process.env.NODE_ENV !== "production" && k(a >= 0 && Math.round(a) === a), a;
+        }
+      }
+      return 0;
+    }, n.prototype.getExtentSpan = function() {
+      return this._elapsedExtent[1] - this._elapsedExtent[0];
+    }, n.prototype.normalize = function(t) {
+      var i = this._elapsedExtent[1] - this._elapsedExtent[0];
+      return i === 0 ? 0.5 : (this.elapse(t) - this._elapsedExtent[0]) / i;
+    }, n.prototype.scale = function(t) {
+      return this.unelapse(t * (this._elapsedExtent[1] - this._elapsedExtent[0]) + this._elapsedExtent[0]);
+    }, n.prototype.elapse = function(t) {
+      for (var i = E, p = y, v = !0, a = 0; a < this.breaks.length; a++) {
+        var r = this.breaks[a];
+        if (t <= r.vmax) {
+          t > r.vmin ? i += r.vmin - p + (t - r.vmin) / (r.vmax - r.vmin) * r.gapReal : i += t - p, p = r.vmax, v = !1;
+          break;
+        }
+        i += r.vmin - p + r.gapReal, p = r.vmax;
+      }
+      return v && (i += t - p), i;
+    }, n.prototype.unelapse = function(t) {
+      for (var i = E, p = y, v = !0, a = 0, r = 0; r < this.breaks.length; r++) {
+        var e = this.breaks[r], s = i + e.vmin - p, o = s + e.gapReal;
+        if (t <= o) {
+          t > s ? a = e.vmin + (t - s) / (o - s) * (e.vmax - e.vmin) : a = p + t - i, p = e.vmax, v = !1;
+          break;
+        }
+        i = o, p = e.vmax;
+      }
+      return v && (a = p + t - i), a;
+    }, n;
+  }()
+);
+function I() {
+  return new F();
+}
+var E = 0, y = 0;
+function T(n, t) {
+  var i = 0, p = {
+    tpAbs: {
+      span: 0,
+      val: 0
+    },
+    tpPrct: {
+      span: 0,
+      val: 0
+    }
+  }, v = function() {
+    return {
+      has: !1,
+      span: NaN,
+      inExtFrac: NaN,
+      val: NaN
+    };
+  }, a = {
+    S: {
+      tpAbs: v(),
+      tpPrct: v()
+    },
+    E: {
+      tpAbs: v(),
+      tpPrct: v()
+    }
+  };
+  l(n.breaks, function(e) {
+    var s = e.gapParsed;
+    s.type === "tpPrct" && (i += s.val);
+    var o = x(e, t);
+    if (o) {
+      var u = o.vmin !== e.vmin, f = o.vmax !== e.vmax, c = o.vmax - o.vmin;
+      if (!(u && f)) if (u || f) {
+        var m = u ? "S" : "E";
+        a[m][s.type].has = !0, a[m][s.type].span = c, a[m][s.type].inExtFrac = c / (e.vmax - e.vmin), a[m][s.type].val = s.val;
+      } else
+        p[s.type].span += c, p[s.type].val += s.val;
+    }
+  });
+  var r = i * (0 + (t[1] - t[0]) + (p.tpAbs.val - p.tpAbs.span) + (a.S.tpAbs.has ? (a.S.tpAbs.val - a.S.tpAbs.span) * a.S.tpAbs.inExtFrac : 0) + (a.E.tpAbs.has ? (a.E.tpAbs.val - a.E.tpAbs.span) * a.E.tpAbs.inExtFrac : 0) - p.tpPrct.span - (a.S.tpPrct.has ? a.S.tpPrct.span * a.S.tpPrct.inExtFrac : 0) - (a.E.tpPrct.has ? a.E.tpPrct.span * a.E.tpPrct.inExtFrac : 0)) / (1 - p.tpPrct.val - (a.S.tpPrct.has ? a.S.tpPrct.val * a.S.tpPrct.inExtFrac : 0) - (a.E.tpPrct.has ? a.E.tpPrct.val * a.E.tpPrct.inExtFrac : 0));
+  l(n.breaks, function(e) {
+    var s = e.gapParsed;
+    s.type === "tpPrct" && (e.gapReal = i !== 0 ? Math.max(r, 0) * s.val / i : 0), s.type === "tpAbs" && (e.gapReal = s.val), e.gapReal == null && (e.gapReal = 0);
+  });
+}
+function O(n, t, i, p, v, a) {
+  n !== "no" && l(i, function(r) {
+    var e = x(r, a);
+    if (e)
+      for (var s = t.length - 1; s >= 0; s--) {
+        var o = t[s], u = p(o), f = v * 3 / 4;
+        u > e.vmin - f && u < e.vmax + f && (n !== "preserve_extent_bound" || u !== a[0] && u !== a[1]) && t.splice(s, 1);
+      }
+  });
+}
+function D(n, t, i, p) {
+  l(t, function(v) {
+    var a = x(v, i);
+    a && (n.push({
+      value: a.vmin,
+      break: {
+        type: "vmin",
+        parsedBreak: a
+      },
+      time: p ? p(a) : void 0
+    }), n.push({
+      value: a.vmax,
+      break: {
+        type: "vmax",
+        parsedBreak: a
+      },
+      time: p ? p(a) : void 0
+    }));
+  }), t.length && n.sort(function(v, a) {
+    return v.value - a.value;
+  });
+}
+function x(n, t) {
+  var i = Math.max(n.vmin, t[0]), p = Math.min(n.vmax, t[1]);
+  return i < p || i === p && i > t[0] && i < t[1] ? {
+    vmin: i,
+    vmax: p,
+    breakOption: n.breakOption,
+    gapParsed: n.gapParsed,
+    gapReal: n.gapReal
+  } : null;
+}
+function g(n, t, i) {
+  var p = [];
+  if (!n)
+    return {
+      breaks: p
+    };
+  function v(r, e) {
+    return r >= 0 && r < 1 - 1e-5 ? !0 : (process.env.NODE_ENV !== "production" && d(e + " must be >= 0 and < 1, rather than " + r + " ."), !1);
+  }
+  l(n, function(r) {
+    if (!r || r.start == null || r.end == null) {
+      process.env.NODE_ENV !== "production" && d("The input axis breaks start/end should not be empty.");
+      return;
+    }
+    if (!r.isExpanded) {
+      var e = {
+        breakOption: _(r),
+        vmin: t(r.start),
+        vmax: t(r.end),
+        gapParsed: {
+          type: "tpAbs",
+          val: 0
+        },
+        gapReal: null
+      };
+      if (r.gap != null) {
+        var s = !1;
+        if (S(r.gap)) {
+          var o = N(r.gap);
+          if (o.match(/%$/)) {
+            var u = parseFloat(o) / 100;
+            v(u, "Percent gap") || (u = 0), e.gapParsed.type = "tpPrct", e.gapParsed.val = u, s = !0;
+          }
+        }
+        if (!s) {
+          var f = t(r.gap);
+          (!isFinite(f) || f < 0) && (process.env.NODE_ENV !== "production" && d("Axis breaks gap must positive finite rather than (" + r.gap + ")."), f = 0), e.gapParsed.type = "tpAbs", e.gapParsed.val = f;
+        }
+      }
+      if (e.vmin === e.vmax && (e.gapParsed.type = "tpAbs", e.gapParsed.val = 0), i && i.noNegative && l(["vmin", "vmax"], function(m) {
+        e[m] < 0 && (process.env.NODE_ENV !== "production" && d("Axis break." + m + " must not be negative."), e[m] = 0);
+      }), e.vmin > e.vmax) {
+        var c = e.vmax;
+        e.vmax = e.vmin, e.vmin = c;
+      }
+      p.push(e);
+    }
+  }), p.sort(function(r, e) {
+    return r.vmin - e.vmin;
+  });
+  var a = -1 / 0;
+  return l(p, function(r, e) {
+    a > r.vmin && (process.env.NODE_ENV !== "production" && d("Axis breaks must not overlap."), p[e] = null), a = r.vmax;
+  }), {
+    breaks: p.filter(function(r) {
+      return !!r;
+    })
+  };
+}
+function B(n, t) {
+  return h(t) === h(n);
+}
+function h(n) {
+  return n.start + "_\0_" + n.end;
+}
+function w(n, t, i) {
+  var p = [];
+  l(n, function(a, r) {
+    var e = t(a);
+    e && e.type === "vmin" && p.push([r]);
+  }), l(n, function(a, r) {
+    var e = t(a);
+    if (e && e.type === "vmax") {
+      var s = A(
+        p,
+        // parsedBreak may be changed, can only use breakOption to match them.
+        function(o) {
+          return B(t(n[o[0]]).parsedBreak.breakOption, e.parsedBreak.breakOption);
+        }
+      );
+      s && s.push(r);
+    }
+  });
+  var v = [];
+  return l(p, function(a) {
+    a.length === 2 && v.push(i ? a : [n[a[0]], n[a[1]]]);
+  }), v;
+}
+function K(n, t, i, p) {
+  var v, a;
+  if (n.break) {
+    var r = n.break.parsedBreak, e = A(i, function(f) {
+      return B(f.breakOption, n.break.parsedBreak.breakOption);
+    }), s = p(Math.pow(t, r.vmin), e.vmin), o = p(Math.pow(t, r.vmax), e.vmax), u = {
+      type: r.gapParsed.type,
+      val: r.gapParsed.type === "tpAbs" ? M(Math.pow(t, r.vmin + r.gapParsed.val)) - s : r.gapParsed.val
+    };
+    v = {
+      type: n.break.type,
+      parsedBreak: {
+        breakOption: r.breakOption,
+        vmin: s,
+        vmax: o,
+        gapParsed: u,
+        gapReal: r.gapReal
+      }
+    }, a = e[n.break.type];
+  }
+  return {
+    brkRoundingCriterion: a,
+    vBreak: v
+  };
+}
+function L(n, t, i) {
+  var p = {
+    noNegative: !0
+  }, v = g(n, i, p), a = g(n, i, p), r = Math.log(t);
+  return a.breaks = P(a.breaks, function(e) {
+    var s = Math.log(e.vmin) / r, o = Math.log(e.vmax) / r, u = {
+      type: e.gapParsed.type,
+      val: e.gapParsed.type === "tpAbs" ? Math.log(e.vmin + e.gapParsed.val) / r - s : e.gapParsed.val
+    };
+    return {
+      vmin: s,
+      vmax: o,
+      gapParsed: u,
+      gapReal: e.gapReal,
+      breakOption: e.breakOption
+    };
+  }), {
+    parsedOriginal: v,
+    parsedLogged: a
+  };
+}
+var X = {
+  vmin: "start",
+  vmax: "end"
+};
+function b(n, t) {
+  return t && (n = n || {}, n.break = {
+    type: X[t.type],
+    start: t.parsedBreak.vmin,
+    end: t.parsedBreak.vmax
+  }), n;
+}
+function q() {
+  R({
+    createScaleBreakContext: I,
+    pruneTicksByBreak: O,
+    addBreaksToTicks: D,
+    parseAxisBreakOption: g,
+    identifyAxisBreak: B,
+    serializeAxisBreakIdentifier: h,
+    retrieveAxisBreakPairs: w,
+    getTicksLogTransformBreak: K,
+    logarithmicParseBreaksFromOption: L,
+    makeAxisLabelFormatterParamBreak: b
+  });
+}
+export {
+  q as installScaleBreakHelper
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/scale/helper.js

@@ -0,0 +1,69 @@
+import { getPrecision as v, nice as m, round as s, quantityExponent as p } from "../util/number.js";
+import { bind as h } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+function S(r) {
+  var a = Math.pow(10, p(Math.abs(r))), i = Math.abs(r / a);
+  return i === 0 || i === 1 || i === 2 || i === 3 || i === 5;
+}
+function P(r) {
+  return r.type === "interval" || r.type === "log";
+}
+function w(r, a, i, l, u) {
+  var n = {}, o = n.interval = m(a / i);
+  l != null && o < l && (o = n.interval = l), u != null && o > u && (o = n.interval = u);
+  var f = n.intervalPrecision = g(o), M = n.niceTickExtent = [s(Math.ceil(r[0] / o) * o, f), s(Math.floor(r[1] / o) * o, f)];
+  return z(M, r), n;
+}
+function B(r) {
+  var a = Math.pow(10, p(r)), i = r / a;
+  return i ? i === 2 ? i = 3 : i === 3 ? i = 5 : i *= 2 : i = 1, s(i * a);
+}
+function g(r) {
+  return v(r) + 2;
+}
+function c(r, a, i) {
+  r[a] = Math.max(Math.min(r[a], i[1]), i[0]);
+}
+function z(r, a) {
+  !isFinite(r[0]) && (r[0] = a[0]), !isFinite(r[1]) && (r[1] = a[1]), c(r, 0, a), c(r, 1, a), r[0] > r[1] && (r[0] = r[1]);
+}
+function F(r, a) {
+  return r >= a[0] && r <= a[1];
+}
+var q = (
+  /** @class */
+  function() {
+    function r() {
+      this.normalize = t, this.scale = e;
+    }
+    return r.prototype.updateMethods = function(a) {
+      a.hasBreaks() ? (this.normalize = h(a.normalize, a), this.scale = h(a.scale, a)) : (this.normalize = t, this.scale = e);
+    }, r;
+  }()
+);
+function t(r, a) {
+  return a[1] === a[0] ? 0.5 : (r - a[0]) / (a[1] - a[0]);
+}
+function e(r, a) {
+  return r * (a[1] - a[0]) + a[0];
+}
+function L(r, a, i) {
+  var l = Math.log(r);
+  return [
+    // log(negative) is NaN, so safe guard here.
+    // PENDING: But even getting a -Infinity still does not make sense in extent.
+    //  Just keep it as is, getting a NaN to make some previous cases works by coincidence.
+    Math.log(i ? a[0] : Math.max(0, a[0])) / l,
+    Math.log(i ? a[1] : Math.max(0, a[1])) / l
+  ];
+}
+export {
+  q as ScaleCalculator,
+  F as contain,
+  z as fixExtent,
+  g as getIntervalPrecision,
+  B as increaseInterval,
+  w as intervalScaleNiceTicks,
+  P as isIntervalOrLogScale,
+  S as isValueNice,
+  L as logTransform
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/theme/dark.js

@@ -0,0 +1,287 @@
+import t from "../visual/tokens.js";
+var e = t.darkColor, a = e.background, r = function() {
+  return {
+    axisLine: {
+      lineStyle: {
+        color: e.axisLine
+      }
+    },
+    splitLine: {
+      lineStyle: {
+        color: e.axisSplitLine
+      }
+    },
+    splitArea: {
+      areaStyle: {
+        color: [e.backgroundTint, e.backgroundTransparent]
+      }
+    },
+    minorSplitLine: {
+      lineStyle: {
+        color: e.axisMinorSplitLine
+      }
+    },
+    axisLabel: {
+      color: e.axisLabel
+    },
+    axisName: {}
+  };
+}, l = {
+  label: {
+    color: e.secondary
+  },
+  itemStyle: {
+    borderColor: e.borderTint
+  },
+  dividerLineStyle: {
+    color: e.border
+  }
+}, i = {
+  darkMode: !0,
+  color: e.theme,
+  backgroundColor: a,
+  axisPointer: {
+    lineStyle: {
+      color: e.border
+    },
+    crossStyle: {
+      color: e.borderShade
+    },
+    label: {
+      color: e.tertiary
+    }
+  },
+  legend: {
+    textStyle: {
+      color: e.secondary
+    },
+    pageTextStyle: {
+      color: e.tertiary
+    }
+  },
+  textStyle: {
+    color: e.secondary
+  },
+  title: {
+    textStyle: {
+      color: e.primary
+    },
+    subtextStyle: {
+      color: e.quaternary
+    }
+  },
+  toolbox: {
+    iconStyle: {
+      borderColor: e.accent50
+    }
+  },
+  tooltip: {
+    backgroundColor: e.neutral20,
+    defaultBorderColor: e.border,
+    textStyle: {
+      color: e.tertiary
+    }
+  },
+  dataZoom: {
+    borderColor: e.accent10,
+    textStyle: {
+      color: e.tertiary
+    },
+    brushStyle: {
+      color: e.backgroundTint
+    },
+    handleStyle: {
+      color: e.neutral00,
+      borderColor: e.accent20
+    },
+    moveHandleStyle: {
+      color: e.accent40
+    },
+    emphasis: {
+      handleStyle: {
+        borderColor: e.accent50
+      }
+    },
+    dataBackground: {
+      lineStyle: {
+        color: e.accent30
+      },
+      areaStyle: {
+        color: e.accent20
+      }
+    },
+    selectedDataBackground: {
+      lineStyle: {
+        color: e.accent50
+      },
+      areaStyle: {
+        color: e.accent30
+      }
+    }
+  },
+  visualMap: {
+    textStyle: {
+      color: e.secondary
+    },
+    handleStyle: {
+      borderColor: e.neutral30
+    }
+  },
+  timeline: {
+    lineStyle: {
+      color: e.accent10
+    },
+    label: {
+      color: e.tertiary
+    },
+    controlStyle: {
+      color: e.accent30,
+      borderColor: e.accent30
+    }
+  },
+  calendar: {
+    itemStyle: {
+      color: e.neutral00,
+      borderColor: e.neutral20
+    },
+    dayLabel: {
+      color: e.tertiary
+    },
+    monthLabel: {
+      color: e.secondary
+    },
+    yearLabel: {
+      color: e.secondary
+    }
+  },
+  matrix: {
+    x: l,
+    y: l,
+    backgroundColor: {
+      borderColor: e.axisLine
+    },
+    body: {
+      itemStyle: {
+        borderColor: e.borderTint
+      }
+    }
+  },
+  timeAxis: r(),
+  logAxis: r(),
+  valueAxis: r(),
+  categoryAxis: r(),
+  line: {
+    symbol: "circle"
+  },
+  graph: {
+    color: e.theme
+  },
+  gauge: {
+    title: {
+      color: e.secondary
+    },
+    axisLine: {
+      lineStyle: {
+        color: [[1, e.neutral05]]
+      }
+    },
+    axisLabel: {
+      color: e.axisLabel
+    },
+    detail: {
+      color: e.primary
+    }
+  },
+  candlestick: {
+    itemStyle: {
+      color: "#f64e56",
+      color0: "#54ea92",
+      borderColor: "#f64e56",
+      borderColor0: "#54ea92"
+      // borderColor: '#ca2824',
+      // borderColor0: '#09a443'
+    }
+  },
+  funnel: {
+    itemStyle: {
+      borderColor: e.background
+    }
+  },
+  radar: function() {
+    var o = r();
+    return o.axisName = {
+      color: e.axisLabel
+    }, o.axisLine.lineStyle.color = e.neutral20, o;
+  }(),
+  treemap: {
+    breadcrumb: {
+      itemStyle: {
+        color: e.neutral20,
+        textStyle: {
+          color: e.secondary
+        }
+      },
+      emphasis: {
+        itemStyle: {
+          color: e.neutral30
+        }
+      }
+    }
+  },
+  sunburst: {
+    itemStyle: {
+      borderColor: e.background
+    }
+  },
+  map: {
+    itemStyle: {
+      borderColor: e.border,
+      areaColor: e.neutral10
+    },
+    label: {
+      color: e.tertiary
+    },
+    emphasis: {
+      label: {
+        color: e.primary
+      },
+      itemStyle: {
+        areaColor: e.highlight
+      }
+    },
+    select: {
+      label: {
+        color: e.primary
+      },
+      itemStyle: {
+        areaColor: e.highlight
+      }
+    }
+  },
+  geo: {
+    itemStyle: {
+      borderColor: e.border,
+      areaColor: e.neutral10
+    },
+    emphasis: {
+      label: {
+        color: e.primary
+      },
+      itemStyle: {
+        areaColor: e.highlight
+      }
+    },
+    select: {
+      label: {
+        color: e.primary
+      },
+      itemStyle: {
+        color: e.highlight
+      }
+    }
+  }
+};
+i.categoryAxis.splitLine.show = !1;
+export {
+  i as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/ECEventProcessor.js

@@ -0,0 +1,54 @@
+import { isString as m, each as y } from "../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { parseClassType as E } from "./clazz.js";
+var I = (
+  /** @class */
+  function() {
+    function p() {
+    }
+    return p.prototype.normalizeQuery = function(d) {
+      var t = {}, o = {}, f = {};
+      if (m(d)) {
+        var v = E(d);
+        t.mainType = v.main || null, t.subType = v.sub || null;
+      } else {
+        var a = ["Index", "Name", "Id"], l = {
+          name: 1,
+          dataIndex: 1,
+          dataType: 1
+        };
+        y(d, function(n, r) {
+          for (var e = !1, u = 0; u < a.length; u++) {
+            var c = a[u], i = r.lastIndexOf(c);
+            if (i > 0 && i === r.length - c.length) {
+              var s = r.slice(0, i);
+              s !== "data" && (t.mainType = s, t[c.toLowerCase()] = n, e = !0);
+            }
+          }
+          l.hasOwnProperty(r) && (o[r] = n, e = !0), e || (f[r] = n);
+        });
+      }
+      return {
+        cptQuery: t,
+        dataQuery: o,
+        otherQuery: f
+      };
+    }, p.prototype.filter = function(d, t) {
+      var o = this.eventInfo;
+      if (!o)
+        return !0;
+      var f = o.targetEl, v = o.packedEvent, a = o.model, l = o.view;
+      if (!a || !l)
+        return !0;
+      var n = t.cptQuery, r = t.dataQuery;
+      return e(n, a, "mainType") && e(n, a, "subType") && e(n, a, "index", "componentIndex") && e(n, a, "name") && e(n, a, "id") && e(r, v, "name") && e(r, v, "dataIndex") && e(r, v, "dataType") && (!l.filterForExposedEvent || l.filterForExposedEvent(d, t.otherQuery, f, v));
+      function e(u, c, i, s) {
+        return u[i] == null || c[s || i] === u[i];
+      }
+    }, p.prototype.afterTrigger = function() {
+      this.eventInfo = null;
+    }, p;
+  }()
+);
+export {
+  I as ECEventProcessor
+};