@hybridcore/ui 1.5.80 → 1.5.83

package/dist/DateAxis-CMum47iz.js

@@ -0,0 +1,924 @@
+import { C as it, G as Z, n as rt, m as st, o as K, s as q, q as lt, i as y, r as J, t as ht, u as Q, v as ut, j as b, V as at, w as C, x as $, y as ct, z as f, D as G, B as S, E as gt, F as dt, H as z, I as tt, J as et, K as vt, M as N, k as ft } from "./AxisRendererY-kADUad00.js";
+class H extends it {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_alwaysShow", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "lineX", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.children.push(Z.new(this._root, {
+        themeTags: ["x"]
+      }))
+    }), Object.defineProperty(this, "lineY", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.children.push(Z.new(this._root, {
+        themeTags: ["y"]
+      }))
+    }), Object.defineProperty(this, "selection", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.children.push(rt.new(this._root, {
+        themeTags: ["selection", "cursor"],
+        layer: 30
+      }))
+    }), Object.defineProperty(this, "_movePoint", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_lastPoint", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: { x: 0, y: 0 }
+    }), Object.defineProperty(this, "_lastPoint2", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: { x: 0, y: 0 }
+    }), Object.defineProperty(this, "_tooltipX", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_tooltipY", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "chart", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_toX", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), Object.defineProperty(this, "_toY", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  _afterNew() {
+    this._settings.themeTags = st(this._settings.themeTags, ["xy", "cursor"]), super._afterNew(), this.setAll({ width: K, height: K, isMeasured: !0, position: "absolute" }), this.states.create("hidden", { visible: !0, opacity: 0 }), this._drawLines(), this.setPrivateRaw("visible", !1), this._disposers.push(this.setTimeout(() => {
+      this.setPrivate("visible", !0);
+    }, 500)), this._disposers.push(this.lineX.events.on("positionchanged", () => {
+      this._handleXLine();
+    })), this._disposers.push(this.lineY.events.on("positionchanged", () => {
+      this._handleYLine();
+    })), this._disposers.push(this.lineX.events.on("focus", () => this._handleLineFocus())), this._disposers.push(this.lineX.events.on("blur", () => this._handleLineBlur())), this._disposers.push(this.lineY.events.on("focus", () => this._handleLineFocus())), this._disposers.push(this.lineY.events.on("blur", () => this._handleLineBlur())), q("keyboardevents") && this._disposers.push(lt(document, "keydown", (t) => {
+      this._handleLineMove(ut(t), t.ctrlKey);
+    }));
+  }
+  _setUpTouch() {
+    const t = this.chart;
+    t && (t.plotContainer._display.cancelTouch = this.get("behavior") != "none");
+  }
+  _handleXLine() {
+    let t = this.lineX.x(), e = !0;
+    (t < 0 || t > this.width()) && (e = !1), this.lineX.setPrivate("visible", e);
+  }
+  _handleYLine() {
+    let t = this.lineY.y(), e = !0;
+    (t < 0 || t > this.height()) && (e = !1), this.lineY.setPrivate("visible", e);
+  }
+  _handleLineMove(t, e) {
+    let i = "";
+    const s = this.chart;
+    let n;
+    if (s && s.xAxes.length) {
+      this._root.focused(this.lineX) ? (i = "positionX", n = s.xAxes.getIndex(0)) : this._root.focused(this.lineY) && (n = s.yAxes.getIndex(0), i = "positionY");
+      let a = 1;
+      if (e && (a = 5), n) {
+        let r = n.get("renderer").get("inversed", !1), o;
+        t == "ArrowRight" || t == "ArrowDown" ? o = 1 : t == "ArrowLeft" || t == "ArrowUp" ? o = -1 : t == "Tab" && (o = 0), o != null && (r && (o *= -1), this.set(i, n.nextPosition(o * a)));
+      }
+    }
+  }
+  _handleLineFocus() {
+    this._alwaysShow = this.get("alwaysShow", !1), this.setAll({
+      positionX: this.getPrivate("positionX", 0),
+      positionY: this.getPrivate("positionY", 0),
+      alwaysShow: !0
+    }), this._handleLineMove("Tab");
+  }
+  _handleLineBlur() {
+    (this.lineX.isFocus() || this.lineY.isFocus()) && this.setAll({
+      positionX: void 0,
+      positionY: void 0,
+      alwaysShow: this._alwaysShow
+    });
+  }
+  _prepareChildren() {
+    if (super._prepareChildren(), this.isDirty("xAxis")) {
+      this._tooltipX = !1;
+      const t = this.get("xAxis");
+      if (t) {
+        const e = t.get("tooltip");
+        e && (this._tooltipX = !0, this._disposers.push(e.on("pointTo", () => {
+          this._updateXLine(e);
+        })));
+      }
+    }
+    if (this.isDirty("yAxis")) {
+      this._tooltipY = !1;
+      const t = this.get("yAxis");
+      if (t) {
+        const e = t.get("tooltip");
+        e && (this._tooltipY = !0, this._disposers.push(e.on("pointTo", () => {
+          this._updateYLine(e);
+        })));
+      }
+    }
+  }
+  _handleSyncWith() {
+    const t = this.chart;
+    if (t) {
+      const e = this.get("syncWith"), i = [];
+      e && y(e, (s) => {
+        const n = s.chart;
+        n && i.push(n);
+      }), t._otherCharts = i;
+    }
+  }
+  _updateChildren() {
+    if (super._updateChildren(), this._handleSyncWith(), this.isDirty("positionX") || this.isDirty("positionY")) {
+      const t = this.get("positionX"), e = this.get("positionY");
+      t == null && e == null ? this.hide(0) : (this._movePoint = this.toGlobal(this._getPoint(this.get("positionX", 0), this.get("positionY", 0))), this.handleMove());
+    }
+  }
+  _updateXLine(t) {
+    let e = J(this._display.toLocal(t.get("pointTo", { x: 0, y: 0 })).x, 3);
+    this._toX != e && (this.lineX.animate({ key: "x", to: e, duration: t.get("animationDuration", 0), easing: t.get("animationEasing") }), this._toX = e);
+  }
+  _updateYLine(t) {
+    let e = J(this._display.toLocal(t.get("pointTo", { x: 0, y: 0 })).y, 3);
+    this._toY != e && (this.lineY.animate({ key: "y", to: e, duration: t.get("animationDuration", 0), easing: t.get("animationEasing") }), this._toY = e);
+  }
+  _drawLines() {
+    this.lineX.set("draw", (t) => {
+      t.moveTo(0, 0), t.lineTo(0, this.height());
+    }), this.lineY.set("draw", (t) => {
+      t.moveTo(0, 0), t.lineTo(this.width(), 0);
+    });
+  }
+  updateCursor() {
+    this.get("alwaysShow") && (this._movePoint = this.toGlobal(this._getPoint(this.get("positionX", 0), this.get("positionY", 0)))), this.handleMove();
+  }
+  _setChart(t) {
+    this.chart = t, this._handleSyncWith();
+    const e = t.plotContainer;
+    this.events.on("boundschanged", () => {
+      this._disposers.push(this.setTimeout(() => {
+        this.updateCursor();
+      }, 50));
+    }), q("touchevents") && (this._disposers.push(e.events.on("click", (s) => {
+      ht(s.originalEvent) && this._handleMove(s);
+    })), this._setUpTouch()), this._disposers.push(e.events.on("pointerdown", (s) => {
+      this._handleCursorDown(s);
+    })), this._disposers.push(e.events.on("globalpointerup", (s) => {
+      this._handleCursorUp(s), !s.native && !this.isHidden() && this._handleMove(s);
+    })), this._disposers.push(e.events.on("globalpointermove", (s) => {
+      !this.get("syncWith") && Q(e._downPoints).length == 0 && !s.native && this.isHidden() || (this._handleMove(s), Math.hypot(this._lastPoint2.x - s.point.x, this._lastPoint2.y - s.point.y) > 1 && (this._handleLineBlur(), this._lastPoint2 = s.point));
+    }));
+    const i = this.parent;
+    i && i.children.moveValue(this.selection);
+  }
+  _inPlot(t) {
+    const e = this.chart;
+    return e ? e.inPlot(t) : !1;
+  }
+  _handleCursorDown(t) {
+    if (t.originalEvent.button == 2)
+      return;
+    const e = t.point;
+    let i = this._display.toLocal(e);
+    const s = this.chart;
+    if (this.selection.set("draw", () => {
+    }), s && this._inPlot(i)) {
+      if (this._downPoint = i, this.get("behavior") != "none") {
+        this.selection.show();
+        const r = "selectstarted";
+        this.events.isEnabled(r) && this.events.dispatch(r, { type: r, target: this, originalEvent: t.originalEvent });
+      }
+      let n = this._getPosition(i).x, a = this._getPosition(i).y;
+      this.setPrivate("downPositionX", n), this.setPrivate("downPositionY", a);
+    }
+  }
+  _handleCursorUp(t) {
+    if (this._downPoint) {
+      const e = this.get("behavior", "none");
+      if (e != "none") {
+        e.charAt(0) === "z" && this.selection.hide();
+        const i = t.point;
+        let s = this._display.toLocal(i);
+        const n = this._downPoint, a = this.get("moveThreshold", 1);
+        if (s && n) {
+          let r = !1;
+          if ((e === "zoomX" || e === "zoomXY" || e === "selectX" || e === "selectXY") && Math.abs(s.x - n.x) > a && (r = !0), (e === "zoomY" || e === "zoomXY" || e === "selectY" || e === "selectXY") && Math.abs(s.y - n.y) > a && (r = !0), r) {
+            const o = "selectended";
+            this.events.isEnabled(o) && this.events.dispatch(o, { type: o, target: this, originalEvent: t.originalEvent });
+          } else {
+            const o = "selectcancelled";
+            this.events.isEnabled(o) && this.events.dispatch(o, { type: o, target: this, originalEvent: t.originalEvent });
+          }
+        }
+      }
+    }
+    this._downPoint = void 0;
+  }
+  _handleMove(t) {
+    if (this.getPrivate("visible")) {
+      const e = this.chart;
+      if (e && Q(e.plotContainer._downPoints).length > 1) {
+        this.set("forceHidden", !0);
+        return;
+      } else
+        this.set("forceHidden", !1);
+      const i = t.point, s = this._lastPoint;
+      if (Math.round(s.x) === Math.round(i.x) && Math.round(s.y) === Math.round(i.y))
+        return;
+      this._lastPoint = i, this.setPrivate("lastPoint", i), this.handleMove({ x: i.x, y: i.y }, !1, t.originalEvent);
+    }
+  }
+  _getPosition(t) {
+    return { x: t.x / this.width(), y: t.y / this.height() };
+  }
+  /**
+   * Moves the cursor to X/Y coordinates within chart container (`point`).
+   *
+   * If `skipEvent` parameter is set to `true`, the move will not invoke
+   * the `"cursormoved"` event.
+   *
+   * @param  point      X/Y to move cursor to
+   * @param  skipEvent  Do not fire "cursormoved" event
+   */
+  handleMove(t, e, i) {
+    t || (t = this._movePoint);
+    const s = this.get("alwaysShow");
+    if (!t) {
+      this.hide(0);
+      return;
+    }
+    this._movePoint = t;
+    let n = this._display.toLocal(t), a = this.chart;
+    if (a && (this._inPlot(n) || this._downPoint)) {
+      a._movePoint = t, this.isHidden() && (this.show(), this.get("behavior", "").charAt(0) == "z" && this.selection.set("draw", () => {
+      }));
+      let r = n.x, o = n.y, l = this._getPosition(n);
+      this.setPrivate("point", n);
+      let d = this.get("snapToSeries");
+      this._downPoint && (d = void 0);
+      let u = this.get("positionX"), m = l.x;
+      b(u) && (m = u);
+      let v = this.get("positionY"), P = l.y;
+      b(v) && (P = v), this.setPrivate("positionX", m), this.setPrivate("positionY", P);
+      const T = this._getPoint(m, P);
+      if (r = T.x, o = T.y, a.xAxes.each((h) => {
+        h._handleCursorPosition(m, d), s && h.handleCursorShow();
+      }), a.yAxes.each((h) => {
+        h._handleCursorPosition(P, d), s && h.handleCursorShow();
+      }), !e) {
+        a._handleCursorPosition();
+        const h = "cursormoved";
+        this.events.isEnabled(h) && this.events.dispatch(h, { type: h, target: this, point: t, originalEvent: i });
+      }
+      this._updateLines(r, o), a.arrangeTooltips();
+    } else if (!this._downPoint && !s) {
+      this.hide(0);
+      const r = "cursorhidden";
+      this.events.isEnabled(r) && this.events.dispatch(r, { type: r, target: this });
+    }
+    this._downPoint && this.get("behavior") != "none" && this._updateSelection(n);
+  }
+  _getPoint(t, e) {
+    return { x: this.width() * t, y: this.height() * e };
+  }
+  _updateLines(t, e) {
+    this._tooltipX || this.lineX.set("x", t), this._tooltipY || this.lineY.set("y", e), this._drawLines();
+  }
+  _updateSelection(t) {
+    const e = this.selection, i = this.get("behavior"), s = this.width(), n = this.height();
+    t.x < 0 && (t.x = 0), t.x > s && (t.x = s), t.y < 0 && (t.y = 0), t.y > n && (t.y = n), e.set("draw", (a) => {
+      const r = this._downPoint;
+      r && (i === "zoomXY" || i === "selectXY" ? (a.moveTo(r.x, r.y), a.lineTo(r.x, t.y), a.lineTo(t.x, t.y), a.lineTo(t.x, r.y), a.lineTo(r.x, r.y)) : i === "zoomX" || i === "selectX" ? (a.moveTo(r.x, 0), a.lineTo(r.x, n), a.lineTo(t.x, n), a.lineTo(t.x, 0), a.lineTo(r.x, 0)) : (i === "zoomY" || i === "selectY") && (a.moveTo(0, r.y), a.lineTo(s, r.y), a.lineTo(s, t.y), a.lineTo(0, t.y), a.lineTo(0, r.y)));
+    });
+  }
+  _onHide() {
+    if (this.isHidden()) {
+      let t = this.chart;
+      t && (t.xAxes.each((e) => {
+        e.handleCursorHide();
+      }), t.yAxes.each((e) => {
+        e.handleCursorHide();
+      }), t.series.each((e) => {
+        e.handleCursorHide();
+      }));
+    }
+    super._onHide();
+  }
+  _onShow() {
+    if (!this.isHidden()) {
+      let t = this.chart;
+      t && (t.xAxes.each((e) => {
+        e.handleCursorShow();
+      }), t.yAxes.each((e) => {
+        e.handleCursorShow();
+      }));
+    }
+    super._onShow();
+  }
+  _dispose() {
+    super._dispose(), this.selection.dispose();
+  }
+}
+Object.defineProperty(H, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "XYCursor"
+});
+Object.defineProperty(H, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: it.classNames.concat([H.className])
+});
+class B extends at {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_dataGrouped", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_seriesDataGrouped", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_groupingCalculated", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: !1
+    }), Object.defineProperty(this, "_intervalDuration", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 1
+    }), Object.defineProperty(this, "_baseDuration", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 1
+    }), Object.defineProperty(this, "_intervalMax", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    }), Object.defineProperty(this, "_intervalMin", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: {}
+    });
+  }
+  _afterNew() {
+    this._settings.themeTags = st(this._settings.themeTags, ["axis"]), super._afterNew(), this.addTag("date"), this._setBaseInterval(this.get("baseInterval")), this.on("baseInterval", () => {
+      this._setBaseInterval(this.get("baseInterval"));
+    });
+  }
+  _setBaseInterval(t) {
+    this.setPrivateRaw("baseInterval", t), this._baseDuration = C(t);
+  }
+  _fixZoomFactor() {
+    const t = this.get("maxZoomFactor");
+    t != null && t != 1 / 0 ? this.setPrivateRaw("maxZoomFactor", t) : this.setPrivateRaw("maxZoomFactor", Math.round((this.getPrivate("max", 0) - this.getPrivate("min", 0)) / this.baseMainDuration()));
+  }
+  _groupData() {
+    const t = this.getPrivate("min"), e = this.getPrivate("max");
+    if (b(t) && b(e)) {
+      this._fixZoomFactor();
+      const i = this.getPrivate("groupInterval");
+      if (i ? this._setBaseInterval(i) : this._setBaseInterval(this.get("baseInterval")), this.isDirty("groupInterval")) {
+        let s = this.get("groupInterval");
+        s && (this.setRaw("groupIntervals", [s]), this._handleRangeChange());
+      }
+      if (this.isDirty("groupData") && !this._dataGrouped) {
+        if (this.get("groupData"))
+          y(this.series, (s) => {
+            this._groupSeriesData(s);
+          }), this._handleRangeChange();
+        else {
+          let s = this.get("baseInterval"), n = s.timeUnit + s.count;
+          y(this.series, (a) => {
+            a.setDataSet(n), a.resetGrouping();
+          }), this._setBaseInterval(s), this.setPrivateRaw("groupInterval", void 0), this.markDirtyExtremes();
+        }
+        this._dataGrouped = !0;
+      }
+    }
+  }
+  _groupSeriesData(t) {
+    if (this.get("groupData") && !t.get("groupDataDisabled")) {
+      this._dataGrouped = !0, this._seriesDataGrouped = !0;
+      let e = [], i = this.baseMainDuration(), s = this.get("groupIntervals");
+      y(s, (v) => {
+        C(v) > i && e.push(v);
+      }), t._dataSets = {};
+      const n = this.getPrivate("name") + this.get("renderer").getPrivate("letter");
+      let a;
+      const r = t.get("baseAxis");
+      t.get("xAxis") === r ? a = t._valueYFields : t.get("yAxis") === r && (a = t._valueXFields);
+      let o = t._mainDataItems, l = this.get("baseInterval"), d = l.timeUnit + l.count;
+      t._dataSets[d] = o;
+      const u = t.get("groupDataCallback");
+      let m = t.get("groupDataWithOriginals", !1);
+      u && (m = !0), y(e, (v) => {
+        let P = -1 / 0, T = v.timeUnit + v.count;
+        t._dataSets[T] = [];
+        let h, M = {}, U = {}, R = {}, L = {};
+        y(a, (p) => {
+          M[p] = 0, U[p] = 0, R[p] = t.get(p + "Grouped"), L[p] = p + "Working";
+        });
+        let X = S(v.timeUnit), A = o[0], Y;
+        A && (Y = o[0].get(n));
+        let g;
+        y(o, (p) => {
+          let V = p.get(n), x = f(V, v.timeUnit, v.count, this._root, Y), k;
+          P < x - X / 24 ? (k = et(p.dataContext), h = new G(t, k, t._makeDataItem(k)), h.setRaw(n, x), t._dataSets[T].push(h), y(a, (c) => {
+            let w = p.get(c);
+            b(w) ? (h.setRaw(c, w), h.setRaw(L[c], w), U[c] = 1, M[c] = w) : (M[c] = 0, U[c] = 0);
+          }), m && h.set("originals", [p]), u && g && u(g, v), g = h) : (y(a, (c) => {
+            let w = R[c], _ = p.get(c);
+            if (_ != null) {
+              let D = h.get(c);
+              switch (w) {
+                case "close":
+                  h.setRaw(c, _);
+                  break;
+                case "sum":
+                  h.setRaw(c, D + _);
+                  break;
+                case "open":
+                  break;
+                case "low":
+                  _ < D && h.setRaw(c, _);
+                  break;
+                case "high":
+                  _ > D && h.setRaw(c, _);
+                  break;
+                case "average":
+                  U[c]++, M[c] += _;
+                  let E = M[c] / U[c];
+                  h.setRaw(c, E);
+                  break;
+                case "extreme":
+                  Math.abs(_) > Math.abs(D) && h.setRaw(c, _);
+                  break;
+              }
+              h.setRaw(L[c], h.get(c));
+              let F = et(p.dataContext);
+              F[n] = x, h.dataContext = F;
+            }
+          }), m && h.get("originals").push(p)), P = x;
+        }), u && g && u(g, v);
+      }), t._dataSetId && t.setDataSet(t._dataSetId), this.markDirtySize(), this._seriesAdded && this._root.events.once("frameended", () => {
+        this.markDirtySize();
+      });
+    }
+  }
+  _clearDirty() {
+    super._clearDirty(), this._groupingCalculated = !1, this._dataGrouped = !1;
+  }
+  /**
+   * Returns a time interval axis would group data to for a specified duration.
+   *
+   * @since 5.2.1
+   */
+  getGroupInterval(t) {
+    let e = this.get("baseInterval"), i = $(0, t, this.get("groupCount", 1 / 0), this.get("groupIntervals"));
+    return C(i) < C(e) && (i = Object.assign({}, e)), i;
+  }
+  /**
+   * Return `max` of a specified time interval.
+   *
+   * Will work only if the axis was grouped to this interval at least once.
+   *
+   * @since 5.2.1
+   * @param   interval  Interval
+   * @return            Max
+   */
+  getIntervalMax(t) {
+    return this._intervalMax[t.timeUnit + t.count];
+  }
+  /**
+   * Return `min` of a specified time interval.
+   *
+   * Will work only if the axis was grouped to this interval at least once.
+   *
+   * @since 5.2.1
+   * @param   interval  Interval
+   * @return            Min
+   */
+  getIntervalMin(t) {
+    return this._intervalMin[t.timeUnit + t.count];
+  }
+  _handleRangeChange() {
+    super._handleRangeChange();
+    let t = Math.round(this.getPrivate("selectionMin")), e = Math.round(this.getPrivate("selectionMax"));
+    if (b(t) && b(e)) {
+      if (this.get("endLocation") == 0 && (e += 1), this.get("groupData") && !this._groupingCalculated) {
+        this._groupingCalculated = !0;
+        let i = this.get("groupInterval"), s = this.getPrivate("groupInterval"), n = e - t + (this.get("startLocation", 0) + (1 - this.get("endLocation", 1)) * this.baseDuration());
+        if (s) {
+          let a = C(s);
+          n = Math.ceil(n / a) * a;
+        }
+        if (i || (i = this.getGroupInterval(n)), i && (!s || s.timeUnit !== i.timeUnit || s.count !== i.count || this._seriesDataGrouped)) {
+          this._seriesDataGrouped = !1, this.setPrivateRaw("groupInterval", i), this._setBaseInterval(i);
+          let a = i.timeUnit + i.count;
+          y(this.series, (r) => {
+            r.get("baseAxis") === this && r.setDataSet(a);
+          }), this.markDirtyExtremes(), this._root.events.once("frameended", () => {
+            this._root.events.once("frameended", () => {
+              const r = "groupintervalchanged";
+              this.events.isEnabled(r) && this.events.dispatch(r, { type: r, target: this });
+            });
+          });
+        }
+      }
+      y(this.series, (i) => {
+        if (i.get("baseAxis") === this) {
+          let s = this.getPrivate("name") + this.get("renderer").getPrivate("letter"), a = vt(i.dataItems, (h) => N(h.get(s), t)).index;
+          a > 0 && (a -= 1), e += this.baseDuration() * (1 - this.get("endLocation", 1));
+          let o = tt(i.dataItems, (h) => N(h.get(s), e)).index, l = o;
+          l > 1 && l--;
+          const d = i.dataItems[a], u = i.dataItems[l];
+          let m, v;
+          d && (v = d.get(s)), u && (m = u.get(s));
+          let P = !1;
+          m != null && v != null && (m < t || v > e) && (P = !0), i.setPrivate("outOfSelection", P), i.setPrivate("startIndex", a);
+          let T = i._adjustStartIndex(a);
+          i.getPrivate("adjustedStartIndex") !== T && (i.setPrivate("adjustedStartIndex", T), this.root.events.once("frameended", () => {
+            i._markDirtyPrivateKey("adjustedStartIndex");
+          })), i.setPrivate("endIndex", o);
+        }
+      });
+    }
+  }
+  _adjustMinMax(t, e, i, s) {
+    return { min: t, max: e, step: (e - t) / i };
+  }
+  /**
+   * @ignore
+   */
+  intervalDuration() {
+    return this._intervalDuration;
+  }
+  _saveMinMax(t, e) {
+    let i = this.getPrivate("groupInterval");
+    i || (i = this.get("baseInterval"));
+    let s = i.timeUnit + i.count;
+    this._intervalMin[s] = t, this._intervalMax[s] = e;
+  }
+  _getM(t) {
+    return t == "day" || t == "month" || t == "year" ? 1.05 : 1.01;
+  }
+  _getMinorInterval(t) {
+    var e;
+    let i, s = t.count, n = t.timeUnit;
+    return s > 1 && (s == 10 || s == 15 ? s = 5 : s == 12 ? s = 2 : s == 6 ? s = 1 : s == 30 ? s = 10 : s < 10 && (s = 1), i = { timeUnit: n, count: s }), n == "week" && (((e = this.getPrivate("baseInterval")) === null || e === void 0 ? void 0 : e.timeUnit) != "week" ? i = { timeUnit: "day", count: 1 } : i = { timeUnit: "week", count: 1 }), n == "year" && s == 1 && this.getPrivate("selectionMax", 0) - this.getPrivate("selectionMin", 0) < 4 * 366 * 24 * 60 * 60 * 1e3 && (i = { timeUnit: "month", count: 1 }), i;
+  }
+  _prepareAxisItems() {
+    const t = this.getPrivate("min"), e = this.getPrivate("max");
+    if (b(t) && b(e)) {
+      const i = this._root, s = Math.round(this.getPrivate("selectionMin")), n = Math.round(this.getPrivate("selectionMax")), a = this.get("renderer"), r = this.getPrivate("baseInterval");
+      let o = s, l = 0;
+      const d = this.get("gridIntervals");
+      let u = $(0, n - s, a.gridCount(), d);
+      C(u) < this.baseDuration() && (u = Object.assign({}, r));
+      const m = C(u);
+      this._intervalDuration = m;
+      const v = ct(u.timeUnit), P = i.utc, T = i.timezone;
+      o = f(s - m, u.timeUnit, u.count, i, t);
+      let h = o - m, M;
+      const U = this.get("dateFormats");
+      this.setPrivateRaw("gridInterval", u);
+      const R = a.get("minorLabelsEnabled"), L = a.get("minorGridEnabled", R);
+      let X, A = 0;
+      L && (X = this._getMinorInterval(u), A = C(X));
+      let Y = 0;
+      for (; o < n + m; ) {
+        let g;
+        this.dataItems.length < l + 1 ? (g = new G(this, void 0, {}), this._dataItems.push(g), this.processDataItem(g)) : g = this.dataItems[l], this._createAssets(g, []), this._toggleDataItem(g, !0), g.setRaw("value", o), g.setRaw("labelEndValue", void 0);
+        let p = o + S(u.timeUnit, u.count * this._getM(u.timeUnit));
+        p = f(p, u.timeUnit, 1, i), g.setRaw("endValue", p);
+        let V = new Date(o);
+        M = U[u.timeUnit], v && this.get("markUnitChange") && b(h) && u.timeUnit != "year" && gt(o, h, v, P, T) && (M = this.get("periodChangeDateFormats")[u.timeUnit]);
+        const x = g.get("label");
+        x && x.set("text", i.dateFormatter.format(V, M));
+        let k = u.count;
+        if (u.timeUnit == "week" ? x == null || x.set("location", this.get("weekLabelLocation", 0)) : x == null || x.set("location", a.labels.template.get("location")), L) {
+          k = 1;
+          let c = u.timeUnit;
+          c == "week" && this.get("skipFirstMinor") && (c = "day");
+          let w = o + S(c, this._getM(c));
+          w = f(w, c, 1, i), g.setRaw("labelEndValue", w);
+        }
+        if (this._prepareDataItem(g, k), h = o, o = p, X) {
+          const c = X.timeUnit, w = X.count, _ = this._getM(c);
+          this.get("skipFirstMinor") || (h -= A * _);
+          let D = f(h + A * _, c, w, i, h), F, E = this.get("minorDateFormats", this.get("dateFormats"));
+          for (; D < o - 0.01 * A; ) {
+            let I;
+            this.minorDataItems.length < Y + 1 ? (I = new G(this, void 0, {}), this.minorDataItems.push(I), this.processDataItem(I)) : I = this.minorDataItems[Y], this._createAssets(I, ["minor"], !0), this._toggleDataItem(I, !0), I.setRaw("value", D);
+            let j = D + S(c, w * _);
+            j = f(j, c, 1, i), I.setRaw("endValue", j);
+            let ot = new Date(D);
+            M = E[c];
+            const O = I.get("label");
+            if (O && (R ? O.set("text", i.dateFormatter.format(ot, M)) : O.setPrivate("visible", !1)), this._prepareDataItem(I, 1), D == F)
+              break;
+            if (!I.get("isRange")) {
+              const W = this.get("fillRule");
+              W && W(I);
+            }
+            F = D, D = j, Y++;
+          }
+        }
+        if (o == h)
+          break;
+        l++;
+      }
+      for (let g = l; g < this.dataItems.length; g++)
+        this._toggleDataItem(this.dataItems[g], !1);
+      for (let g = Y; g < this.minorDataItems.length; g++)
+        this._toggleDataItem(this.minorDataItems[g], !1);
+      y(this.series, (g) => {
+        g.inited && g._markDirtyAxes();
+      });
+    }
+    this._updateGhost();
+  }
+  _updateFinals(t, e) {
+    this.setPrivateRaw("selectionMinFinal", this.positionToValue(t)), this.setPrivateRaw("selectionMaxFinal", this.positionToValue(e));
+  }
+  _getDelta() {
+    this._deltaMinMax = this.baseDuration() / 2;
+  }
+  _fixMin(t) {
+    const e = this.getPrivate("baseInterval"), i = e.timeUnit;
+    let s = f(t, i, e.count, this._root), n = s + S(i, e.count * this._getM(i));
+    return n = f(n, i, 1, this._root), s + (n - s) * this.get("startLocation", 0);
+  }
+  _fixMax(t) {
+    const e = this.getPrivate("baseInterval"), i = e.timeUnit;
+    let s = f(t, i, e.count, this._root), n = s + S(i, e.count * this._getM(i));
+    return n = f(n, i, 1, this._root), s + (n - s) * this.get("endLocation", 1);
+  }
+  _updateDates(t, e) {
+  }
+  _handleSeriesRemoved() {
+    this.setPrivate("baseInterval", this.get("baseInterval")), this.setPrivate("min", void 0), this.setPrivate("minFinal", void 0);
+  }
+  /**
+   * Returns a duration of currently active `baseInterval` in milliseconds.
+   *
+   * @return Duration
+   */
+  baseDuration() {
+    return this._baseDuration;
+  }
+  /**
+   * Returns a duration of user-defined `baseInterval` in milliseconds.
+   *
+   * @return Duration
+   */
+  baseMainDuration() {
+    return C(this.get("baseInterval"));
+  }
+  /**
+   * @ignore
+   */
+  processSeriesDataItem(t, e) {
+    const i = this.getPrivate("baseInterval");
+    t.open || (t.open = {}), t.close || (t.close = {}), y(e, (s) => {
+      let n = t.get(s);
+      if (b(n)) {
+        let a = t.open[s], r = t.close[s];
+        if (!(n >= a && n <= r)) {
+          const o = i.timeUnit, l = i.count;
+          a = f(n, o, l, this._root), r = a + S(o, l * this._getM(o)), r = f(r, o, 1, this._root), t.open[s] = a, t.close[s] = r;
+        }
+        this._updateDates(a, t.component);
+      }
+    });
+  }
+  _handleSizeDirty() {
+  }
+  /**
+   * @ignore
+   */
+  getDataItemPositionX(t, e, i, s, n) {
+    let a, r, o;
+    return n ? o = t.get(e) : (t.open && t.close ? (a = t.open[e], r = t.close[e]) : (a = t.get(e), r = a), o = a + (r - a) * i, o = this._baseValue + (o - this._baseValue) * s), this.valueToPosition(o);
+  }
+  /**
+   * @ignore
+   */
+  getDataItemCoordinateX(t, e, i, s) {
+    return this._settings.renderer.positionToCoordinate(this.getDataItemPositionX(t, e, i, s));
+  }
+  /**
+   * @ignore
+   */
+  getDataItemPositionY(t, e, i, s, n) {
+    let a, r, o;
+    return n ? o = t.get(e) : (t.open && t.close ? (a = t.open[e], r = t.close[e]) : (a = t.get(e), r = a), o = a + (r - a) * i, o = this._baseValue + (o - this._baseValue) * s), this.valueToPosition(o);
+  }
+  /**
+   * @ignore
+   */
+  getDataItemCoordinateY(t, e, i, s) {
+    return this._settings.renderer.positionToCoordinate(this.getDataItemPositionY(t, e, i, s));
+  }
+  /**
+   * @ignore
+   */
+  roundAxisPosition(t, e) {
+    let i = this.positionToValue(t);
+    i = i - (e - 0.5) * this.baseDuration();
+    let s = this.getPrivate("baseInterval");
+    if (!dt(i)) {
+      const n = this._root.locale.firstDayOfWeek, a = s.timeUnit, r = this._root.utc, o = this._root.timezone, l = s.count;
+      i = f(i, a, l, this._root, this.getPrivate("min", 0));
+      let d = z(s, new Date(i), n, r, o);
+      return o && (i = f(i + this.baseDuration() * 0.05, a, l, this._root, this.getPrivate("min", 0)), d = z(s, new Date(i + d * e), n, r, o)), this.valueToPosition(i + d * e);
+    }
+    return NaN;
+  }
+  /**
+   * Returns text to be used in an axis tooltip for specific relative position.
+   *
+   * NOTE: Unless `adjustPosition` (2nd parameter) is set to `false`, the method
+   * will adjust position by `tooltipIntervalOffset`.
+   *
+   * @param  position        Position
+   * @param  adjustPosition  Adjust position
+   * @return                 Tooltip text
+   */
+  getTooltipText(t, e) {
+    if (this.getPrivate("min") != null) {
+      let i = this.get("tooltipDateFormats")[this.getPrivate("baseInterval").timeUnit], s = this.positionToValue(t);
+      if (b(s)) {
+        let n = new Date(s), a = this.getPrivate("baseInterval"), r = z(a, n, this._root.locale.firstDayOfWeek, this._root.utc, this._root.timezone);
+        return e !== !1 && (n = new Date(s + this.get("tooltipIntervalOffset", -this.get("tooltipLocation", 0.5)) * r)), this._root.dateFormatter.format(n, this.get("tooltipDateFormat", i));
+      }
+    }
+    return "";
+  }
+  /**
+   * Returns a data item from series that is closest to the `position`.
+   *
+   * @param   series    Series
+   * @param   position  Relative position
+   * @return            Data item
+   */
+  getSeriesItem(t, e, i, s) {
+    let n = this.getPrivate("name") + this.get("renderer").getPrivate("letter"), a = this.positionToValue(e);
+    i == null && (i = 0.5), a = a - (i - 0.5) * this.baseDuration();
+    const r = tt(t.dataItems, (o) => {
+      let l = 0;
+      return o.open && (l = o.open[n]), N(l, a);
+    });
+    if (s || t.get("snapTooltip")) {
+      let o = t.dataItems[r.index - 1], l = t.dataItems[r.index];
+      if (o && l && o.open && l.close) {
+        let d = o.open[n], u = l.close[n];
+        if (Math.abs(a - d) > Math.abs(a - u))
+          return l;
+      }
+      if (o)
+        return o;
+      if (l)
+        return l;
+    } else {
+      const o = t.dataItems[r.index - 1];
+      if (o && o.open && o.close) {
+        let l = o.open[n], d = o.close[n];
+        if (a >= l && a <= d)
+          return o;
+      }
+    }
+  }
+  /**
+   * @ignore
+   */
+  shouldGap(t, e, i, s) {
+    const n = t.get(s);
+    return e.get(s) - n > this.baseDuration() * i;
+  }
+  /**
+   * Zooms the axis to specific `start` and `end` dates.
+   *
+   * Optional `duration` specifies duration of zoom animation in milliseconds.
+   *
+   * @param  start     Start Date
+   * @param  end       End Date
+   * @param  duration  Duration in milliseconds
+   */
+  zoomToDates(t, e, i) {
+    this.zoomToValues(t.getTime(), e.getTime(), i);
+  }
+  /**
+   * Zooms the axis to specific `start` and `end` values.
+   *
+   * Optional `duration` specifies duration of zoom animation in milliseconds.
+   *
+   * @param  start     Start value
+   * @param  end       End value
+   * @param  duration  Duration in milliseconds
+   */
+  zoomToValues(t, e, i) {
+    const s = this.getPrivate("minFinal", this.getPrivate("min", 0)), n = this.getPrivate("maxFinal", this.getPrivate("max", 0));
+    if (this.getPrivate("min") != null && this.getPrivate("max") != null)
+      if (this.get("groupData")) {
+        const a = this.getGroupInterval(e - t), r = this.get("baseInterval");
+        let o = this.getIntervalMin(r), l = this.getIntervalMax(r) - 1;
+        l = f(l, a.timeUnit, a.count, this.root), l += this._getM(a.timeUnit) * C(a), l = f(l, a.timeUnit, a.count, this.root);
+        let d = f(o, a.timeUnit, a.count, this.root), u = f(l, a.timeUnit, a.count, this.root), m = (t - d) / (u - d), v = (e - d) / (u - d);
+        this.zoom(m, v, i);
+      } else
+        this.zoom((t - s) / (n - s), (e - s) / (n - s), i);
+  }
+  /**
+   * Returns a `Date` object corresponding to specific position within plot
+   * area.
+   *
+   * @param   position  Pposition
+   * @return            Date
+   */
+  positionToDate(t) {
+    return new Date(this.positionToValue(t));
+  }
+  /**
+   * Returns a relative position within plot area that corresponds to specific
+   * date.
+   *
+   * @param   date  Date
+   * @return        Position
+   */
+  dateToPosition(t) {
+    return this.valueToPosition(t.getTime());
+  }
+  /**
+   * Returns relative position between two grid lines of the axis.
+   *
+   * @since 5.2.30
+   * @return Position
+   */
+  getCellWidthPosition() {
+    let t = this.getPrivate("selectionMax", this.getPrivate("max")), e = this.getPrivate("selectionMin", this.getPrivate("min"));
+    return b(t) && b(e) ? this._intervalDuration / (t - e) : 0.05;
+  }
+  nextPosition(t) {
+    t == null && (t = 1);
+    let e = this.get("tooltipLocation", 0.5) * this.baseDuration();
+    this.get("renderer").getPrivate("letter") == "Y" && (t *= -1);
+    let i = this.positionToValue(this.getPrivate("tooltipPosition", 0));
+    const s = this.getPrivate("baseInterval");
+    let n = this._nextTime(i, t, s), a = this.getPrivate("selectionMin", 0), r = this.getPrivate("selectionMax", 0), o = f(a, s.timeUnit, s.count, this._root), l = f(r, s.timeUnit, s.count, this._root);
+    return n += e, n = ft(n, o + e, l - e), this.toGlobalPosition(this.valueToPosition(n));
+  }
+  _nextTime(t, e, i) {
+    return f(t + e * this.baseDuration(), i.timeUnit, i.count, this._root);
+  }
+}
+Object.defineProperty(B, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "DateAxis"
+});
+Object.defineProperty(B, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: at.classNames.concat([B.className])
+});
+export {
+  B as D,
+  H as X
+};