evui 3.5.0-rc.1 → 3.5.0

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

@@ -0,0 +1,403 @@
+import { merge as v } from "lodash-es";
+import { convertToPercent as H, truthyNumber as X, checkNullAndUndefined as N, truthy as D } from "../../../common/utils.js";
+import P from "../helpers/helpers.util.js";
+import { HEAT_MAP_OPTION as U } from "../helpers/helpers.constant.js";
+class Z {
+  constructor(e, o, s, t, i) {
+    const n = v({}, U, o);
+    Object.keys(n).forEach((a) => {
+      this[a] = n[a];
+    }), this.isHorizontal = t, this.isGradient = i, this.createColorState(s), this.sId = e, this.data = [], this.labels = {
+      x: [],
+      y: []
+    }, this.valueOpt = {}, this.size = {
+      w: 0,
+      h: 0
+    }, this.type = "heatMap", this.currentLabelInfo = {
+      x: {
+        steps: 0,
+        min: 0,
+        max: 0
+      },
+      y: {
+        steps: 0,
+        min: 0,
+        max: 0
+      }
+    };
+  }
+  /**
+   * create series color axis
+   * @param colorOpt
+   * @returns {*[]}
+   */
+  createColorState(e) {
+    const o = [], s = /[^0-9]&[^,]/g, { min: t, max: i, rangeCount: n, colorsByRange: a, error: l, stroke: d } = e, g = t.includes("#") ? P.hexToRgb(t) : t.replace(s, ""), m = i.includes("#") ? P.hexToRgb(i) : i.replace(s, ""), [f, h, c] = g.split(","), [b, M, r] = m.split(",");
+    if (this.isGradient)
+      o.push({
+        minColor: { minR: f, minG: h, minB: c },
+        maxColor: { maxR: b, maxG: M, maxB: r },
+        rangeCount: n,
+        start: 0,
+        end: 100,
+        selectedValue: null
+      });
+    else if (a.length)
+      a.forEach(({ color: x, label: C }, u) => {
+        o.push({
+          id: `color#${u}`,
+          color: x,
+          label: C,
+          state: "normal",
+          show: !0
+        });
+      });
+    else {
+      const x = Math.floor((f - b) / (n - 1)), C = Math.floor((h - M) / (n - 1)), u = Math.floor((c - r) / (n - 1));
+      for (let y = 0; y < n; y++) {
+        const I = +f - x * y, w = +h - C * y, p = +c - u * y;
+        o.push({
+          id: `color#${y}`,
+          color: `rgb(${I},${w},${p})`,
+          state: "normal",
+          show: !0
+        });
+      }
+    }
+    this.colorState = o, this.errorColor = l, this.stroke = d;
+  }
+  getColorForGradient(e) {
+    const { minColor: o, maxColor: s } = this.colorState[0], { minR: t, minG: i, minB: n } = o, { maxR: a, maxG: l, maxB: d } = s, g = +t - Math.floor((t - a) * e / 100), m = +i - Math.floor((i - l) * e / 100), f = +n - Math.floor((n - d) * e / 100);
+    return `rgb(${g},${m},${f})`;
+  }
+  getColorIndexByValue(e) {
+    const { existError: o, min: s, interval: t, decimalPoint: i } = this.valueOpt, n = this.colorState.length - 1;
+    if (o && e < 0)
+      return n;
+    const a = Math.floor(+(e - s).toFixed(i) / t);
+    return a >= n ? o ? n - 1 : n : a;
+  }
+  getItemInfo(e) {
+    const { min: o, max: s } = this.valueOpt, t = {
+      show: !1,
+      opacity: 1,
+      dataColor: null,
+      id: null,
+      isHighlight: null
+    };
+    if (this.isGradient) {
+      const i = H(e - o, s - o), { start: n, end: a, selectedValue: l } = this.colorState[0];
+      (e < 0 || n <= i && i <= a) && (t.show = !0, t.isHighlight = l !== null && Math.floor(e) === Math.floor(o + (s - o) * (l / 100)), t.dataColor = e < 0 ? this.errorColor : this.getColorForGradient(i));
+    } else {
+      const i = this.getColorIndexByValue(e), { show: n, state: a, color: l, id: d } = this.colorState[i];
+      t.show = n, t.opacity = a === "downplay" ? 0.1 : 1, t.dataColor = e < 0 ? this.errorColor : l, t.id = d;
+    }
+    return t;
+  }
+  drawItem(e, o, s, t, i, n) {
+    if (e.beginPath(), !(t < 0 || i < 0)) {
+      if (n.show) {
+        const { radius: a } = n;
+        if (a > 0) {
+          const l = Math.min(t, i);
+          let d = a;
+          d > l / 2 && (d = Math.floor(l / 2)), e.moveTo(o + d, s), e.arcTo(o + t, s, o + t, s + i, d), e.arcTo(o + t, s + i, o, s + i, d), e.arcTo(o, s + i, o, s, d), e.arcTo(o, s, o + t, s, d), e.stroke(), e.fill();
+        } else
+          e.strokeRect(o, s, t, i), e.fillRect(o, s, t, i);
+      } else {
+        const a = P.aliasPixel(1);
+        e.fillRect(o, s - a, t + a, i + a);
+      }
+      e.closePath();
+    }
+  }
+  calculateXY(e, o, s, t) {
+    let i = null;
+    if (this.labels[e] && this.labels[e].length) {
+      let n = this.labels[e].findIndex((f) => f === o);
+      n === -1 && (n = this.labels[e].findIndex((f) => +f == +o));
+      const { minIndex: a, maxIndex: l, graphMin: d, graphMax: g } = t;
+      if (X(l) && n > l || X(a) && n < a || N(a) && N(l) && (o < d || o > g))
+        return null;
+      const m = a ?? this.labels[e].findIndex((f) => +f == +d);
+      n > -1 && (n -= m > -1 ? m : 0, i = e === "x" ? s + this.size.w * n : s - this.size.h * (n + 1));
+    }
+    return i;
+  }
+  draw(e) {
+    if (!this.show)
+      return;
+    const {
+      ctx: o,
+      chartRect: s,
+      labelOffset: t,
+      overlayCtx: i,
+      selectLabel: n,
+      legendHitInfo: a,
+      selectItem: l,
+      axesSteps: d
+    } = e, g = s.chartWidth - (t.left + t.right), m = s.chartHeight - (t.top + t.bottom), f = s.x1 + t.left, h = s.y2 - t.bottom, c = d.x[this.xAxisIndex], b = d.y[this.yAxisIndex];
+    this.size.w = g / c.oriSteps, this.size.h = m / b.oriSteps, this.currentLabelInfo = {
+      x: {
+        steps: c.oriSteps,
+        min: c.graphMin,
+        max: c.graphMax
+      },
+      y: {
+        steps: b.oriSteps,
+        min: b.graphMin,
+        max: b.graphMax
+      }
+    };
+    const M = (r, x, C) => {
+      var u, y;
+      if (!a) {
+        let I;
+        const { option: w, selected: p } = l, { option: T, selected: S } = n, O = D(p == null ? void 0 : p.dataIndex) && (p == null ? void 0 : p.dataIndex) > -1, B = ((u = S == null ? void 0 : S.label) == null ? void 0 : u.length) > 0;
+        return O ? I = w.useSeriesOpacity ? C !== (p == null ? void 0 : p.dataIndex) : !1 : B && (I = T.useSeriesOpacity ? !((y = S == null ? void 0 : S.label) != null && y.includes(this.getItemLabel(n, r))) : !1), I ? 0.1 : x;
+      }
+      return x;
+    };
+    this.data.forEach((r, x) => {
+      var T;
+      let u = this.calculateXY("x", r.x, f, c), y = this.calculateXY("y", r.y, h, b), I = this.size.w, w = this.size.h;
+      const p = r.o;
+      if (u !== null && y !== null && p !== null && p !== void 0) {
+        const { show: S, opacity: O, dataColor: B, id: A, isHighlight: L } = this.getItemInfo(p);
+        let z = O;
+        O === 1 && P.getColorStringType(r.dataColor) === "RGBA" && (z = P.getOpacity(r.dataColor));
+        const Y = M(r, z, x);
+        if (r.dataColor || (r.dataColor = B), r.cId = A, o.save(), S) {
+          o.fillStyle = P.colorStringToRgba(r.dataColor, Y);
+          let k = this.stroke;
+          const R = l == null ? void 0 : l.option, V = (R == null ? void 0 : R.use) && (R == null ? void 0 : R.showBorder), $ = x === ((T = l == null ? void 0 : l.selected) == null ? void 0 : T.dataIndex);
+          V && $ && (k = {
+            show: R == null ? void 0 : R.showBorder,
+            ...R == null ? void 0 : R.borderStyle
+          });
+          let E = !1;
+          if (k.show && k.lineWidth > 0) {
+            const { color: F, lineWidth: G, opacity: j } = k, W = G * 2;
+            E = W < Math.floor(I) && W < Math.floor(w), o.strokeStyle = E ? P.colorStringToRgba(F, Y === 1 ? j : Y) : void 0, E ? (o.lineWidth = G, u += G, y += G, I -= W, w -= W) : o.lineWidth = 0;
+          }
+          u += 1, r.xp = u, r.yp = y, r.w = I, r.h = w, this.drawItem(o, u, y, I, w, { ...k, show: E }), o.restore(), this.showValue.use && this.drawValueLabels({
+            context: o,
+            data: r
+          }), L && this.itemHighlight(
+            {
+              data: r
+            },
+            i
+          );
+        }
+      }
+    });
+  }
+  /**
+   * Draw value label if series 'use' of showValue option is true
+   *
+   * @param context           canvas context
+   * @param data              series value data (model.store.js addData return value)
+   */
+  drawValueLabels({ context: e, data: o }) {
+    const { fontSize: s, textColor: t, align: i, formatter: n, decimalPoint: a } = this.showValue, { xp: l, yp: d, w: g, h: m, o: f } = o, h = e;
+    h.save(), h.beginPath(), h.font = `normal normal normal ${s}px Roboto`, h.fillStyle = t, h.lineWidth = 1, h.textBaseline = "middle", h.textAlign = i !== "center" ? "left" : "center";
+    let c;
+    n && (c = n(f)), (!n || typeof c != "string") && (c = P.labelSignFormat(f, a));
+    const b = Math.round(h.measureText(c).width), M = s, r = l + g / 2, x = d + m / 2;
+    if (!(b >= g || M >= m || c < 0)) {
+      switch (i) {
+        case "top": {
+          const C = r - b / 2, u = x - M / 2;
+          h.fillText(c, C, u);
+          break;
+        }
+        case "right": {
+          const C = l + g - b;
+          h.fillText(c, C, x);
+          break;
+        }
+        case "bottom": {
+          const C = r - b / 2, u = x + M / 2;
+          h.fillText(c, C, u);
+          break;
+        }
+        case "left":
+          h.fillText(c, l, x);
+          break;
+        default: {
+          const C = r - b / 2;
+          h.fillText(c, C, x);
+          break;
+        }
+      }
+      h.restore();
+    }
+  }
+  /**
+   * 자바스크립트 부동 소수점 오차 때문에 범위를 조정
+   * @param {object} params - range information
+   * @param {number} params.xp - start x position
+   * @param {number} params.yp - start y position
+   * @param {number} params.width - width
+   * @param {number} params.height - height
+   * @returns {object} adjusted range
+   */
+  getAdjustedBounds({ xp: e, yp: o, width: s, height: t }) {
+    const n = Math.max(0, s), a = Math.max(0, t);
+    return {
+      xsp: Math.floor(e * 100) / 100,
+      xep: Math.ceil((e + n) * 100) / 100,
+      ysp: Math.floor(o * 100) / 100,
+      yep: Math.ceil((o + a) * 100) / 100
+    };
+  }
+  /**
+   *Returns items in range
+   * @param {object} params - range information
+   * @param {number} params.xsp - start x position
+   * @param {number} params.width - width
+   * @param {number} params.ysp - start y position
+   * @param {number} params.height - height
+   * @returns {array} items in range
+   */
+  findItems(e) {
+    const o = this.data, { xsp: s, xep: t, ysp: i, yep: n } = this.getAdjustedBounds({
+      xp: e.xsp,
+      yp: e.ysp,
+      width: e.width,
+      height: e.height
+    });
+    return o.filter(({ xp: a, yp: l, w: d, h: g }) => {
+      const {
+        xsp: m,
+        xep: f,
+        ysp: h,
+        yep: c
+      } = this.getAdjustedBounds({
+        xp: a,
+        yp: l,
+        width: d,
+        height: g
+      });
+      return m >= s && f <= t && h >= i && c <= n;
+    });
+  }
+  /**
+   * Draw item highlight
+   * @param {object}   item       object for drawing series data
+   * @param {object}   context    canvas context
+   *
+   * @returns {undefined}
+   */
+  itemHighlight(e, o) {
+    var b;
+    const s = e.data, t = o, { stroke: i, shadow: n } = this.highlight, a = s.xp, l = s.yp, d = s.w, g = s.h, m = s.cId;
+    let f;
+    if (this.isGradient) {
+      const { min: M, max: r } = this.valueOpt, x = H(s.o - M, r - M), { start: C, end: u } = this.colorState[0];
+      f = C <= x && x <= u || s.o === -1;
+    } else
+      f = (b = this.colorState.find(({ id: M }) => M === m)) == null ? void 0 : b.show;
+    if (a === null || l === null || !f)
+      return;
+    t.save();
+    const h = P.getColorStringType(s.dataColor) === "RGBA" ? e.dataColor : P.colorStringToRgba(s.dataColor, 1);
+    t.fillStyle = h, n.use && (t.shadowOffsetX = n.offsetX, t.shadowOffsetY = n.offsetY, t.shadowBlur = n.blur, t.shadowColor = n.color);
+    const c = {
+      color: "",
+      lineWidth: 1,
+      opacity: 1,
+      radius: 0,
+      show: !0
+    };
+    if (i.use) {
+      const { color: M, width: r, radius: x } = i;
+      c.show = !0, c.radius = x, t.lineWidth = r, c.lineWidth = r, t.strokeStyle = M || h, c.color = M || h;
+    } else
+      c.show = !1, t.strokeStyle = h, c.color = h;
+    this.drawItem(t, a - 0.5, l - 0.5, d + 1, g + 1, c), t.restore(), this.showValue.use && this.drawValueLabels({
+      context: t,
+      data: s
+    });
+  }
+  /**
+   * Find graph item for tooltip
+   * @param {array}  offset       mouse position
+   *
+   * @returns {object} graph item
+   */
+  findGraphData(e) {
+    const o = e[0], s = e[1], t = {
+      data: null,
+      hit: !1,
+      color: null,
+      dataColor: null,
+      name: null
+    }, i = this.data, n = i.findIndex((a) => {
+      const { xp: l, yp: d, w: g, h: m } = a;
+      return l <= o && o <= l + g && d <= s && s <= d + m;
+    });
+    if (n > -1) {
+      const a = i[n];
+      t.data = a, t.color = a.dataColor, t.dataColor = a.dataColor, t.index = n, t.hit = !0;
+    }
+    return t;
+  }
+  findBlockRange({ xcp: e, xep: o, ycp: s, yep: t, range: i }) {
+    const n = this.labels, a = 1, l = {
+      xsp: Math.min(e, o),
+      ysp: Math.min(s, t),
+      width: Math.ceil(Math.abs(o - e)),
+      height: Math.ceil(Math.abs(t - s))
+    };
+    if (n.x.length && n.y.length) {
+      const d = this.currentLabelInfo.x.steps || n.x.length, g = this.currentLabelInfo.y.steps || n.y.length, { x1: m, x2: f, y1: h, y2: c } = i, b = (f - m) / d, M = (c - h) / g, r = {
+        xsp: e,
+        xep: o,
+        ysp: s,
+        yep: t
+      }, x = (C, u, y) => {
+        let I, w, p;
+        C === "x" ? (w = b, p = m + a) : (w = M, p = h), n[C].findIndex((S, O) => (I = p + w * O, I <= u && u <= I + w)) > -1 ? r[y] = ["xsp", "ysp"].includes(y) ? I : I + w : u < p && (r[y] = p);
+      };
+      x("x", Math.min(e, o), "xsp"), x("x", Math.max(e, o), "xep"), x("y", Math.min(s, t), "ysp"), x("y", Math.max(s, t), "yep"), l.xsp = Math.min(r.xsp, r.xep), l.ysp = Math.min(r.ysp, r.yep), l.width = Math.abs(r.xep - r.xsp), l.height = Math.abs(r.yep - r.ysp);
+    }
+    return l;
+  }
+  getFilteredLabel(e, o, s, t) {
+    return e.length !== o ? e.filter((i) => s <= i && i <= t) : e;
+  }
+  findSelectionRange(e) {
+    const { xsp: o, ysp: s, width: t, height: i, range: n } = e;
+    let a = null;
+    const { x1: l, x2: d, y1: g, y2: m } = n, { x: f, y: h } = this.labels;
+    if (f.length && h.length) {
+      const {
+        x: { steps: c, min: b, max: M },
+        y: { steps: r, min: x, max: C }
+      } = this.currentLabelInfo, u = c || f.length, y = r || h.length, I = (d - l) / u, w = (m - g) / y, p = o + t, T = s + i, S = {
+        min: Math.floor((o - l) / I),
+        max: Math.floor((p - l - I) / I)
+      }, O = y - 1, B = {
+        min: O - Math.round((T - g - w) / w),
+        max: O - Math.round((s - g) / w)
+      }, A = this.getFilteredLabel(f, u, b, M), L = this.getFilteredLabel(h, y, x, C);
+      a = {
+        xMin: A[S.min],
+        xMax: A[S.max],
+        yMin: L[B.min],
+        yMax: L[B.max]
+      };
+    }
+    return a;
+  }
+  getItemLabel(e, o) {
+    const { option: s, selected: t } = e;
+    let i = this.isHorizontal ? o.y : o.x;
+    return s != null && s.useBothAxis && (t != null && t.targetAxis) && (i = (t == null ? void 0 : t.targetAxis) === "yAxis" ? o.y : o.x), i;
+  }
+}
+export {
+  Z as default
+};

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

@@ -0,0 +1,292 @@
+import { defaultsDeep as st, isNil as A, isUndefined as ot } from "lodash-es";
+import { LINE_OPTION as lt, COLOR as K } from "../helpers/helpers.constant.js";
+import C from "../helpers/helpers.util.js";
+import z from "../helpers/helpers.canvas.js";
+class pt {
+  constructor(M, i, f) {
+    const e = st({}, i, lt);
+    Object.keys(e).forEach((t) => {
+      this[t] = e[t];
+    }), this.name === void 0 && (this.name = `series-${f}`), ["color", "pointFill", "fillColor"].forEach((t) => {
+      this[t] === void 0 && (this[t] = t === "pointFill" ? this.color : K[f % K.length]);
+    }), this.type = "line", this.sId = M, this.extent = {
+      downplay: { opacity: 0.3, lineWidth: 1 },
+      normal: { opacity: 1, lineWidth: 1 },
+      highlight: { opacity: 1, lineWidth: 2 }
+    }, this.data = [], this.beforeMouseXp = 0, this.beforeMouseYp = 0, this.beforeFindItemIndex = -1, this.size = {
+      comboOffset: 0
+    };
+  }
+  useLinearInterpolation() {
+    return this.interpolation === "linear" || this.interpolation === "none" && !!this.passingValue && this.hasPassingValueInData;
+  }
+  /**
+   * @typedef {Object} LineDrawParam
+   * @property {CanvasRenderingContext2D} ctx - 캔버스 렌더링 컨텍스트
+   * @property {object} chartRect - 차트 영역 정보
+   * @property {object} labelOffset - 라벨 오프셋 정보
+   * @property {object} axesSteps - 축 스텝 정보
+   * @property {object} [selectLabel] - 선택된 라벨 정보
+   * @property {object} [selectSeries] - 선택된 시리즈 정보
+   * @property {object} [legendHitInfo] - 범례 히트 정보
+   * @property {boolean} [isBrush] - 브러시 사용 여부
+   * @property {number} [unSelectedOpacity] - 비선택 시 opacity (0~1)
+   */
+  /**
+   * Draw series data
+   * @param {LineDrawParam} param     object for drawing series data
+   *
+   * @returns {undefined}
+   */
+  draw(M) {
+    var B, V, _, j, q, J, $;
+    if (!this.show)
+      return;
+    const {
+      ctx: i,
+      chartRect: f,
+      labelOffset: e,
+      axesSteps: t,
+      selectLabel: m,
+      selectSeries: s,
+      legendHitInfo: h,
+      isBrush: O,
+      unSelectedOpacity: F
+    } = M, c = m == null ? void 0 : m.option, u = (c == null ? void 0 : c.use) && (c == null ? void 0 : c.useSeriesOpacity), d = ((B = m == null ? void 0 : m.selected) == null ? void 0 : B.dataIndex) ?? [];
+    let n;
+    if (h)
+      n = this.extent[(h == null ? void 0 : h.sId) === this.sId ? "highlight" : "downplay"];
+    else if ((V = s == null ? void 0 : s.option) != null && V.use && ((j = (_ = s == null ? void 0 : s.selected) == null ? void 0 : _.seriesId) != null && j.length)) {
+      const a = (J = (q = s == null ? void 0 : s.selected) == null ? void 0 : q.seriesId) == null ? void 0 : J.includes(this.sId);
+      n = this.extent[a ? "highlight" : "downplay"];
+    } else u && d.length ? n = this.extent.downplay : n = this.extent.normal;
+    n === this.extent.downplay && (n = { ...n, opacity: F });
+    const S = (a) => a != null && a.includes("rgba") ? C.getOpacity(a) : n.opacity, b = this.color, o = S(b), l = this.pointFill, p = S(l), y = this.extent.downplay ? this.fillOpacity * n.opacity : this.fillOpacity, P = this.lineWidth * n.lineWidth;
+    i.beginPath(), i.save(), i.lineJoin = "round", i.lineWidth = P, i.strokeStyle = C.colorStringToRgba(b, o), this.segments && i.setLineDash(this.segments);
+    const D = this.useLinearInterpolation();
+    let L = 0;
+    const H = t.x[this.xAxisIndex], Y = t.y[this.yAxisIndex];
+    let X = f.chartWidth - (e.left + e.right);
+    const Q = f.chartHeight - (e.top + e.bottom);
+    this.combo && (L = X / (this.data.length || 1), X -= L, this.size.comboOffset = L);
+    const Z = f.x1 + e.left + L / 2, tt = f.y2 - e.bottom, G = (a) => {
+      const x = Math.min(
+        Math.max(a, H.graphMin),
+        H.graphMax
+      );
+      return z.calculateX(x, H.graphMin, H.graphMax, X, Z);
+    }, N = (a) => {
+      const x = Math.min(
+        Math.max(a, Y.graphMin),
+        Y.graphMax
+      );
+      return z.calculateY(x, Y.graphMin, Y.graphMax, Q, tt);
+    }, U = this.data.some((a) => a.o < 0), it = U ? N(0) : f.y2 - e.bottom;
+    let R;
+    if (this.data.forEach((a) => {
+      let x = G(a.x), v = N(a.y);
+      this.isExistGrp && D && a.o === null && (v = N(a.b ?? 0)), x !== null && (x += C.aliasPixel(x)), a.xp = x, a.yp = v, !(D && a.o === null) && (A(R == null ? void 0 : R.y) && !this.isExistGrp || !D && (A(R == null ? void 0 : R.y) || A(a.o)) ? i.moveTo(x, v) : i.lineTo(x, v), R = a);
+    }), i.stroke(), this.segments && i.setLineDash([]), this.fill && this.data.length) {
+      i.beginPath();
+      const a = C.colorStringToRgba(this.fillColor || b, y);
+      if (($ = this.fill) != null && $.gradient) {
+        let r = this.data[0].yp, E = this.data[0].y;
+        this.data.forEach((w) => {
+          w.yp && w.yp <= r ? r = w.yp : w.y && w.y >= E && (E = w.y);
+        });
+        const g = i.createLinearGradient(0, f.y2, 0, r), I = n.opacity < 1 ? a : b;
+        g.addColorStop(0, U ? I : a), g.addColorStop(0.5, a), g.addColorStop(1, I), i.fillStyle = g;
+      } else
+        i.fillStyle = a;
+      let x = null, v = null;
+      const T = this.data.map((r) => r == null ? void 0 : r.o), W = [];
+      for (let r = 0; r < T.length + 1; r++)
+        if (D && ot(T[r]) || !D && A(T[r])) {
+          if (x !== null && v !== null) {
+            const g = T.slice(x, r).findLastIndex(
+              (I) => !A(I) && I !== null
+            );
+            W.push([x, x + g]), x = null, v = null;
+          }
+        } else D && T[r] === null || (x = x === null ? r : x), v = r;
+      W.forEach(([r, E]) => {
+        if (r === E) {
+          const g = this.data[r];
+          i.moveTo(g.xp - P, g.yp), i.lineTo(g.xp + P, g.yp), i.lineTo(g.xp + P, N(g.b) ?? it), i.closePath();
+          return;
+        }
+        for (let g = r; g <= E; g++) {
+          const I = this.data[g];
+          if (g === r ? i.moveTo(I.xp, I.yp) : I.o !== null && i.lineTo(I.xp, I.yp), g === E) {
+            for (let w = E; w >= r; w--) {
+              const k = this.data[w], et = G(k.x);
+              if (k.o !== null) {
+                const nt = N(k.b) ?? N(0);
+                i.lineTo(et, nt);
+              }
+            }
+            i.closePath();
+          }
+        }
+      }), i.fill();
+    }
+    if (!O) {
+      i.strokeStyle = C.colorStringToRgba(b, o);
+      const a = C.colorStringToRgba(l, 1), x = C.colorStringToRgba(l, p), v = this.interpolation === "linear" && this.data.filter((T) => T.o !== null).length === 1;
+      this.data.forEach((T, W) => {
+        var w, k;
+        if (T.xp === null || T.yp === null || T.o === null)
+          return;
+        const r = (w = this.data[W - 1]) == null ? void 0 : w.o, E = (k = this.data[W + 1]) == null ? void 0 : k.o, g = !D && A(r) && A(E) || v, I = d.includes(W);
+        (this.point || g || I) && (i.fillStyle = I && !h ? a : x, z.drawPoint(i, this.pointStyle, this.pointSize, T.xp, T.yp));
+      });
+    }
+    i.restore();
+  }
+  /**
+   * 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(M, i) {
+    const f = M.data, e = i, { xp: t, yp: m, o: s } = f;
+    e.save(), t !== null && m !== null && s !== null && this.pointHighlight && (e.strokeStyle = C.colorStringToRgba(this.color, 0), e.fillStyle = C.colorStringToRgba(this.color, this.highlight.maxShadowOpacity), z.drawPoint(e, this.pointStyle, this.highlight.maxShadowSize, t, m), e.fillStyle = this.color, z.drawPoint(e, this.pointStyle, this.highlight.maxSize, t, m), e.fillStyle = "#fff", z.drawPoint(e, this.pointStyle, this.highlight.defaultSize, t, m)), e.restore();
+  }
+  /**
+   * Find graph item
+   * @param {array}    offset          mouse position
+   * @param {boolean}  isHorizontal
+   * @param {number}   dataIndex       selected label data index
+   * @param {boolean}  useSelectLabelOrItem   used to display select label/item at tooltip location
+   *
+   * @returns {object} graph item
+   */
+  findGraphData(M, i, f, e) {
+    var F;
+    const t = M[0], m = M[1], s = { data: null, hit: !1, color: this.color }, h = this.data.filter((c) => !C.isNullOrUndefined(c.x)), O = this.useLinearInterpolation();
+    if (h != null && h.length)
+      if (typeof f == "number" && this.show) {
+        if (s.data = h[f], s.index = f, s.data) {
+          const c = h[f];
+          Math.abs(m - c.yp) <= 15 && (s.hit = !0);
+        }
+      } else if (typeof this.beforeFindItemIndex == "number" && this.beforeFindItemIndex !== -1 && this.show && e)
+        s.data = h[this.beforeFindItemIndex], s.index = this.beforeFindItemIndex;
+      else {
+        let c = 1 / 0, u = -1;
+        const d = [];
+        h.forEach((o, l) => {
+          o.xp !== null && o.yp !== null && o.o !== null && d.push({ ...o, originalIndex: l });
+        }), d.length === 0 && h.forEach((o, l) => {
+          d.push({ ...o, originalIndex: l });
+        });
+        let n = 0, S = d.length - 1;
+        for (; n <= S; ) {
+          const o = Math.floor((n + S) / 2), l = d[o], p = Math.abs(t - l.xp);
+          if (p < c && (c = p, u = l.originalIndex), l.xp < t) {
+            if (n = o + 1, n < d.length) {
+              const y = Math.abs(t - d[n].xp);
+              y < c && (c = y, u = d[n].originalIndex);
+            }
+          } else if (l.xp > t) {
+            if (S = o - 1, S >= 0) {
+              const y = Math.abs(t - d[S].xp);
+              y < c && (c = y, u = d[S].originalIndex);
+            }
+          } else
+            break;
+        }
+        const b = d.findIndex((o) => o.originalIndex === u);
+        if (b !== -1)
+          for (let o = Math.max(0, b - 2); o <= Math.min(d.length - 1, b + 2); o++) {
+            const l = d[o], p = Math.abs(t - l.xp);
+            p < c && (c = p, u = l.originalIndex);
+          }
+        if (u !== -1) {
+          let o = 50;
+          if (h.length > 1) {
+            const p = [];
+            for (let y = 1; y < h.length; y++)
+              h[y].xp !== null && h[y - 1].xp !== null && p.push(Math.abs(h[y].xp - h[y - 1].xp));
+            p.length > 0 && (o = p.reduce((y, P) => y + P, 0) / p.length);
+          }
+          const l = Math.max(o, 1);
+          if (c <= l)
+            s.data = h[u], s.index = u;
+          else {
+            let p = !1, y = O ? 1 / 0 : l;
+            const P = O ? d : h;
+            for (let D = 0; D < P.length; D++) {
+              const L = Math.abs(t - P[D].xp);
+              L <= y && (p = !0, y = L, u = O ? P[D].originalIndex : D);
+            }
+            p && (s.data = h[u], s.index = u);
+          }
+          if (s.data) {
+            const p = h[u];
+            Math.abs(m - p.yp) <= 15 && (s.hit = !0);
+          }
+        }
+      }
+    return e || (this.beforeMouseXp = t, this.beforeMouseYp = m, typeof s.index == "number" && (this.beforeFindItemIndex = s.index)), O && ((F = s == null ? void 0 : s.data) == null ? void 0 : F.o) === null && (s.data = null), s;
+  }
+  /**
+   * Find approximate graph item
+   * @param {array}  offset       mouse position
+   *
+   * @returns {object} graph item
+   */
+  findApproximateData(M) {
+    var u, d;
+    const i = M[0], f = M[1], e = { data: null, hit: !1, color: this.color }, t = this.data.filter((n) => !C.isNullOrUndefined(n.x));
+    if (!t.length)
+      return e;
+    const m = t.length > 1 ? Math.abs(((u = t[1]) == null ? void 0 : u.xp) - ((d = t[0]) == null ? void 0 : d.xp)) : 50, s = Math.max(m * 0.4, 10);
+    let h = 0, O = t.length - 1, F = -1, c = 1 / 0;
+    for (; h <= O; ) {
+      const n = Math.floor((h + O) / 2), S = t[n].xp;
+      if (S - s <= i && i <= S + s) {
+        const b = Math.max(0, n - 2), o = Math.min(t.length - 1, n + 2);
+        for (let l = b; l <= o; l++)
+          if (t[l].xp !== null && t[l].yp !== null) {
+            const p = Math.sqrt((i - t[l].xp) ** 2 + (f - t[l].yp) ** 2);
+            p < c && (c = p, F = l);
+          }
+        return F !== -1 && (e.data = t[F], e.index = F, c < 5 && (e.hit = !0)), e;
+      } else if (S + s < i) {
+        if (n < O && i < t[n + 1].xp) {
+          const b = Math.abs(t[n].xp - i), o = Math.abs(t[n + 1].xp - i);
+          e.data = b > o ? t[n + 1] : t[n], e.index = b > o ? n + 1 : n;
+          const l = e.data;
+          return Math.abs(f - l.yp) < 10 && (e.hit = !0), e;
+        }
+        h = n + 1;
+      } else {
+        if (n > 0 && i > t[n - 1].xp) {
+          const b = Math.abs(t[n - 1].xp - i), o = Math.abs(t[n].xp - i);
+          e.data = b > o ? t[n] : t[n - 1], e.index = b > o ? n : n - 1;
+          const l = e.data;
+          return Math.abs(f - l.yp) < 10 && (e.hit = !0), e;
+        }
+        O = n - 1;
+      }
+    }
+    return e;
+  }
+  /**
+   * Returns items in range
+   * @param {object} params  range values
+   *
+   * @returns {array}
+   */
+  findItems({ xsp: M, width: i }) {
+    const f = M + i;
+    return this.data.filter((e) => M - 1 <= e.xp && e.xp <= f + 1);
+  }
+}
+export {
+  pt as default
+};