evui 3.4.214 → 3.5.0

package/dist/components/chart/element/element.pie.js

@@ -0,0 +1,73 @@
+import { merge as p } from "lodash-es";
+import { PIE_OPTION as P, COLOR as y } from "../helpers/helpers.constant.js";
+import r from "../helpers/helpers.util.js";
+class Y {
+  constructor(a, e, t) {
+    const i = p({}, P, e);
+    Object.keys(i).forEach((s) => {
+      this[s] = i[s];
+    }), this.name === void 0 && (this.name = `series-${t}`), this.color === void 0 && (this.color = y[t % y.length]), this.sId = a, this.show = !0, this.data = [], this.type = "pie", this.centerX = 0, this.centerY = 0, this.radius = 0, this.doughnutHoleSize = 0, this.startAngle = 0, this.endAngle = 0, this.ctx = null, this.isSelect = !1;
+  }
+  /**
+   * Draw series data
+   * @param context
+   * @param strokeOptions
+   * @param unSelectedOpacity
+   *
+   * @returns {undefined}
+   */
+  draw(a, e, t) {
+    var o;
+    const i = a ?? this.ctx, s = new Path2D(), h = this.isSelect ? this.radius + 5 : this.radius, n = this.color, l = n.includes("rgba") ? r.getOpacity(n) : 1, c = this.isDownplay ? t : l;
+    i.beginPath(), s.moveTo(this.centerX, this.centerY), s.arc(this.centerX, this.centerY, h, this.startAngle, this.endAngle), s.lineTo(this.centerX, this.centerY), i.fillStyle = r.colorStringToRgba(n, c), i.fill(s), e.use && (i.lineCap = "round", i.lineWidth = e == null ? void 0 : e.lineWidth, i.strokeStyle = e == null ? void 0 : e.color, i.stroke(s)), (o = this.showValue) != null && o.use && this.drawValueLabels(i), i.closePath(), this.ctx = i;
+  }
+  /**
+   * Find graph item
+   * @param {array}    offset          mouse position
+   *
+   * @returns {object} graph item
+   */
+  findGraphData([a, e]) {
+    const t = { data: null, hit: !1, color: null, index: -1 }, { radius: i, startAngle: s, endAngle: h, centerX: n, centerY: l } = this, c = Math.sqrt((a - n) ** 2 + (e - l) ** 2), o = 2.5 * Math.PI - Math.atan2(a - n, e - l), d = i > c && o >= s && o <= h;
+    return this.show && d && (t.type = this.type, t.data = this.data, t.hit = !0, t.color = this.color, t.index = 0), t;
+  }
+  /**
+   * Draw item highlight
+   *
+   * @param item {object} object for drawing series data
+   * @param context {CanvasRenderingContext2D} canvas context
+   *
+   * @returns {undefined}
+   */
+  itemHighlight(a, e) {
+    var h, n;
+    const t = e, i = this.isSelect ? this.radius + 5 : this.radius;
+    t.save(), t.shadowOffsetX = 0, t.shadowOffsetY = 0, t.shadowBlur = 4;
+    const s = ((h = a == null ? void 0 : a.data) == null ? void 0 : h.dataColor) || this.color;
+    t.fillStyle = s, t.shadowColor = s, t.beginPath(), t.moveTo(this.centerX, this.centerY), t.arc(this.centerX, this.centerY, i, this.startAngle, this.endAngle), t.lineTo(this.centerX, this.centerY), t.fill(), (n = this.showValue) != null && n.use && this.drawValueLabels(t), t.closePath(), t.restore();
+  }
+  /**
+   * Draw value label if series 'use' of showValue option is true
+   *
+   * @param context           canvas context
+   */
+  drawValueLabels(a) {
+    const e = a, t = this.data.o, { fontSize: i, textColor: s, formatter: h } = this.showValue;
+    let n;
+    h && (n = h({
+      value: t,
+      percentage: this.data.percentage
+    })), (!h || typeof n != "string") && (n = r.labelSignFormat(t));
+    const l = 1.8, c = this.radius - this.doughnutHoleSize, o = (this.endAngle - this.startAngle) * 180 / Math.PI, d = i + 4, u = Math.round(e.measureText(n).width);
+    if (o >= u * l && o >= d * l && c >= u * l && c >= d * l) {
+      e.save(), e.beginPath();
+      const w = s.includes("rgba") ? r.getOpacity(s) : 1, m = this.state === "downplay" ? this.unSelectedOpacity : w;
+      e.font = `normal normal normal ${i}px Roboto`, e.fillStyle = r.colorStringToRgba(s, m), e.lineWidth = 1, e.textAlign = "center", e.textBaseline = "middle";
+      const g = c / 2 + this.doughnutHoleSize, f = (this.endAngle - this.startAngle) / 2 + this.startAngle, x = g * Math.cos(f) + this.centerX, A = g * Math.sin(f) + this.centerY;
+      e.fillText(n, x, A), e.restore();
+    }
+  }
+}
+export {
+  Y as default
+};

package/dist/components/chart/element/element.scatter.js

@@ -0,0 +1,209 @@
+import { merge as F } from "lodash-es";
+import { LINE_OPTION as b, COLOR as v } from "../helpers/helpers.constant.js";
+import I from "../helpers/helpers.util.js";
+import S from "../helpers/helpers.canvas.js";
+class $ {
+  constructor(e, l, s, t = !1) {
+    const i = F({}, b, l);
+    Object.keys(i).forEach((o) => {
+      this[o] = i[o];
+    }), this.name === void 0 && (this.name = `series-${s}`), ["color", "pointFill", "fillColor", "overflowColor"].forEach((o) => {
+      this[o] === void 0 && (this[o] = v[s % v.length]);
+    }), this.sId = e, this.data = [], this.type = "scatter", this.realTimeScatter = t, this._rtTotalCount = 0, this._colorCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get cached color with opacity
+   * colorStringToRgba cache the result of colorStringToRgba to avoid repeated calculations.
+   * @param {string} colorStr - Color string
+   * @param {number} opacity - Opacity value
+   * @returns {string} rgba string
+   */
+  getCachedColor(e, l) {
+    const s = `${e}_${l}`;
+    if (this._colorCache.has(s))
+      return this._colorCache.get(s);
+    const t = I.colorStringToRgba(e, l);
+    if (this._colorCache.size > 100) {
+      const i = this._colorCache.keys().next().value;
+      this._colorCache.delete(i);
+    }
+    return this._colorCache.set(s, t), t;
+  }
+  /**
+   * Draw series data
+   * @param {object} param     object for drawing series data
+   *
+   * @returns {undefined}
+   */
+  draw(e) {
+    this.show && (this.realTimeScatter ? this.realTimeScatterDraw(e) : this.defaultScatterDraw(e));
+  }
+  /**
+   * Calculate opacity for a data item in the series.
+   * @param {object} param - The parameter object passed to the draw function.
+   * @param {string} colorStr - The color string of the item.
+   * @param {number} dataIndex - The index of the item in the data array.
+   *
+   * @returns {number} - The calculated opacity level for the item.
+   */
+  getOpacity(e, l, s) {
+    const t = l.includes("rgba") ? I.getOpacity(l) : 1;
+    let i = !1;
+    const { selectInfo: o, legendHitInfo: n, unSelectedOpacity: r } = e;
+    return n ? i = n.sId !== this.sId : o && (i = (o == null ? void 0 : o.seriesID) !== this.sId || (o == null ? void 0 : o.dataIndex) !== s), i ? r : t;
+  }
+  /**
+   * Calculate x and y coordinates for a data item in the series.
+   * @param {object} item - The data item for which coordinates are to be calculated.
+   * @param {object} param - The parameter object passed to the draw function.
+   *
+   * @returns {undefined}
+   */
+  calcItem(e, l) {
+    const { chartRect: s, labelOffset: t, axesSteps: i, displayOverflow: o } = l;
+    let n;
+    const r = i.x[this.xAxisIndex], a = i.y[this.yAxisIndex], f = s.chartWidth - (t.left + t.right), d = s.chartHeight - (t.top + t.bottom), c = s.x1 + t.left, u = s.y2 - t.bottom;
+    let h = S.calculateX(e.x, r.graphMin, r.graphMax, f, c);
+    const p = S.calculateY(
+      o && e.y > a.graphMax ? a.graphMax : e.y,
+      a.graphMin,
+      a.graphMax,
+      d,
+      u
+    );
+    h !== null && (n = I.aliasPixel(h), h += n), e.xp = h, e.yp = p;
+  }
+  /**
+   * Draw default scatter chart
+   * @param {object} param - The parameter object passed to the draw function.
+   *
+   * @returns {undefined}
+   */
+  defaultScatterDraw(e) {
+    const { ctx: l, axesSteps: s, duple: t, legendHitInfo: i, coordinateDedupe: o } = e, n = s.y[this.yAxisIndex];
+    for (let r = 0; r < this.data.length; r++) {
+      const a = this.data[r], f = r, d = o !== !1;
+      let c;
+      if (i ? c = i.sId === this.sId : d ? c = t.get(`${a.x}${a.y}`) === this.sId : c = !0, c && (this.calcItem(a, e), a.xp !== null && a.yp !== null)) {
+        const h = a.y > n.graphMax && this.overflowColor || a.dataColor || this.color, p = this.getOpacity(e, h, f);
+        l.strokeStyle = this.getCachedColor(h, p);
+        const g = a.dataColor || this.pointFill, x = this.getOpacity(e, g, f);
+        l.fillStyle = this.getCachedColor(g, x), S.drawPoint(l, this.pointStyle, this.pointSize, a.xp, a.yp);
+      }
+    }
+  }
+  /**
+   * Draw real time scatter chart
+   * @param {object} param - The parameter object passed to the draw function.
+   *
+   * @returns {undefined}
+   */
+  realTimeScatterDraw(e) {
+    var d, c, u, h, p, g;
+    const { ctx: l, axesSteps: s, duple: t, legendHitInfo: i, coordinateDedupe: o } = e, n = s.y[this.yAxisIndex], r = typeof this.pointStyle == "string" ? this.pointStyle : this.pointStyle.value, a = typeof this.pointSize == "number" ? this.pointSize : this.pointSize.value;
+    let f = 0;
+    for (let x = 0; x < ((c = (d = this.data[this.sId]) == null ? void 0 : d.dataGroup) == null ? void 0 : c.length); x++)
+      for (let C = 0; C < ((h = (u = this.data[this.sId]) == null ? void 0 : u.dataGroup[x]) == null ? void 0 : h.data.length); C++) {
+        const y = (g = (p = this.data[this.sId]) == null ? void 0 : p.dataGroup[x]) == null ? void 0 : g.data[C];
+        f++;
+        const _ = o !== !1;
+        let m;
+        if (i ? m = i.sId === this.sId : _ ? m = t.get(`${y.x}${y.y}`) === this.sId : m = !0, m && (this.calcItem(y, e), y.xp !== null && y.yp !== null)) {
+          const w = y.y > n.graphMax && this.overflowColor, O = w || y.color || this.color, T = w || y.color || this.pointFill || this.color, z = this.getOpacity(e, O, C), D = this.getOpacity(e, T, C);
+          l.strokeStyle = this.getCachedColor(O, z), l.fillStyle = this.getCachedColor(T, D), S.drawPoint(l, r, a, y.xp, y.yp);
+        }
+      }
+    this._rtTotalCount = f;
+  }
+  /**
+   * Filters and returns data items based on input coordinates
+   *
+   * @param {Array} data - The data to filter
+   * @param {number} xsp - Start X coordinate
+   * @param {number} ysp - Start Y coordinate
+   * @param {number} xep - End X coordinate
+   * @param {number} yep - End Y coordinate
+   * @returns {Array} Filtered data items
+   */
+  findItemsInRange(e, l, s, t, i) {
+    return e.filter(
+      (o) => l - 1 <= o.xp && o.xp <= t + 1 && s - 1 <= o.yp && o.yp <= i + 1
+    );
+  }
+  defaultScatterFindItems(e, l, s, t, i) {
+    return this.findItemsInRange(e, l, s, t, i);
+  }
+  realTimeScatterFindItems(e, l, s, t, i) {
+    const o = [];
+    for (let n = 0; n < e[this.sId].dataGroup.length; n++) {
+      const r = e[this.sId].dataGroup[n];
+      o.push(...this.findItemsInRange(r.data, l, s, t, i));
+    }
+    return o;
+  }
+  /**
+   *Returns items in range
+   * @param {object} params  range values
+   *
+   * @returns {array}
+   */
+  findItems({ xsp: e, ysp: l, width: s, height: t }) {
+    const i = this.data, o = e + s, n = l + t;
+    let r = [];
+    return this.realTimeScatter ? r = this.realTimeScatterFindItems(i, e, l, o, n) : r = this.defaultScatterFindItems(i, e, l, o, n), r;
+  }
+  /**
+   * Draw item highlight
+   * @param {object}   item       object for drawing series data
+   * @param {object}   context    canvas context
+   * @param {boolean}  isMax      determines if this series has max value
+   *
+   * @returns {undefined}
+   */
+  itemHighlight(e, l) {
+    const s = e.data, t = l, i = s.xp, o = s.yp;
+    if (t.save(), i !== null && o !== null) {
+      const n = s.dataColor || this.color, r = s.dataColor || this.pointFill;
+      t.strokeStyle = this.getCachedColor(n, 0), t.fillStyle = this.getCachedColor(r, this.highlight.maxShadowOpacity), S.drawPoint(t, this.pointStyle, this.highlight.maxShadowSize, i, o), t.fillStyle = n, S.drawPoint(t, this.pointStyle, this.highlight.maxSize, i, o), t.fillStyle = "#fff", S.drawPoint(t, this.pointStyle, this.highlight.defaultSize, i, o);
+    }
+    t.restore();
+  }
+  /**
+   * Find graph item for tooltip
+   * @param {array}  offset       mouse position
+   *
+   * @returns {object} graph item
+   */
+  findGraphData(e) {
+    var r;
+    const l = e[0], s = e[1], t = { data: null, hit: !1, color: this.color, index: null }, i = this.pointSize;
+    if (this.realTimeScatter) {
+      const a = (r = this.data[this.sId]) == null ? void 0 : r.dataGroup;
+      if (!a)
+        return t;
+      let d = this._rtTotalCount - 1;
+      for (let c = a.length - 1; c >= 0; c--) {
+        const u = a[c];
+        if (u != null && u.data)
+          for (let h = u.data.length - 1; h >= 0; h--) {
+            const p = u.data[h];
+            if (p.xp !== null && p.yp !== null) {
+              const g = p.xp, x = p.yp;
+              if (g - i <= l && l <= g + i && x - i <= s && s <= x + i)
+                return t.data = p, t.index = d, t.hit = !0, t;
+            }
+            d--;
+          }
+      }
+      return t;
+    }
+    const o = this.data, n = o.findIndex((a) => {
+      const f = a.xp, d = a.yp;
+      return f - i <= l && l <= f + i && d - i <= s && s <= d + i;
+    });
+    return n > -1 && (t.data = o[n], t.index = n, t.hit = !0), t;
+  }
+}
+export {
+  $ as default
+};

package/dist/components/chart/element/element.tip.js

@@ -0,0 +1,312 @@
+import U from "dayjs";
+import { truthyNumber as K, numberWithComma as Q } from "../../../common/utils.js";
+import P from "../helpers/helpers.canvas.js";
+const et = {
+  /**
+   * Draw TextTip with tip's locationInfo
+   * @param {object} [tipLocationInfo=undefined]   tip location information
+   *
+   * @returns {undefined}
+   */
+  drawTips(d) {
+    var f, T, u, t, x, h;
+    const l = this.options;
+    let s = null;
+    const r = !!l.horizontal, i = l.maxTip, p = l.selectItem, c = l.selectLabel;
+    let a, n;
+    typeof ((f = l.tooltip) == null ? void 0 : f.formatter) == "function" ? s = (T = l.tooltip) == null ? void 0 : T.formatter : typeof ((t = (u = l.tooltip) == null ? void 0 : u.formatter) == null ? void 0 : t.value) == "function" && (s = (h = (x = l.tooltip) == null ? void 0 : x.formatter) == null ? void 0 : h.value), c.use && c.showTip && (n = l.type === "heatMap" ? this.drawLabelTipForHeatMap() : this.drawTipForSelectedLabel());
+    const b = (o) => {
+      d.forEach((e) => {
+        if (e) {
+          const w = this.seriesList[e == null ? void 0 : e.sId];
+          if (!(w != null && w.show))
+            return;
+          const m = this.calculateTipInfo(w, "sel", e);
+          if (m) {
+            let z = !1;
+            if (i.use && (a == null ? void 0 : a.dp) === m.dp && (z = !0), o.showTextTip || o.showTip) {
+              if (o.tipText === "label") {
+                const C = r ? l.axesY[0] : l.axesX[0], O = m.label;
+                m.text = C.type === "time" ? U(O).format(C.timeFormat) : O;
+              } else
+                m.text = Q(m.value);
+              this.drawTextTip({
+                opt: o,
+                tipType: "sel",
+                seriesOpt: w,
+                isSamePos: z,
+                ...m
+              });
+            }
+            o.showIndicator && this.drawFixedIndicator({ opt: o, seriesOpt: w, ...m });
+          }
+          e && (e != null && e.label) && (e == null ? void 0 : e.label) === 0 && (this.lastHitInfo = e);
+        }
+      });
+    };
+    if (d && !n && (p.use ? b(p) : c.use && l.type === "line" && b(c)), i.use && !n) {
+      const o = this.minMax[r ? "x" : "y"][0].maxSID, e = this.seriesList[o];
+      a = this.calculateTipInfo(e, "max", null), i.use && a && (s ? a.text = s({
+        seriesId: e.sId,
+        x: r ? a.value : void 0,
+        y: r ? void 0 : a.value
+      }) : a.text = Q(a.value), this.drawTextTip({ opt: i, tipType: "max", seriesOpt: e, ...a }), i.showIndicator && this.drawFixedIndicator({ opt: i, seriesOpt: e, ...a }));
+    }
+  },
+  /**
+   * Calculate tip size and contents
+   * @param {object} series     series information (max series or selected series)
+   * @param {string} tipType    tip type
+   * [sel = user select series, label = user select label, max = max value]
+   * @param {object} hitInfo    mouse hit information
+   *
+   * @returns {object} size and tip contents
+   */
+  calculateTipInfo(d, l, s) {
+    if (!d)
+      return !1;
+    const r = !!this.options.horizontal, i = this.lastTip, p = this.chartRect, c = this.labelOffset, a = {
+      x1: p.x1 + c.left,
+      x2: p.x2 - c.right,
+      y1: p.y1 + c.top,
+      y2: p.y2 - c.bottom
+    }, n = p.chartHeight - (c.top + c.bottom), b = p.chartWidth - (c.left + c.right), f = this.axesSteps.x[d.xAxisIndex], T = this.axesSteps.y[d.yAxisIndex], u = a.x1, t = a.x2, x = a.y2, { type: h, size: o } = d, { maxDomain: e, maxDomainIndex: w } = d.minMax;
+    if (e === null || w < 0)
+      return !1;
+    let m = h === "bar" ? w : e;
+    l === "sel" && (s && s.label !== null ? (i.pos = h === "bar" ? s.maxIndex : s.label, m = i.pos) : i.pos !== null && (m = i.pos));
+    let z = r ? d.minMax.maxX : d.minMax.maxY, C;
+    if (l === "sel") {
+      if (s && s.value !== null)
+        z = s.useStack ? s.acc : s.value, C = s.label, i.value = z, i.label = C;
+      else if (i.value !== null)
+        z = i.value, C = i.label;
+      else if (i.pos !== null) {
+        const g = h === "bar" ? this.getItemByLabelIndex(i.pos) : this.getItemByLabel(i.pos);
+        z = g.useStack ? g.acc : g.value, C = g.label, i.value = z, i.label = C;
+      }
+    }
+    let O, A, S;
+    if (h === "bar") {
+      const g = r ? this.scrollbar.y : this.scrollbar.x;
+      if (g != null && g.use) {
+        const [E, L] = (g == null ? void 0 : g.range) ?? [];
+        if (m >= E && m <= L)
+          m -= E ?? 0;
+        else
+          return !1;
+      }
+      r ? (A = Math.round(o.h / 2), O = x - o.cat * m - o.cPad, S = O - (o.bar * o.ix - (o.h + o.bPad)) - A) : (A = Math.round(o.w / 2), O = u + o.cat * m + o.cPad, S = O + (o.bar * o.ix - (o.w + o.bPad)) + A);
+    } else h === "line" ? S = P.calculateX(
+      m,
+      f.graphMin,
+      f.graphMax,
+      b - o.comboOffset,
+      u + o.comboOffset / 2
+    ) : h === "scatter" && (S = P.calculateX(m, f.graphMin, f.graphMax, b, u));
+    return { ...{ xArea: b, yArea: n, graphX: f, graphY: T, xsp: u, xep: t, ysp: x }, ...{ dp: S, value: z, label: C, type: h } };
+  },
+  drawFixedIndicator(d) {
+    const l = !!this.options.horizontal, s = this.bufferCtx, { graphX: r, graphY: i, xArea: p, yArea: c, xsp: a, ysp: n, dp: b, type: f, value: T, opt: u, seriesOpt: t } = d;
+    let x = 0;
+    f === "line" ? x += 3 : f === "scatter" && (x += (t == null ? void 0 : t.pointSize) ?? 0);
+    let h;
+    if (u.fixedPosTop)
+      l ? h = P.calculateX(r.graphMax, r.graphMin, r.graphMax, p, a) : (h = P.calculateY(i.graphMax, i.graphMin, i.graphMax, c, n), h -= x);
+    else if (l) {
+      const o = Math.min(Math.max(T, r.graphMin), r.graphMax);
+      h = P.calculateX(o, r.graphMin, r.graphMax, p, a);
+    } else {
+      const o = Math.min(Math.max(T, i.graphMin), i.graphMax);
+      h = P.calculateY(o, i.graphMin, i.graphMax, c, n), h -= x;
+    }
+    b !== null && (s.beginPath(), s.save(), s.strokeStyle = u.indicatorColor, s.lineWidth = 2, l ? (s.moveTo(a, b), s.lineTo(h, b)) : (s.moveTo(b, n), s.lineTo(b, h)), s.stroke(), s.restore(), s.closePath());
+  },
+  /**
+   * Draw Selected Label Tip
+   * none Text
+   * @returns {boolean} Whether drew at least one tip
+   */
+  drawTipForSelectedLabel() {
+    var a, n;
+    const d = this.options, l = !!d.horizontal, s = d.selectLabel, { dataIndex: r, data: i, label: p } = this.defaultSelectInfo;
+    let c = !1;
+    if (r.length) {
+      c = !0;
+      const b = this.chartRect, f = this.labelOffset, T = {
+        x1: b.x1 + f.left,
+        x2: b.x2 - f.right,
+        y1: b.y1 + f.top,
+        y2: b.y2 - f.bottom
+      }, u = l ? this.axesY[0] : this.axesX[0], t = l ? this.axesX[0] : this.axesY[0], x = l ? this.axesSteps.x[0] : this.axesSteps.y[0], h = l ? P.calculateX : P.calculateY, o = l ? P.calculateY : P.calculateX, e = l ? this.scrollbar.y : this.scrollbar.x, w = b.chartWidth - (f.left + f.right), m = b.chartHeight - (f.top + f.bottom), z = l ? w : m, C = T[t.units.rectStart];
+      let O = this.options.type === "bar" ? 4 : 6;
+      O *= l ? 1 : -1;
+      const A = Object.keys(this.seriesList ?? {}), S = A.filter((M) => this.seriesList[M].show), H = A.some(
+        (M) => this.seriesList[M].isExistGrp && !this.seriesList[M].isOverlapping
+      ), y = ((a = this.data.groups) == null ? void 0 : a[0]) ?? [];
+      let g, E, L, R, B, q, G, _, N, V = 0, $ = (n = u.labels) == null ? void 0 : n.length;
+      if (u.labels) {
+        let M = u.labels.length;
+        if (e != null && e.use) {
+          const { range: j, interval: W, type: F } = e, [X, Y] = j;
+          K(X) && K(Y) && (M = Math.floor((+Y - +X) / W) + 1, V = F === "step" ? X : u.labels.findIndex((v) => v === +X), $ = F === "step" ? Y : u.labels.findIndex((v) => v === +Y));
+        }
+        R = T[u.units.rectStart], B = T[u.units.rectEnd], q = (B - R) / M;
+      } else
+        G = this.axesSteps.x[0], _ = A.find((M) => {
+          var j;
+          return ((j = this.seriesList[M]) == null ? void 0 : j.type) === "line";
+        }), N = this.seriesList[_].size;
+      i.forEach((M, j) => {
+        var W;
+        if (L = x.graphMax, !s.fixedPosTop) {
+          if (H) {
+            const F = S == null ? void 0 : S.reduce(
+              (v, k) => {
+                var I, J;
+                return y.includes(k) && (((I = M[k]) == null ? void 0 : I.value) ?? M[k]) > 0 ? v + (((J = M[k]) == null ? void 0 : J.value) ?? M[k]) : v;
+              },
+              0
+            ), X = ((W = S == null ? void 0 : S.filter((v) => !y.includes(v))) == null ? void 0 : W.map((v) => {
+              var k;
+              return ((k = M[v]) == null ? void 0 : k.value) ?? M[v];
+            })) ?? [], Y = (X == null ? void 0 : X.length) > 0 ? X.reduce((v, k) => Math.max(v, k ?? -1 / 0), -1 / 0) : -1 / 0;
+            L = F > 0 ? Math.max(Y, F) : Math.max(Y, 0);
+          } else if (S.length) {
+            const F = S.map(
+              (Y) => {
+                var v;
+                return ((v = M[Y]) == null ? void 0 : v.value) ?? M[Y];
+              }
+            ), X = F.length > 0 ? F.reduce((Y, v) => Math.max(Y, v ?? -1 / 0), -1 / 0) : -1 / 0;
+            L = X > 0 || this.options.type !== "bar" ? X : 0;
+          }
+        }
+        if (u.labels) {
+          if (r[j] < V || r[j] > $)
+            return;
+          const F = r[j] - V;
+          g = Math.round(R + q * F) + q / 2;
+        } else
+          g = o(
+            p[j],
+            G.graphMin,
+            G.graphMax,
+            w - N.comboOffset,
+            T.x1 + N.comboOffset / 2
+          );
+        E = h(
+          L,
+          x.graphMin,
+          x.graphMax,
+          z,
+          C
+        ) + O, this.showTip({
+          context: this.bufferCtx,
+          x: l ? E : g,
+          y: l ? g : E,
+          opt: s,
+          isSamePos: !1
+        });
+      });
+    }
+    return c;
+  },
+  /**
+   * Draw Selected Label Tip
+   * @returns {boolean} Whether drew at least one tip
+   */
+  drawLabelTipForHeatMap() {
+    const d = this.options, l = !!d.horizontal, s = d.selectLabel, { dataIndex: r } = this.defaultSelectInfo;
+    let i = !1;
+    if (r) {
+      i = !0;
+      const p = this.chartRect, c = this.labelOffset, a = {
+        x1: p.x1 + c.left,
+        x2: p.x2 - c.right,
+        y1: p.y1 + c.top,
+        y2: p.y2 - c.bottom
+      }, n = l ? this.axesY[0] : this.axesX[0], b = a[n.units.rectStart], T = (a[n.units.rectEnd] - b) / n.labels.length, u = l ? this.axesX[0] : this.axesY[0], t = 6 * (l ? 1 : -1), x = a[u.units.rectEnd] + t;
+      r == null || r.forEach((h) => {
+        const e = Math.round(b + T * h) + T / 2;
+        this.showTip({
+          context: this.bufferCtx,
+          x: l ? x : e,
+          y: l ? e : x,
+          opt: s,
+          isSamePos: !1
+        });
+      });
+    }
+    return i;
+  },
+  /**
+   * Calculate x, y position to draw text tip
+   * @param {object} param     object for drawing text tip
+   *
+   * @returns {undefined}
+   */
+  drawTextTip(d) {
+    const l = !!this.options.horizontal, s = this.bufferCtx, { graphX: r, graphY: i, xArea: p, yArea: c, xsp: a, xep: n, ysp: b } = d, { dp: f, value: T, text: u, opt: t, type: x, tipType: h, isSamePos: o, seriesOpt: e } = d, w = 4, m = 4, { fontSize: z, fontFamily: C, fontWeight: O, height: A } = t.tipStyle, S = `normal normal ${O} ${z}px ${C}`;
+    let H = 1;
+    x === "line" ? H += 6 : x === "scatter" ? H += e == null ? void 0 : e.pointSize : x === "bar" && (H += 4);
+    let y, g = f;
+    if (t.fixedPosTop)
+      l ? (y = P.calculateX(r.graphMax, r.graphMin, r.graphMax, p, a), y += H) : (y = P.calculateY(i.graphMax, i.graphMin, i.graphMax, c, b), y -= H);
+    else if (l) {
+      const R = Math.min(Math.max(T, r.graphMin), r.graphMax);
+      y = P.calculateX(R, r.graphMin, r.graphMax, p, a), y = T < 0 ? y - H : y + H;
+    } else {
+      const R = x === "bar" && T < 0 ? 0 : T, B = Math.min(Math.max(R, i.graphMin), i.graphMax);
+      y = P.calculateY(B, i.graphMin, i.graphMax, c, b), y = R < 0 ? y + H : y - H;
+    }
+    let E = "center";
+    s.save(), s.font = S;
+    const L = Math.round(Math.max(s.measureText(u).width + 12, 40));
+    l || (f + L / 2 > n - 10 ? (E = "right", g -= L / 2 - w * 2) : f - L / 2 < a + 10 && (E = "left", g += L / 2 - w * 2)), s.restore(), (t.showTextTip || h === "max") && this.showTextTip({
+      context: s,
+      type: E,
+      width: L,
+      height: A,
+      x: l ? y + L / 2 : g,
+      y: l ? g + A / 2 : y,
+      opt: t,
+      arrowSize: w,
+      borderRadius: m,
+      text: u,
+      textStyle: S,
+      isNegative: T < 0
+    }), t.showTip && h === "sel" && this.showTip({
+      context: s,
+      x: l ? y : f,
+      y: l ? f : y,
+      opt: t,
+      isSamePos: o
+    });
+  },
+  /**
+   * Draw text tip
+   * @param {object} param     object for drawing text tip
+   *
+   * @returns {undefined}
+   */
+  showTextTip(d) {
+    const l = !!this.options.horizontal, { type: s, width: r, height: i, x: p, y: c, arrowSize: a, borderRadius: n, text: b, opt: f, textStyle: T, isNegative: u } = d, t = d.context;
+    let x = p - r / 2, h = p + r / 2;
+    const o = c - i, e = c;
+    u && l && (x = p - r / 2 - r, h = p - r / 2), t.save(), t.font = T, t.fillStyle = f.tipBackground ?? f.tipStyle.background, t.shadowBlur = 0, t.beginPath(), t.moveTo(x + n, o), t.quadraticCurveTo(x, o, x, o + n), t.lineTo(x, e - n), t.quadraticCurveTo(x, e, x + n, e), t.lineTo(h - n, e), t.quadraticCurveTo(h, e, h, e - n), t.lineTo(h, o + n), t.quadraticCurveTo(h, o, h - n, o), t.lineTo(x + n, o), t.closePath(), t.fill(), t.beginPath(), l ? (u ? (t.moveTo(h, e), t.lineTo(h, o + n + a / 2), t.lineTo(h + a, e - i / 2), t.lineTo(h, e - n - a / 2)) : (t.moveTo(x, o), t.lineTo(x, o + n + a / 2), t.lineTo(x - a, e - i / 2), t.lineTo(x, e - n - a / 2)), t.closePath(), t.fill()) : (u ? s === "left" ? (t.lineTo(x + n + a, e + a), t.lineTo(x + n + a * 2, e)) : s === "right" ? (t.lineTo(h - a * 2 - n, e), t.lineTo(h - a - n, e + a)) : (t.lineTo(p - a, e), t.lineTo(p, e + a), t.lineTo(p + a, e)) : u || (s === "left" ? (t.moveTo(x, o), t.lineTo(x + n + a, e + a), t.lineTo(x + n + a * 2, e)) : s === "right" ? (t.moveTo(h, o), t.lineTo(h - a * 2 - n, e), t.lineTo(h - a - n, e + a)) : (t.lineTo(p - a, e), t.lineTo(p, e + a), t.lineTo(p + a, e))), t.closePath(), t.fill()), t.restore(), t.save(), t.font = T, t.fillStyle = f.tipTextColor ?? f.tipStyle.textColor, t.textBaseline = "middle", t.textAlign = "center", t.fillText(`${b}`, x + r / 2, o + i / 2), t.restore();
+  },
+  /**
+   * Draw arrow tip
+   * @param {object} param     object for drawing arrow tip
+   *
+   * @returns {undefined}
+   */
+  showTip(d) {
+    const l = !!this.options.horizontal, { x: s, y: r, opt: i, isSamePos: p } = d, c = d.context, n = r - (p ? 24 : 0);
+    c.save(), c.fillStyle = i.tipBackground ?? i.tipStyle.background, c.beginPath(), c.moveTo(s, n), l ? (c.lineTo(s + 6, n - 6), c.lineTo(s + 6, n + 6)) : (c.lineTo(s + 6, n - 6), c.lineTo(s - 6, n - 6)), c.lineTo(s, n), c.closePath(), c.fill(), c.restore();
+  }
+};
+export {
+  et as default
+};