evui 3.4.214 → 3.5.0

package/dist/components/chart/scale/scale.linear.js

@@ -0,0 +1,248 @@
+import { truthyNumber as I } from "../../../common/utils.js";
+import F from "./scale.js";
+import P from "../helpers/helpers.util.js";
+import { NICE_FRACTIONS as y } from "../helpers/helpers.constant.js";
+class j extends F {
+  /**
+   * Transforming label by designated format
+   * @param {number} value                   label value
+   * @param {object} data                   data for formatting
+   *
+   * @returns {string} formatted label
+   */
+  getTruthyValue(t) {
+    const e = this.adjustedDecimalPoint ?? this.decimalPoint;
+    return I(t) ? Number(t.toFixed(e)) : t;
+  }
+  getLabelFormat(t, e = {}) {
+    if (this.formatter) {
+      const s = this.getTruthyValue(t), a = this.formatter(s, {
+        ...e,
+        prevOriginalValue: e == null ? void 0 : e.prev,
+        prevDecimalPointValue: this.getTruthyValue(e == null ? void 0 : e.prev),
+        currentOriginalValue: t,
+        currentDecimalPointValue: s
+      });
+      if (typeof a == "string")
+        return a;
+    }
+    const i = this.adjustedDecimalPoint ?? this.decimalPoint;
+    return P.labelSignFormat(t, i);
+  }
+  /**
+   * Calculate interval
+   * @param {object} range    range information
+   *
+   * @returns {number}  interval (한 칸에 표시할 값의 간격)
+   */
+  getInterval(t) {
+    if (this.interval) return this.interval;
+    let e = 0;
+    const i = t.maxValue, s = t.minValue, a = t.maxSteps;
+    if (!a || a <= 0) return 0;
+    if (this.startToZero && s < 0) {
+      const n = Math.abs(s) + Math.abs(i), c = Math.abs(s) / n, b = Math.abs(i) / n;
+      let g = Math.max(1, Math.round(c * a)), p = Math.max(1, a - g);
+      g + p > a && (c > b ? g -= 1 : p -= 1), e = Math.max(
+        Math.abs(s) / (g || 1),
+        Math.abs(i) / (p || 1)
+      );
+    } else
+      e = (i - s) / a;
+    return this.decimalPoint ? e : Math.ceil(e);
+  }
+  /**
+   * 주어진 값에 대한 적절한 간격을 계산합니다.
+   * @param value - 계산할 값 (양수, 음수 모두 가능)
+   * @returns 계산된 간격 값 (유효하지 않은 경우 0 반환)
+   */
+  getNiceInterval(t) {
+    if (!Number.isFinite(t) || t === 0) return 0;
+    const e = Math.abs(t), i = Math.floor(Math.log10(e)), s = e / 10 ** i;
+    let a = 10;
+    for (let c = 0; c < y.length; c++)
+      if (y[c] >= s) {
+        a = y[c];
+        break;
+      }
+    const n = a * 10 ** i;
+    return t < 0 ? -n : n;
+  }
+  /** 
+   * user range를 사용하지 않을때 nice scale 계산
+   * graph MIN / MAX 를 조정할 수 있다.
+   * @param {number} max
+   * @param {number} min
+   * @param {number} maxSteps
+   * @returns {object}
+   */
+  getStepsWithNiceScale({ max: t, min: e, maxSteps: i }) {
+    let s = t, a = e, n = 0, c = 0, b = 1 / 0;
+    const g = Math.max(1, i - 1), p = i + 1;
+    for (let u = g; u <= p; u++) {
+      const M = (t - e) / u, f = this.getNiceInterval(M);
+      if (f > 0) {
+        const v = Math.floor(e / f) * f, x = v + f * u;
+        if (x >= t) {
+          const S = e - v, d = x - t, o = S + d;
+          o < b && (s = x, a = v, n = f, c = u, b = o);
+        }
+      }
+    }
+    if (!(n > 0) || c <= 0) {
+      const u = Math.max(1, i), M = (t - e) / u || 1;
+      return {
+        max: t,
+        min: e,
+        interval: M,
+        steps: u
+      };
+    }
+    return {
+      max: s,
+      min: a,
+      interval: n,
+      steps: c
+    };
+  }
+  /**
+   * graphRange와 step 수를 기반으로 필요한 소수점 자릿수를 계산
+   * @param {object} params
+   * @param {number} params.graphRange
+   * @param {number} params.numberOfSteps
+   * @returns {number} decimal places (0 이상)
+   */
+  getDecimalPointFromRange({ graphRange: t, numberOfSteps: e }) {
+    if (!Number.isFinite(t) || !Number.isFinite(e) || t <= 0 || e <= 0)
+      return 0;
+    const i = t / e;
+    if (!Number.isFinite(i) || i === 0)
+      return 0;
+    const s = Math.abs(i);
+    if (s >= 1)
+      return 0;
+    let a = 0, n = s;
+    for (; n < 1 && a < 10; )
+      n *= 10, a += 1;
+    return a;
+  }
+  /**
+   * With range information, calculate how many labels in axis
+   * @param {object} range    min/max information
+   *
+   * @returns {object} steps, interval, min/max graph value
+   */
+  calculateSteps(t) {
+    const { minValue: e, maxValue: i } = t, s = Math.max(1, t.maxSteps ?? 1), a = Array.isArray(this.range) && this.range.length === 2, c = typeof this.interval == "number" || typeof this.interval == "object" && this.interval !== null ? this.getInterval(t) : null, b = c != null && c > 0 && Number.isFinite(c), g = a ? +this.range[0] : null, p = a ? +this.range[1] : null, u = 1e-10, M = (o, h, r) => {
+      var m;
+      if (this.decimalPoint === "auto") {
+        const l = (m = this.getDecimalPointFromRange) == null ? void 0 : m.call(this, {
+          graphRange: o,
+          numberOfSteps: h
+        });
+        l != null && !Number.isNaN(l) ? this.adjustedDecimalPoint = l : typeof this.getAutoDecimalPointFromInterval == "function" ? this.adjustedDecimalPoint = this.getAutoDecimalPointFromInterval(r) : this.adjustedDecimalPoint = 0;
+      } else
+        this.adjustedDecimalPoint = this.decimalPoint;
+    }, f = (o, h) => Math.max(1, Math.round(o / h + u)), v = ({ min: o, max: h, interval: r }) => {
+      let m = 0, l = 0;
+      return o >= 0 ? (m = +o, l = Math.ceil(h / r) * r) : h >= 0 ? (m = Math.floor(o / r) * r, l = Math.ceil(h / r) * r) : (l = +h, m = Math.floor(o / r) * r), { graphMin: m, graphMax: l };
+    };
+    if (a && b) {
+      const o = g, h = p, r = c, m = h - o, l = m / r;
+      if (Math.abs(l - Math.round(l)) < u || this.fixedSteps) {
+        const V = Math.round(l);
+        return M(m, V, r), {
+          steps: V,
+          interval: r,
+          graphMin: o,
+          graphMax: h
+        };
+      }
+    }
+    if (a) {
+      const o = g, h = p, r = h - o, m = s, l = r / m;
+      return M(r, m, l), {
+        steps: m,
+        interval: l,
+        graphMin: o,
+        graphMax: h
+      };
+    }
+    if (b) {
+      let o = c, h = 0, r = 0, m = 0, l = 0;
+      for ({ graphMin: h, graphMax: r } = v({
+        min: e,
+        max: i,
+        interval: o
+      }), m = r - h, l = f(m, o); l > s; )
+        o *= 2, { graphMin: h, graphMax: r } = v({
+          min: e,
+          max: i,
+          interval: o
+        }), m = r - h, l = f(m, o);
+      return M(m, l, o), {
+        steps: l,
+        interval: o,
+        graphMin: h,
+        graphMax: r
+      };
+    }
+    const x = this.startToZero && e >= 0 ? 0 : e, S = this.startToZero && i <= 0 ? 0 : i, d = this.getStepsWithNiceScale({
+      min: x,
+      max: S,
+      maxSteps: s
+    });
+    return M(
+      d.max - d.min,
+      d.steps,
+      d.interval
+    ), {
+      steps: d.steps,
+      interval: d.interval,
+      graphMin: d.min,
+      graphMax: d.max
+    };
+  }
+  /**
+   * Calculate min/max value, label and size information for axis
+   * @param {object} minMax    min/max information
+   * @param {object} scrollbarOpt scrollbar option
+   *
+   * @returns {object} min/max value and label
+   */
+  calculateScaleRange(t, e) {
+    var p;
+    let i, s, a = !1;
+    const n = e != null && e.use ? e == null ? void 0 : e.range : this.range;
+    Array.isArray(n) && (n == null ? void 0 : n.length) === 2 ? this.options.type === "heatMap" ? (i = n[1] > +t.max ? +t.max : n[1], s = n[0] < +t.min ? +t.min : n[0]) : (i = n[1], s = n[0]) : typeof n == "function" ? [s, i] = n(t.min, t.max) : (i = t.max, s = t.min);
+    const c = Array.isArray(this.range) && this.range.length === 2;
+    if (this.autoScaleRatio && !c) {
+      const u = i, M = i * (this.autoScaleRatio + 1);
+      if (i = this.decimalPoint ? M : Math.ceil(M), i > 0 && s < 0) {
+        const f = u - i;
+        s += f;
+      } else if (i < 0 && s < 0) {
+        const f = s * (this.autoScaleRatio + 1);
+        s = this.decimalPoint ? f : Math.ceil(f);
+      }
+    }
+    this.startToZero && !c && (s > 0 && (s = 0), i < 0 && (i = 0)), i === s && (i += 1, a = !0);
+    const b = this.getLabelFormat(s), g = this.getLabelFormat(i, {
+      isMaxValueSameAsMin: a
+    });
+    return {
+      min: s,
+      max: i,
+      minLabel: b,
+      maxLabel: g,
+      size: P.calcTextSizeCanvas(
+        g,
+        P.getLabelStyle(this.labelStyle),
+        (p = this.labelStyle) == null ? void 0 : p.padding
+      )
+    };
+  }
+}
+export {
+  j as default
+};

package/dist/components/chart/scale/scale.logarithmic.js

@@ -0,0 +1,82 @@
+import h from "./scale.js";
+import s from "../helpers/helpers.util.js";
+class M extends h {
+  /**
+   * Calculate min/max value, label and size information for logarithmic scale
+   * @param {object} minMax    min/max information
+   *
+   * @returns {object} min/max value and label
+   */
+  calculateScaleRange(a) {
+    let t, e, r = !1;
+    Array.isArray(this.range) && this.range.length === 2 ? (t = this.range[1], e = this.range[0]) : typeof range == "function" ? [e, t] = this.range(a.min, a.max) : (t = a.max, e = a.min);
+    const n = s.calculateMagnitude(t - e);
+    t = Math.ceil(t / 10 ** n) * 10 ** n, this.startToZero && (e = 0), t === e && (t += 1, r = !0);
+    const m = this.getLabelFormat(e), l = this.getLabelFormat(t, {
+      isMaxValueSameAsMin: r
+    });
+    return {
+      min: e,
+      max: t,
+      minLabel: m,
+      maxLabel: l,
+      size: s.calcTextSize(l, s.getLabelStyle(this.labelStyle))
+    };
+  }
+  /**
+   * With range information, calculate how many labels in axis
+   * @param {object}  range          min/max information
+   * @param {boolean} skipFitting    determines if label skipping job.
+   *
+   * @returns {object} steps, interval, min/max graph value
+   */
+  calculateSteps(a, t) {
+    const e = a.maxValue, r = a.minValue, n = a.maxSteps, m = s.calculateMagnitude(e - r);
+    let l = this.getInterval(a), i;
+    const u = e, o = r, c = u - o;
+    for (i = Math.round(c / l), e === 1 && (l = 0.2, i = 5); (i > n || i * 2 < n) && !t; )
+      if (i > n)
+        l *= 2, i = Math.ceil(c / l);
+      else if (m >= 0)
+        if (l / 2 % 1 === 0)
+          l /= 2, i = Math.ceil(c / l);
+        else
+          break;
+      else
+        l /= 2, i = Math.ceil(c / l);
+    return {
+      steps: i,
+      interval: l,
+      graphMin: o,
+      graphMax: Math.ceil(o + i * l)
+    };
+  }
+  /**
+   * Transforming label by designated format
+   * @param {number} value                   label value
+   * @param {object} data                    data for formatting
+   *
+   * @returns {string} formatted label
+   */
+  getLabelFormat(a, t = {}) {
+    if (this.formatter) {
+      const e = this.formatter(a, t);
+      if (typeof e == "string")
+        return e;
+    }
+    return s.labelSignFormat(a, this.decimalPoint);
+  }
+  /**
+   * Calculate interval
+   * @param {object} range    range information
+   *
+   * @returns {number} interval
+   */
+  getInterval(a) {
+    const t = a.maxValue, e = a.minValue;
+    return 10 ** s.calculateMagnitude(t - e);
+  }
+}
+export {
+  M as default
+};

package/dist/components/chart/scale/scale.step.js

@@ -0,0 +1,227 @@
+import { defaultsDeep as Z } from "lodash-es";
+import { PLOT_BAND_OPTION as I, PLOT_LINE_OPTION as tt } from "../helpers/helpers.constant.js";
+import { bnMinus as O, bnPlus as it } from "../../../common/utils.bignumber.js";
+import { truthyNumber as R } from "../../../common/utils.js";
+import et from "./scale.js";
+import u from "../helpers/helpers.util.js";
+class xt extends et {
+  constructor(e, s, a, o, i) {
+    super(e, s, a, i), this.labels = o;
+  }
+  /**
+   * get max width from labelStyle
+   * maxWidth : number | string
+   * @param {object} chartRect chart size information
+   * @returns {number} max width
+   */
+  getMaxWidth(e) {
+    var a, o, i, t, l;
+    let s = ((a = this.labelStyle) == null ? void 0 : a.maxWidth) ?? e.chartWidth * 0.5;
+    return typeof ((o = this.labelStyle) == null ? void 0 : o.maxWidth) == "string" && ((i = this.labelStyle) != null && i.maxWidth.includes("%") ? s = e.chartWidth * (parseInt((t = this.labelStyle) == null ? void 0 : t.maxWidth.replace("%", "")) / 100) : s = parseInt((l = this.labelStyle) == null ? void 0 : l.maxWidth)), s;
+  }
+  /**
+   * Calculate min/max value, label and size information for step scale
+   * @param {object} minMax       min/max information (unused on step scale)
+   * @param {object} scrollbarOpt    scroll bar option
+   * @param {object} chartRect    chart size information
+   *
+   * @returns {object} min/max value and label
+   */
+  calculateScaleRange(e, s, a) {
+    const o = this.labelStyle.alignToGridLine ? e : u.getStringMinMax(this.labels);
+    let i = o.max, t = o.min, l = 0, n = this.labels.length - 1;
+    const r = s != null && s.use ? s == null ? void 0 : s.range : this.range;
+    if (Array.isArray(r) && (r != null && r.length)) {
+      const [w, x] = r;
+      R(w) && R(x) && (l = w < l ? l : w, n = x > n ? n : x, i = this.labels[n], t = this.labels[l]);
+    } else if (typeof r == "function") {
+      const [w, x] = r(t, i);
+      l = w < l ? l : w, n = x > n ? n : x, i = this.labels[n], t = this.labels[l];
+    }
+    const k = this.getMaxWidth(a);
+    return {
+      min: t,
+      max: i,
+      minIndex: l,
+      maxIndex: n,
+      minLabel: this.getLabelFormat(t, k),
+      maxLabel: this.getLabelFormat(i, k),
+      size: u.calcTextSizeCanvas(
+        this.getLabelFormat(i, k),
+        u.getLabelStyle(this.labelStyle)
+      )
+    };
+  }
+  getIndexInterval(e) {
+    const s = e.maxSteps;
+    return this.interval ? this.interval : Math.ceil(this.labels.length / s);
+  }
+  /**
+   * With range information, calculate how many labels in axis
+   * @param {object}  range          min/max information
+   *
+   * @returns {object} steps, interval, min/max graph value
+   */
+  calculateSteps(e) {
+    const { minValue: s, maxValue: a, minIndex: o, maxIndex: i } = e, t = i - o + 1;
+    let l = 1;
+    const n = this.labels.every((r) => !isNaN(r));
+    return this.labelStyle.alignToGridLine && n && (l = this.getIndexInterval(e)), {
+      oriSteps: t,
+      steps: t,
+      indexInterval: l,
+      graphMin: s,
+      graphMax: a,
+      minIndex: o,
+      maxIndex: i
+    };
+  }
+  /**
+   * Draw axis
+   * @param {object} chartRect  min/max information
+   * @param {object} labelOffset  label offset information
+   * @param {object} stepInfo  label steps information
+   * @param {object} hitInfo  legend Hit Info
+   * @param {object} selectedLabelInfo Selected Label Info
+   *
+   * @returns {undefined}
+   */
+  draw(e, s, a, o, i) {
+    var z, X, E, Y, _, V, D, H, K, U, $;
+    const t = this.ctx, l = this.labels, n = {
+      x1: e.x1 + s.left,
+      x2: e.x2 - s.right,
+      y1: e.y1 + s.top,
+      y2: e.y2 - s.bottom
+    }, r = a.steps, k = a.indexInterval, w = a.minIndex, x = n[this.units.rectStart], A = n[this.units.rectEnd], d = n[this.units.rectOffset(this.position)], N = n[this.units.rectOffsetCounter(this.position)], F = this.getMaxWidth(e), B = 5;
+    if (this.drawAxisTitle(e, s), (z = this.labelStyle) != null && z.show) {
+      t.font = u.getLabelStyle(this.labelStyle), this.type === "x" ? (t.textAlign = "center", t.textBaseline = this.position === "top" ? "bottom" : "top") : (t.textAlign = this.position === "left" ? "right" : "left", t.textBaseline = "middle"), t.fillStyle = this.labelStyle.color, t.lineWidth = this.axisLineWidth;
+      const L = u.aliasPixel(t.lineWidth);
+      if (t.beginPath(), t.strokeStyle = this.axisLineColor, this.type === "x" ? (t.moveTo(x, d + L), t.lineTo(A, d + L)) : (t.moveTo(d + L, x), t.lineTo(d + L, A)), t.stroke(), r === 0)
+        return;
+      const S = (A - x) / r, P = this.labelStyle.alignToGridLine;
+      let h = null, m = null;
+      t.beginPath(), t.strokeStyle = this.gridLineColor;
+      let f, y, b;
+      const W = [];
+      for (b = 0; b < r; b += k) {
+        const T = w + b, p = this.labels[T];
+        h = Math.round(x + S * b), m = h + L, f = this.getLabelFormat(p, F);
+        const { selectLabel: g, selectItem: c, horizontal: M } = this.options;
+        let v;
+        i != null && i.targetAxis ? v = (i == null ? void 0 : i.targetAxis) === "yAxis" ? "y" : "x" : v = M ? "y" : "x";
+        const j = (g == null ? void 0 : g.use) && (g == null ? void 0 : g.useLabelOpacity) && v === this.type && ((X = i == null ? void 0 : i.dataIndex) == null ? void 0 : X.length) && !((E = i == null ? void 0 : i.dataIndex) != null && E.includes(T)), G = this.labelStyle.color;
+        let q = 1;
+        if (u.getColorStringType(G) === "RGBA" && (q = u.getOpacity(G)), t.fillStyle = u.colorStringToRgba(
+          G,
+          j ? (Y = this.options) == null ? void 0 : Y.unSelectedOpacity : q
+        ), this.type === "x") {
+          y = this.position === "top" ? d - 10 : d + 10;
+          const C = P ? h : h + S / 2;
+          if (t.fillText(this.checkFixWidth(f), C, y), !j && (c != null && c.showLabelTip) && (o != null && o.label) && !M) {
+            const J = o.label;
+            if (J === f) {
+              const Q = Math.round(t.measureText((_ = this.labelStyle) == null ? void 0 : _.fontSize).width);
+              u.showLabelTip({
+                ctx: this.ctx,
+                width: Math.round(t.measureText(J).width) + 10,
+                height: Q,
+                x: h + S / 2,
+                y: y + (Q - 2),
+                borderRadius: 2,
+                arrowSize: 3,
+                text: f,
+                backgroundColor: (V = c == null ? void 0 : c.labelTipStyle) == null ? void 0 : V.backgroundColor,
+                textColor: (D = c == null ? void 0 : c.labelTipStyle) == null ? void 0 : D.textColor
+              });
+            }
+          }
+          this.showAxisTick && (t.beginPath(), t.strokeStyle = this.axisLineColor, t.moveTo(h + S / 2, d), t.lineTo(h + S / 2, d + B), t.stroke(), t.closePath()), b > 0 && this.showGrid && (t.beginPath(), t.strokeStyle = this.gridLineColor, t.moveTo(m, d), t.lineTo(m, N), t.stroke(), t.closePath());
+        } else {
+          y = this.position === "left" ? d - 10 : d + 10;
+          const C = P ? h : h + S / 2;
+          t.fillText(this.checkFixWidth(f), y, C), W.push(f), this.showAxisTick && (t.beginPath(), t.strokeStyle = this.axisLineColor, t.moveTo(d + (this.axisLineWidth ?? 1), C), t.lineTo(d - B, C), t.stroke(), t.closePath()), b > 0 && this.showGrid && (t.beginPath(), t.strokeStyle = this.gridLineColor, t.moveTo(d, m), t.lineTo(N, m), t.stroke(), t.closePath());
+        }
+        t.stroke();
+      }
+      if (P && b >= this.labels.length) {
+        const T = O(+l[1], +l[0]), p = it(+l[l.length - 1], T);
+        if (isNaN(p) || k !== 1 && O(p, W[W.length - 1]) <= T)
+          return;
+        h = Math.round(x + S * l.length), m = h + L;
+        const g = this.getLabelFormat(`${p}`, F);
+        this.type === "x" ? (t.fillText(this.checkFixWidth(g), h, y), this.showGrid && (t.moveTo(m, d), t.lineTo(m, N))) : (t.fillText(this.checkFixWidth(g), y, h), this.showGrid && (t.moveTo(d, m), t.lineTo(N, m))), t.stroke();
+      }
+      t.closePath();
+    }
+    if ((H = this.plotBands) != null && H.length || (K = this.plotLines) != null && K.length) {
+      const L = u.aliasPixel(t.lineWidth) + 1, S = n.x1 + L, P = n.x2, h = n.y1 + L, m = n.y2, f = (A - x) / (this.labelStyle.show ? l.length : 1);
+      (U = this.plotBands) == null || U.forEach((y) => {
+        if (!y.from && !y.to)
+          return;
+        const b = Z({}, y, I), { from: W = 0, to: T = l.length, label: p } = b, g = Math.round(x + f * W), c = Math.round(x + f * T);
+        if (this.setPlotBandStyle(b), this.type === "x" ? this.drawXPlotBand(g, c, S, P, h, m) : this.drawYPlotBand(g, c, S, P, h, m), p.show) {
+          const M = this.getNormalizedLabelOptions(e, p), v = this.getPlotBandLabelPosition(g, c, M, P, h);
+          this.drawPlotLabel(M, v);
+        }
+        t.restore();
+      }), ($ = this.plotLines) == null || $.forEach((y) => {
+        if (!y.value)
+          return;
+        const b = Z({}, y, tt), { value: W, label: T } = b, p = Math.round(x + f * W) + f / 2;
+        if (this.setPlotLineStyle(b), this.type === "x" ? this.drawXPlotLine(p, S, P, h, m) : this.drawYPlotLine(p, S, P, h, m), T.show) {
+          const g = this.getNormalizedLabelOptions(e, T), c = this.getPlotLineLabelPosition(p, g, P, h);
+          this.drawPlotLabel(g, c);
+        }
+        t.restore();
+      });
+    }
+  }
+  /**
+   * Transforming label by designated format
+   * @param {string} value       label value
+   * @param {number} maxWidth    max width for each label
+   * @param {object} data        data for formatting
+   *
+   * @returns {string} formatted label
+   */
+  getLabelFormat(e, s, a = {}) {
+    if (this.formatter) {
+      const o = this.formatter(e, a);
+      if (typeof o == "string")
+        return o;
+    }
+    return this.labelStyle.fitWidth ? this.fittingString(e, s) : e;
+  }
+  /**
+   * Transforming ellipsis label by designated format and specific width
+   * @param {string} value       label value
+   * @param {number} maxWidth    max width for each label
+   *
+   * @returns {string} formatted label
+   */
+  fittingString(e, s) {
+    const a = this.ctx;
+    a.save(), a.font = u.getLabelStyle(this.labelStyle);
+    const o = this.labelStyle.fitDir, i = u.truncateLabelWithEllipsis(e, s, a, o);
+    return a.restore(), i;
+  }
+  /**
+   * return width what has max length
+   * ellipsis가 적용된 label의 width를 계산 (fontSize 적용)
+   * @param {string[]} notFormattedLabels
+   * @param {object} chartRect
+   * @returns {number} maxWidth
+   */
+  getLabelWidthHasMaxLength(e, s) {
+    const a = u.getLabelStyle(this.labelStyle), o = this.getMaxWidth(s);
+    return (e ?? []).reduce((i, t) => {
+      var r;
+      const l = this.getLabelFormat(t, o), n = ((r = u.calcTextSizeCanvas(l, a)) == null ? void 0 : r.width) ?? 0;
+      return Math.max(i, n);
+    }, 0);
+  }
+}
+export {
+  xt as default
+};