@hybridcore/ui 1.5.90 → 1.6.0

package/dist/DateAxis-YX3QNIB-.js

@@ -0,0 +1,569 @@
+import { g as U, c as X, d as Q, e as c, D as E, f as F, h as $, i as B, j as tt } from "./AnimatedTheme-jnasw6rT.js";
+import { V as H } from "./AxisRenderer-DTyLLA6c.js";
+import { m as et, f as P, e as M, h as it, j as K, l as q, n as at, o as Z } from "./ColorSet-C7vpNXhM.js";
+class W extends H {
+  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 = et(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 = U(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"), a = this.getPrivate("max");
+    if (P(t) && P(a)) {
+      this._fixZoomFactor();
+      const e = this.getPrivate("groupInterval");
+      if (e ? this._setBaseInterval(e) : this._setBaseInterval(this.get("baseInterval")), this.isDirty("groupInterval")) {
+        let i = this.get("groupInterval");
+        i && (this.setRaw("groupIntervals", [i]), this._handleRangeChange());
+      }
+      if (this.isDirty("groupData") && !this._dataGrouped) {
+        if (this.get("groupData"))
+          M(this.series, (i) => {
+            this._groupSeriesData(i);
+          }), this._handleRangeChange();
+        else {
+          let i = this.get("baseInterval"), r = i.timeUnit + i.count;
+          M(this.series, (s) => {
+            s.setDataSet(r), s.resetGrouping();
+          }), this._setBaseInterval(i), 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 a = [], e = this.baseMainDuration(), i = this.get("groupIntervals");
+      M(i, (d) => {
+        U(d) > e && a.push(d);
+      }), t._dataSets = {};
+      const r = this.getPrivate("name") + this.get("renderer").getPrivate("letter");
+      let s;
+      const o = t.get("baseAxis");
+      t.get("xAxis") === o ? s = t._valueYFields : t.get("yAxis") === o && (s = t._valueXFields);
+      let n = t._mainDataItems, l = this.get("baseInterval"), v = l.timeUnit + l.count;
+      t._dataSets[v] = n;
+      const h = t.get("groupDataCallback");
+      let p = t.get("groupDataWithOriginals", !1);
+      h && (p = !0), M(a, (d) => {
+        let T = -1 / 0, y = d.timeUnit + d.count;
+        t._dataSets[y] = [];
+        let g, w = {}, R = {}, j = {}, S = {};
+        M(s, (f) => {
+          w[f] = 0, R[f] = 0, j[f] = t.get(f + "Grouped"), S[f] = f + "Working";
+        });
+        let k = F(d.timeUnit), C = n[0], V;
+        C && (V = n[0].get(r));
+        let m;
+        M(n, (f) => {
+          let N = f.get(r), _ = c(N, d.timeUnit, d.count, this._root, V), G;
+          T < _ - k / 24 ? (G = q(f.dataContext), g = new E(t, G, t._makeDataItem(G)), g.setRaw(r, _), t._dataSets[y].push(g), M(s, (u) => {
+            let D = f.get(u);
+            P(D) ? (g.setRaw(u, D), g.setRaw(S[u], D), R[u] = 1, w[u] = D) : (w[u] = 0, R[u] = 0);
+          }), p && g.set("originals", [f]), h && m && h(m, d), m = g) : (M(s, (u) => {
+            let D = j[u], b = f.get(u);
+            if (b != null) {
+              let I = g.get(u);
+              switch (D) {
+                case "close":
+                  g.setRaw(u, b);
+                  break;
+                case "sum":
+                  g.setRaw(u, I + b);
+                  break;
+                case "open":
+                  break;
+                case "low":
+                  b < I && g.setRaw(u, b);
+                  break;
+                case "high":
+                  b > I && g.setRaw(u, b);
+                  break;
+                case "average":
+                  R[u]++, w[u] += b;
+                  let z = w[u] / R[u];
+                  g.setRaw(u, z);
+                  break;
+                case "extreme":
+                  Math.abs(b) > Math.abs(I) && g.setRaw(u, b);
+                  break;
+              }
+              g.setRaw(S[u], g.get(u));
+              let O = q(f.dataContext);
+              O[r] = _, g.dataContext = O;
+            }
+          }), p && g.get("originals").push(f)), T = _;
+        }), h && m && h(m, d);
+      }), 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 a = this.get("baseInterval"), e = X(0, t, this.get("groupCount", 1 / 0), this.get("groupIntervals"));
+    return U(e) < U(a) && (e = Object.assign({}, a)), e;
+  }
+  /**
+   * 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")), a = Math.round(this.getPrivate("selectionMax"));
+    if (P(t) && P(a)) {
+      if (this.get("endLocation") == 0 && (a += 1), this.get("groupData") && !this._groupingCalculated) {
+        this._groupingCalculated = !0;
+        let e = this.get("groupInterval"), i = this.getPrivate("groupInterval"), r = a - t + (this.get("startLocation", 0) + (1 - this.get("endLocation", 1)) * this.baseDuration());
+        if (i) {
+          let s = U(i);
+          r = Math.ceil(r / s) * s;
+        }
+        if (e || (e = this.getGroupInterval(r)), e && (!i || i.timeUnit !== e.timeUnit || i.count !== e.count || this._seriesDataGrouped)) {
+          this._seriesDataGrouped = !1, this.setPrivateRaw("groupInterval", e), this._setBaseInterval(e);
+          let s = e.timeUnit + e.count;
+          M(this.series, (o) => {
+            o.get("baseAxis") === this && o.setDataSet(s);
+          }), this.markDirtyExtremes(), this._root.events.once("frameended", () => {
+            this._root.events.once("frameended", () => {
+              const o = "groupintervalchanged";
+              this.events.isEnabled(o) && this.events.dispatch(o, { type: o, target: this });
+            });
+          });
+        }
+      }
+      M(this.series, (e) => {
+        if (e.get("baseAxis") === this) {
+          let i = this.getPrivate("name") + this.get("renderer").getPrivate("letter"), s = at(e.dataItems, (g) => Z(g.get(i), t)).index;
+          s > 0 && (s -= 1), a += this.baseDuration() * (1 - this.get("endLocation", 1));
+          let n = K(e.dataItems, (g) => Z(g.get(i), a)).index, l = n;
+          l > 1 && l--;
+          const v = e.dataItems[s], h = e.dataItems[l];
+          let p, d;
+          v && (d = v.get(i)), h && (p = h.get(i));
+          let T = !1;
+          p != null && d != null && (p < t || d > a) && (T = !0), e.setPrivate("outOfSelection", T), e.setPrivate("startIndex", s);
+          let y = e._adjustStartIndex(s);
+          e.getPrivate("adjustedStartIndex") !== y && (e.setPrivate("adjustedStartIndex", y), this.root.events.once("frameended", () => {
+            e._markDirtyPrivateKey("adjustedStartIndex");
+          })), e.setPrivate("endIndex", n);
+        }
+      });
+    }
+  }
+  _adjustMinMax(t, a, e, i) {
+    return { min: t, max: a, step: (a - t) / e };
+  }
+  /**
+   * @ignore
+   */
+  intervalDuration() {
+    return this._intervalDuration;
+  }
+  _saveMinMax(t, a) {
+    let e = this.getPrivate("groupInterval");
+    e || (e = this.get("baseInterval"));
+    let i = e.timeUnit + e.count;
+    this._intervalMin[i] = t, this._intervalMax[i] = a;
+  }
+  _getM(t) {
+    return t == "day" || t == "month" || t == "year" ? 1.05 : 1.01;
+  }
+  _getMinorInterval(t) {
+    var a;
+    let e, i = t.count, r = t.timeUnit;
+    return i > 1 && (i == 10 || i == 15 ? i = 5 : i == 12 ? i = 2 : i == 6 ? i = 1 : i == 30 ? i = 10 : i < 10 && (i = 1), e = { timeUnit: r, count: i }), r == "week" && (((a = this.getPrivate("baseInterval")) === null || a === void 0 ? void 0 : a.timeUnit) != "week" ? e = { timeUnit: "day", count: 1 } : e = { timeUnit: "week", count: 1 }), r == "year" && i == 1 && this.getPrivate("selectionMax", 0) - this.getPrivate("selectionMin", 0) < 4 * 366 * 24 * 60 * 60 * 1e3 && (e = { timeUnit: "month", count: 1 }), e;
+  }
+  _prepareAxisItems() {
+    const t = this.getPrivate("min"), a = this.getPrivate("max");
+    if (P(t) && P(a)) {
+      const e = this._root, i = Math.round(this.getPrivate("selectionMin")), r = Math.round(this.getPrivate("selectionMax")), s = this.get("renderer"), o = this.getPrivate("baseInterval");
+      let n = i, l = 0;
+      const v = this.get("gridIntervals");
+      let h = X(0, r - i, s.gridCount(), v);
+      U(h) < this.baseDuration() && (h = Object.assign({}, o));
+      const p = U(h);
+      this._intervalDuration = p;
+      const d = Q(h.timeUnit), T = e.utc, y = e.timezone;
+      n = c(i - p, h.timeUnit, h.count, e, t);
+      let g = n - p, w;
+      const R = this.get("dateFormats");
+      this.setPrivateRaw("gridInterval", h);
+      const j = s.get("minorLabelsEnabled"), S = s.get("minorGridEnabled", j);
+      let k, C = 0;
+      S && (k = this._getMinorInterval(h), C = U(k));
+      let V = 0;
+      for (; n < r + p; ) {
+        let m;
+        this.dataItems.length < l + 1 ? (m = new E(this, void 0, {}), this._dataItems.push(m), this.processDataItem(m)) : m = this.dataItems[l], this._createAssets(m, []), this._toggleDataItem(m, !0), m.setRaw("value", n), m.setRaw("labelEndValue", void 0);
+        let f = n + F(h.timeUnit, h.count * this._getM(h.timeUnit));
+        f = c(f, h.timeUnit, 1, e), m.setRaw("endValue", f);
+        let N = new Date(n);
+        w = R[h.timeUnit], d && this.get("markUnitChange") && P(g) && h.timeUnit != "year" && $(n, g, d, T, y) && (w = this.get("periodChangeDateFormats")[h.timeUnit]);
+        const _ = m.get("label");
+        _ && _.set("text", e.dateFormatter.format(N, w));
+        let G = h.count;
+        if (h.timeUnit == "week" ? _ == null || _.set("location", this.get("weekLabelLocation", 0)) : _ == null || _.set("location", s.labels.template.get("location")), S) {
+          G = 1;
+          let u = h.timeUnit;
+          u == "week" && this.get("skipFirstMinor") && (u = "day");
+          let D = n + F(u, this._getM(u));
+          D = c(D, u, 1, e), m.setRaw("labelEndValue", D);
+        }
+        if (this._prepareDataItem(m, G), g = n, n = f, k) {
+          const u = k.timeUnit, D = k.count, b = this._getM(u);
+          this.get("skipFirstMinor") || (g -= C * b);
+          let I = c(g + C * b, u, D, e, g), O, z = this.get("minorDateFormats", this.get("dateFormats"));
+          for (; I < n - 0.01 * C; ) {
+            let x;
+            this.minorDataItems.length < V + 1 ? (x = new E(this, void 0, {}), this.minorDataItems.push(x), this.processDataItem(x)) : x = this.minorDataItems[V], this._createAssets(x, ["minor"], !0), this._toggleDataItem(x, !0), x.setRaw("value", I);
+            let A = I + F(u, D * b);
+            A = c(A, u, 1, e), x.setRaw("endValue", A);
+            let J = new Date(I);
+            w = z[u];
+            const L = x.get("label");
+            if (L && (j ? L.set("text", e.dateFormatter.format(J, w)) : L.setPrivate("visible", !1)), this._prepareDataItem(x, 1), I == O)
+              break;
+            if (!x.get("isRange")) {
+              const Y = this.get("fillRule");
+              Y && Y(x);
+            }
+            O = I, I = A, V++;
+          }
+        }
+        if (n == g)
+          break;
+        l++;
+      }
+      for (let m = l; m < this.dataItems.length; m++)
+        this._toggleDataItem(this.dataItems[m], !1);
+      for (let m = V; m < this.minorDataItems.length; m++)
+        this._toggleDataItem(this.minorDataItems[m], !1);
+      M(this.series, (m) => {
+        m.inited && m._markDirtyAxes();
+      });
+    }
+    this._updateGhost();
+  }
+  _updateFinals(t, a) {
+    this.setPrivateRaw("selectionMinFinal", this.positionToValue(t)), this.setPrivateRaw("selectionMaxFinal", this.positionToValue(a));
+  }
+  _getDelta() {
+    this._deltaMinMax = this.baseDuration() / 2;
+  }
+  _fixMin(t) {
+    const a = this.getPrivate("baseInterval"), e = a.timeUnit;
+    let i = c(t, e, a.count, this._root), r = i + F(e, a.count * this._getM(e));
+    return r = c(r, e, 1, this._root), i + (r - i) * this.get("startLocation", 0);
+  }
+  _fixMax(t) {
+    const a = this.getPrivate("baseInterval"), e = a.timeUnit;
+    let i = c(t, e, a.count, this._root), r = i + F(e, a.count * this._getM(e));
+    return r = c(r, e, 1, this._root), i + (r - i) * this.get("endLocation", 1);
+  }
+  _updateDates(t, a) {
+  }
+  _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 U(this.get("baseInterval"));
+  }
+  /**
+   * @ignore
+   */
+  processSeriesDataItem(t, a) {
+    const e = this.getPrivate("baseInterval");
+    t.open || (t.open = {}), t.close || (t.close = {}), M(a, (i) => {
+      let r = t.get(i);
+      if (P(r)) {
+        let s = t.open[i], o = t.close[i];
+        if (!(r >= s && r <= o)) {
+          const n = e.timeUnit, l = e.count;
+          s = c(r, n, l, this._root), o = s + F(n, l * this._getM(n)), o = c(o, n, 1, this._root), t.open[i] = s, t.close[i] = o;
+        }
+        this._updateDates(s, t.component);
+      }
+    });
+  }
+  _handleSizeDirty() {
+  }
+  /**
+   * @ignore
+   */
+  getDataItemPositionX(t, a, e, i, r) {
+    let s, o, n;
+    return r ? n = t.get(a) : (t.open && t.close ? (s = t.open[a], o = t.close[a]) : (s = t.get(a), o = s), n = s + (o - s) * e, n = this._baseValue + (n - this._baseValue) * i), this.valueToPosition(n);
+  }
+  /**
+   * @ignore
+   */
+  getDataItemCoordinateX(t, a, e, i) {
+    return this._settings.renderer.positionToCoordinate(this.getDataItemPositionX(t, a, e, i));
+  }
+  /**
+   * @ignore
+   */
+  getDataItemPositionY(t, a, e, i, r) {
+    let s, o, n;
+    return r ? n = t.get(a) : (t.open && t.close ? (s = t.open[a], o = t.close[a]) : (s = t.get(a), o = s), n = s + (o - s) * e, n = this._baseValue + (n - this._baseValue) * i), this.valueToPosition(n);
+  }
+  /**
+   * @ignore
+   */
+  getDataItemCoordinateY(t, a, e, i) {
+    return this._settings.renderer.positionToCoordinate(this.getDataItemPositionY(t, a, e, i));
+  }
+  /**
+   * @ignore
+   */
+  roundAxisPosition(t, a) {
+    let e = this.positionToValue(t);
+    e = e - (a - 0.5) * this.baseDuration();
+    let i = this.getPrivate("baseInterval");
+    if (!it(e)) {
+      const r = this._root.locale.firstDayOfWeek, s = i.timeUnit, o = this._root.utc, n = this._root.timezone, l = i.count;
+      e = c(e, s, l, this._root, this.getPrivate("min", 0));
+      let v = B(i, new Date(e), r, o, n);
+      return n && (e = c(e + this.baseDuration() * 0.05, s, l, this._root, this.getPrivate("min", 0)), v = B(i, new Date(e + v * a), r, o, n)), this.valueToPosition(e + v * a);
+    }
+    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, a) {
+    if (this.getPrivate("min") != null) {
+      let e = this.get("tooltipDateFormats")[this.getPrivate("baseInterval").timeUnit], i = this.positionToValue(t);
+      if (P(i)) {
+        let r = new Date(i), s = this.getPrivate("baseInterval"), o = B(s, r, this._root.locale.firstDayOfWeek, this._root.utc, this._root.timezone);
+        return a !== !1 && (r = new Date(i + this.get("tooltipIntervalOffset", -this.get("tooltipLocation", 0.5)) * o)), this._root.dateFormatter.format(r, this.get("tooltipDateFormat", e));
+      }
+    }
+    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, a, e, i) {
+    let r = this.getPrivate("name") + this.get("renderer").getPrivate("letter"), s = this.positionToValue(a);
+    e == null && (e = 0.5), s = s - (e - 0.5) * this.baseDuration();
+    const o = K(t.dataItems, (n) => {
+      let l = 0;
+      return n.open && (l = n.open[r]), Z(l, s);
+    });
+    if (i || t.get("snapTooltip")) {
+      let n = t.dataItems[o.index - 1], l = t.dataItems[o.index];
+      if (n && l && n.open && l.close) {
+        let v = n.open[r], h = l.close[r];
+        if (Math.abs(s - v) > Math.abs(s - h))
+          return l;
+      }
+      if (n)
+        return n;
+      if (l)
+        return l;
+    } else {
+      const n = t.dataItems[o.index - 1];
+      if (n && n.open && n.close) {
+        let l = n.open[r], v = n.close[r];
+        if (s >= l && s <= v)
+          return n;
+      }
+    }
+  }
+  /**
+   * @ignore
+   */
+  shouldGap(t, a, e, i) {
+    const r = t.get(i);
+    return a.get(i) - r > this.baseDuration() * e;
+  }
+  /**
+   * 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, a, e) {
+    this.zoomToValues(t.getTime(), a.getTime(), e);
+  }
+  /**
+   * 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, a, e) {
+    const i = this.getPrivate("minFinal", this.getPrivate("min", 0)), r = this.getPrivate("maxFinal", this.getPrivate("max", 0));
+    if (this.getPrivate("min") != null && this.getPrivate("max") != null)
+      if (this.get("groupData")) {
+        const s = this.getGroupInterval(a - t), o = this.get("baseInterval");
+        let n = this.getIntervalMin(o), l = this.getIntervalMax(o) - 1;
+        l = c(l, s.timeUnit, s.count, this.root), l += this._getM(s.timeUnit) * U(s), l = c(l, s.timeUnit, s.count, this.root);
+        let v = c(n, s.timeUnit, s.count, this.root), h = c(l, s.timeUnit, s.count, this.root), p = (t - v) / (h - v), d = (a - v) / (h - v);
+        this.zoom(p, d, e);
+      } else
+        this.zoom((t - i) / (r - i), (a - i) / (r - i), e);
+  }
+  /**
+   * 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")), a = this.getPrivate("selectionMin", this.getPrivate("min"));
+    return P(t) && P(a) ? this._intervalDuration / (t - a) : 0.05;
+  }
+  nextPosition(t) {
+    t == null && (t = 1);
+    let a = this.get("tooltipLocation", 0.5) * this.baseDuration();
+    this.get("renderer").getPrivate("letter") == "Y" && (t *= -1);
+    let e = this.positionToValue(this.getPrivate("tooltipPosition", 0));
+    const i = this.getPrivate("baseInterval");
+    let r = this._nextTime(e, t, i), s = this.getPrivate("selectionMin", 0), o = this.getPrivate("selectionMax", 0), n = c(s, i.timeUnit, i.count, this._root), l = c(o, i.timeUnit, i.count, this._root);
+    return r += a, r = tt(r, n + a, l - a), this.toGlobalPosition(this.valueToPosition(r));
+  }
+  _nextTime(t, a, e) {
+    return c(t + a * this.baseDuration(), e.timeUnit, e.count, this._root);
+  }
+}
+Object.defineProperty(W, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "DateAxis"
+});
+Object.defineProperty(W, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: H.classNames.concat([W.className])
+});
+export {
+  W as D
+};

package/dist/{Delete-86TO0fMo.js → Delete-CW0UZv1m.js}

@@ -1,4 +1,4 @@
-import { r as t, i as a } from "./createSvgIcon-DLPYMuH1.js";
+import { r as t, i as a } from "./createSvgIcon-BjpIhJ30.js";
 import u from "react/jsx-runtime";
 var e = {}, l = a;
 Object.defineProperty(e, "__esModule", {

package/dist/{DialogContent-CqTojymQ.js → DialogContent-B3nbEbuv.js}

@@ -1,15 +1,14 @@
 import { a as i, _ as T } from "./objectWithoutPropertiesLoose-DJteAcBH.js";
 import * as d from "react";
-import { P as o } from "./index-DMSHuq6l.js";
-import { g as h, u as S, c as b, a as P } from "./useThemeProps-DRP1dikX.js";
-import { s as m } from "./styled-B8ugzvji.js";
-import { g as y } from "./createTheme-CNnKNxwL.js";
-import { u as q } from "./useTheme-D-uii9iX.js";
+import { P as o } from "./index-C__OZmYy.js";
+import { g as h, u as S, c as b, a as P } from "./useThemeProps-BzzHcQyd.js";
+import { s as m } from "./styled-eZwjUruw.js";
+import { g as y } from "./createTheme-DYxDnE9u.js";
+import { P as O, u as q } from "./Paper-2B03OBmZ.js";
 import { jsx as p } from "react/jsx-runtime";
-import { B as G, M as J, F as Q } from "./Modal-CkcFEpHa.js";
-import { c as u } from "./createTheme-CyC5HawC.js";
-import { P as O } from "./Paper-CjqLScHA.js";
-import { u as Z } from "./useId-BHG98T5I.js";
+import { B as G, M as J, F as Q } from "./Modal-DhPpOoGB.js";
+import { c as u } from "./capitalize-ciszXJ7R.js";
+import { u as Z } from "./useId-B4-oF9Mq.js";
 function oo(e) {
   return y("MuiDialog", e);
 }
@@ -431,7 +430,7 @@ function fo(e) {
   return y("MuiDialogContent", e);
 }
 h("MuiDialogContent", ["root", "dividers"]);
-function Bo(e) {
+function wo(e) {
   return y("MuiDialogTitle", e);
 }
 const go = h("MuiDialogTitle", ["root"]), bo = ["className", "dividers"], xo = (e) => {
@@ -517,5 +516,5 @@ export {
   mo as b,
   R as c,
   W as d,
-  Bo as g
+  wo as g
 };