@hybridcore/ui 1.5.89 → 1.6.0

package/dist/components/charts/stacked-area-radar/logic.js

@@ -0,0 +1,868 @@
+import { k as W, l as $, x as c, m as h, s as g, a as me, n as ae, C as Ae, G as J, o as re, q as pe, t as L, y as C, j as ne, z as le, R as xe, A as ve, T as H } from "../../../AnimatedTheme-jnasw6rT.js";
+import { useThemeProps as ye, useTheme as be } from "@mui/material";
+import Pe from "dayjs";
+import U from "lodash";
+import { useId as Re, useRef as _e, useEffect as we } from "react";
+import { colorSetFromPalette as Te } from "../_common/utils.js";
+import { m as M, x as R, b as K, f as m, p as w, a as N, P as Ce, c as Y } from "../../../ColorSet-C7vpNXhM.js";
+import { a as E, X as ue, V as Le } from "../../../AxisRenderer-DTyLLA6c.js";
+import { R as de, S as Me, a as I } from "../../../Slice-B19rbYDZ.js";
+import { X as he } from "../../../XYCursor-C8WktvKM.js";
+import { C as oe } from "../../../CategoryAxis-CwnfaGc8.js";
+import { L as ge } from "../../../LineSeries-Uiv5o56b.js";
+import { L as De } from "../../../Legend-Dp_MKfS4.js";
+class O extends de {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_tickPoints", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: []
+    });
+  }
+}
+Object.defineProperty(O, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "AxisLabelRadial"
+});
+Object.defineProperty(O, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: de.classNames.concat([O.className])
+});
+class j extends E {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "labels", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.addDisposer(new W($.new({}), () => O._new(this._root, {
+        themeTags: M(this.labels.template.get("themeTags", []), this.get("themeTags", []))
+      }, [this.labels.template])))
+    }), Object.defineProperty(this, "axisFills", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.addDisposer(new W($.new({}), () => Me._new(this._root, {
+        themeTags: M(this.axisFills.template.get("themeTags", ["fill"]), this.get("themeTags", []))
+      }, [this.axisFills.template])))
+    }), Object.defineProperty(this, "_fillGenerator", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: I()
+    });
+  }
+  _afterNew() {
+    this._settings.themeTags = M(this._settings.themeTags, ["renderer", "circular"]), super._afterNew(), this.setPrivateRaw("letter", "X"), this.setRaw("position", "absolute");
+  }
+  _changed() {
+    super._changed(), (this.isDirty("radius") || this.isDirty("innerRadius") || this.isDirty("startAngle") || this.isDirty("endAngle")) && this.updateLayout();
+  }
+  /**
+   * @ignore
+   */
+  processAxis() {
+    super.processAxis(), this.axis.labelsContainer.set("isMeasured", !1);
+  }
+  /**
+   * @ignore
+   */
+  updateLayout() {
+    const e = this.chart;
+    if (e) {
+      const t = e.getPrivate("radius", 0);
+      let s = R(this.get("radius", K), t);
+      s < 0 && (s = t + s), this.setPrivate("radius", s);
+      let i = R(this.get("innerRadius", e.getPrivate("innerRadius", 0)), t) * e.getPrivate("irModifyer", 1);
+      i < 0 && (i = s + i), this.setPrivate("innerRadius", i);
+      let a = this.get("startAngle", e.get("startAngle", -90)), r = this.get("endAngle", e.get("endAngle", 270));
+      this.setPrivate("startAngle", a), this.setPrivate("endAngle", r), this.set("draw", (n) => {
+        const l = this.positionToPoint(0);
+        n.moveTo(l.x, l.y), a > r && ([a, r] = [r, a]), n.arc(0, 0, s, a * c, r * c);
+      }), this.axis.markDirtySize();
+    }
+  }
+  /**
+   * @ignore
+   */
+  updateGrid(e, t, s) {
+    if (e) {
+      t == null && (t = 0);
+      let i = e.get("location", 0.5);
+      s != null && s != t && (t = t + (s - t) * i);
+      let a = this.getPrivate("radius", 0), r = this.getPrivate("innerRadius", 0), n = this.positionToAngle(t);
+      this.toggleVisibility(e, t, 0, 1), a != null && e.set("draw", (l) => {
+        l.moveTo(r * h(n), r * g(n)), l.lineTo(a * h(n), a * g(n));
+      });
+    }
+  }
+  /**
+   * Converts relative position to angle.
+   *
+   * @param   position  Position
+   * @return            Angle
+   */
+  positionToAngle(e) {
+    const t = this.axis, s = this.getPrivate("startAngle", 0), i = this.getPrivate("endAngle", 360), a = t.get("start", 0), r = t.get("end", 1);
+    let n = (i - s) / (r - a), l;
+    return this.get("inversed") ? l = s + (r - e) * n : l = s + (e - a) * n, l;
+  }
+  // do not delete
+  _handleOpposite() {
+  }
+  /**
+   * Converts relative position to an X/Y coordinate.
+   *
+   * @param   position  Position
+   * @return            Point
+   */
+  positionToPoint(e) {
+    const t = this.getPrivate("radius", 0), s = this.positionToAngle(e);
+    return { x: t * h(s), y: t * g(s) };
+  }
+  /**
+   * @ignore
+   */
+  updateLabel(e, t, s, i) {
+    if (e) {
+      t == null && (t = 0);
+      let a = 0.5;
+      i != null && i > 1 ? a = e.get("multiLocation", a) : a = e.get("location", a), s != null && s != t && (t = t + (s - t) * a);
+      const r = this.getPrivate("radius", 0), n = this.getPrivate("innerRadius", 0), l = this.positionToAngle(t);
+      e.setPrivate("radius", r), e.setPrivate("innerRadius", n), e.set("labelAngle", l), this.toggleVisibility(e, t, e.get("minPosition", 0), e.get("maxPosition", 1));
+    }
+  }
+  /**
+   * @ignore
+   */
+  fillDrawMethod(e, t, s) {
+    e.set("draw", (i) => {
+      t == null && (t = this.getPrivate("startAngle", 0)), s == null && (s = this.getPrivate("endAngle", 0));
+      const a = this.getPrivate("innerRadius", 0), r = this.getPrivate("radius", 0);
+      this._fillGenerator.context(i), this._fillGenerator({ innerRadius: a, outerRadius: r, startAngle: (t + 90) * c, endAngle: (s + 90) * c });
+    });
+  }
+  /**
+   * @ignore
+   */
+  updateTick(e, t, s, i) {
+    if (e) {
+      t == null && (t = 0);
+      let a = 0.5;
+      i != null && i > 1 ? a = e.get("multiLocation", a) : a = e.get("location", a), s != null && s != t && (t = t + (s - t) * a);
+      let r = e.get("length", 0);
+      e.get("inside") && (r *= -1);
+      let l = this.getPrivate("radius", 0), u = this.positionToAngle(t);
+      this.toggleVisibility(e, t, e.get("minPosition", 0), e.get("maxPosition", 1)), l != null && e.set("draw", (o) => {
+        o.moveTo(l * h(u), l * g(u)), l += r, o.lineTo(l * h(u), l * g(u));
+      });
+    }
+  }
+  /**
+   * @ignore
+   */
+  updateBullet(e, t, s) {
+    if (e) {
+      const i = e.get("sprite");
+      if (i) {
+        t == null && (t = 0);
+        let a = e.get("location", 0.5);
+        s != null && s != t && (t = t + (s - t) * a);
+        let r = this.getPrivate("radius", 0), n = this.positionToAngle(t);
+        this.toggleVisibility(i, t, 0, 1), i.setAll({ rotation: n, x: r * h(n), y: r * g(n) });
+      }
+    }
+  }
+  /**
+   * @ignore
+   */
+  updateFill(e, t, s) {
+    if (e) {
+      t == null && (t = 0), s == null && (s = 1);
+      let i = this.fitAngle(this.positionToAngle(t)), a = this.fitAngle(this.positionToAngle(s));
+      e.setAll({ startAngle: i, arc: a - i }), e._setSoft("innerRadius", this.getPrivate("innerRadius")), e._setSoft("radius", this.getPrivate("radius"));
+    }
+  }
+  /**
+   * @ignore
+   */
+  fitAngle(e) {
+    const t = this.getPrivate("startAngle", 0), s = this.getPrivate("endAngle", 0), i = Math.min(t, s), a = Math.max(t, s);
+    return e < i && (e = i), e > a && (e = a), e;
+  }
+  /**
+   * Returns axis length in pixels.
+   *
+   * @return Length
+   */
+  axisLength() {
+    return Math.abs(this.getPrivate("radius", 0) * Math.PI * 2 * (this.getPrivate("endAngle", 360) - this.getPrivate("startAngle", 0)) / 360);
+  }
+  /**
+   * @ignore
+   */
+  positionTooltip(e, t) {
+    let s = this.getPrivate("radius", 0);
+    const i = this.positionToAngle(t);
+    this._positionTooltip(e, { x: s * h(i), y: s * g(i) });
+  }
+  /**
+   * @ignore
+   */
+  updateTooltipBounds(e) {
+  }
+}
+Object.defineProperty(j, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "AxisRendererCircular"
+});
+Object.defineProperty(j, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: E.classNames.concat([j.className])
+});
+class G extends E {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_fillGenerator", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: I()
+    }), Object.defineProperty(this, "labels", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.addDisposer(new W($.new({}), () => O._new(this._root, {
+        themeTags: M(this.labels.template.get("themeTags", []), this.get("themeTags", []))
+      }, [this.labels.template])))
+    });
+  }
+  _afterNew() {
+    this._settings.themeTags = M(this._settings.themeTags, ["renderer", "radial"]), super._afterNew(), this.setPrivate("letter", "Y"), this.setRaw("position", "absolute");
+  }
+  _changed() {
+    super._changed(), (this.isDirty("radius") || this.isDirty("innerRadius") || this.isDirty("startAngle") || this.isDirty("endAngle")) && this.updateLayout();
+  }
+  /**
+   * @ignore
+   */
+  processAxis() {
+    super.processAxis();
+  }
+  /**
+   * @ignore
+   */
+  updateLayout() {
+    const e = this.chart;
+    if (e) {
+      const t = e.getPrivate("radius", 0);
+      let s = R(this.get("radius", K), t), i = R(this.get("innerRadius", e.getPrivate("innerRadius", 0)), t) * e.getPrivate("irModifyer", 1);
+      i < 0 && (i = s + i), this.setPrivate("radius", s), this.setPrivate("innerRadius", i);
+      let a = this.get("startAngle", e.get("startAngle", -90)), r = this.get("endAngle", e.get("endAngle", 270));
+      this.setPrivate("startAngle", a), this.setPrivate("endAngle", r);
+      const n = this.get("axisAngle", 0);
+      this.set("draw", (l) => {
+        l.moveTo(i * h(n), i * g(n)), l.lineTo(s * h(n), s * g(n));
+      }), this.axis.markDirtySize();
+    }
+  }
+  /**
+   * @ignore
+   */
+  updateGrid(e, t, s) {
+    if (e) {
+      m(t) || (t = 0);
+      let i = e.get("location", 0.5);
+      m(s) && s != t && (t = t + (s - t) * i);
+      let a = this.positionToCoordinate(t) + this.getPrivate("innerRadius", 0);
+      this.toggleVisibility(e, t, 0, 1), m(a) && e.set("draw", (r) => {
+        let n = this.getPrivate("startAngle", 0) * c, l = this.getPrivate("endAngle", 0) * c;
+        r.arc(0, 0, Math.max(0, a), Math.min(n, l), Math.max(n, l));
+      });
+    }
+  }
+  // do not delete
+  _handleOpposite() {
+  }
+  /**
+   * Converts relative position to X/Y point.
+   *
+   * @param   position  Position
+   * @return            Point
+   */
+  positionToPoint(e) {
+    const t = this.getPrivate("innerRadius", 0), s = this.positionToCoordinate(e) + t, i = this.get("axisAngle", 0);
+    return { x: s * h(i), y: s * g(i) };
+  }
+  /**
+   * @ignore
+   */
+  updateLabel(e, t, s, i) {
+    if (e) {
+      m(t) || (t = 0);
+      let a = 0.5;
+      m(i) && i > 1 ? a = e.get("multiLocation", a) : a = e.get("location", a), m(s) && s != t && (t = t + (s - t) * a);
+      const r = this.positionToPoint(t);
+      let n = Math.hypot(r.x, r.y);
+      e.setPrivate("radius", n), e.setPrivate("innerRadius", n), e.set("labelAngle", this.get("axisAngle")), this.toggleVisibility(e, t, e.get("minPosition", 0), e.get("maxPosition", 1));
+    }
+  }
+  fillDrawMethod(e, t, s) {
+    e.set("draw", (i) => {
+      t = Math.max(0, t), s = Math.max(0, s), this._fillGenerator.context(i);
+      let a = (this.getPrivate("startAngle", 0) + 90) * c, r = (this.getPrivate("endAngle", 0) + 90) * c;
+      r < a && ([a, r] = [r, a]), this._fillGenerator({ innerRadius: t, outerRadius: s, startAngle: a, endAngle: r });
+    });
+  }
+  /**
+   * @ignore
+   */
+  updateTick(e, t, s, i) {
+    if (e) {
+      m(t) || (t = 0);
+      let a = 0.5;
+      m(i) && i > 1 ? a = e.get("multiLocation", a) : a = e.get("location", a), m(s) && s != t && (t = t + (s - t) * a);
+      const r = this.positionToPoint(t);
+      e.set("x", r.x), e.set("y", r.y);
+      let n = e.get("length", 0);
+      e.get("inside") && (n *= -1);
+      const u = this.get("axisAngle", 0) + 90;
+      e.set("draw", (o) => {
+        o.moveTo(0, 0), o.lineTo(n * h(u), n * g(u));
+      }), this.toggleVisibility(e, t, e.get("minPosition", 0), e.get("maxPosition", 1));
+    }
+  }
+  /**
+   * @ignore
+   */
+  updateBullet(e, t, s) {
+    if (e) {
+      const i = e.get("sprite");
+      if (i) {
+        m(t) || (t = 0);
+        let a = e.get("location", 0.5);
+        m(s) && s != t && (t = t + (s - t) * a);
+        const r = this.positionToPoint(t);
+        i.setAll({ x: r.x, y: r.y }), this.toggleVisibility(i, t, 0, 1);
+      }
+    }
+  }
+  /**
+   * @ignore
+   */
+  updateFill(e, t, s) {
+    if (e) {
+      m(t) || (t = 0), m(s) || (s = 1);
+      const i = this.getPrivate("innerRadius", 0);
+      let a = this.positionToCoordinate(t) + i, r = this.positionToCoordinate(s) + i;
+      this.fillDrawMethod(e, a, r);
+    }
+  }
+  /**
+   * Returns axis length in pixels.
+   *
+   * @return Length
+   */
+  axisLength() {
+    return this.getPrivate("radius", 0) - this.getPrivate("innerRadius", 0);
+  }
+  /**
+   * @ignore
+   */
+  updateTooltipBounds(e) {
+  }
+  /**
+   * Converts relative position to pixels.
+   *
+   * @param   position  Position
+   * @return            Pixels
+   */
+  positionToCoordinate(e) {
+    return this._inversed ? (e = Math.min(this._end, e), (this._end - e) * this._axisLength) : (e = Math.max(this._start, e), (e - this._start) * this._axisLength);
+  }
+  /**
+   * @ignore
+   */
+  positionTooltip(e, t) {
+    let s = this.getPrivate("innerRadius", 0) + this.positionToCoordinate(t);
+    const i = this.get("axisAngle", 0);
+    this._positionTooltip(e, { x: s * h(i), y: s * g(i) });
+  }
+}
+Object.defineProperty(G, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "AxisRendererRadial"
+});
+Object.defineProperty(G, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: E.classNames.concat([G.className])
+});
+class Ye extends me {
+  setupDefaultRules() {
+    super.setupDefaultRules();
+    const e = this.rule.bind(this), t = this._root.interfaceColors;
+    e("RadarChart").setAll({
+      radius: w(80),
+      innerRadius: 0,
+      startAngle: -90,
+      endAngle: 270
+    }), e("RadarColumnSeries").setAll({
+      clustered: !0
+    }), e("Slice", ["radar", "column", "series"]).setAll({
+      width: w(80),
+      height: w(80)
+    }), e("RadarLineSeries").setAll({
+      connectEnds: !0
+    }), e("SmoothedRadarLineSeries").setAll({
+      tension: 0.5
+    }), e("AxisRendererRadial").setAll({
+      minGridDistance: 40,
+      axisAngle: -90,
+      inversed: !1,
+      cellStartLocation: 0,
+      cellEndLocation: 1
+    }), e("AxisRendererCircular").setAll({
+      minGridDistance: 100,
+      inversed: !1,
+      cellStartLocation: 0,
+      cellEndLocation: 1
+    }), e("RadialLabel", ["circular"]).setAll({
+      textType: "circular",
+      paddingTop: 1,
+      paddingRight: 0,
+      paddingBottom: 1,
+      paddingLeft: 0,
+      centerX: 0,
+      centerY: 0,
+      radius: 8
+    }), e("AxisLabelRadial", ["category"]).setAll({
+      text: "{category}",
+      populateText: !0
+    }), e("RadialLabel", ["radial"]).setAll({
+      textType: "regular",
+      centerX: 0,
+      textAlign: "right"
+    }), e("RadarChart", ["gauge"]).setAll({
+      startAngle: 180,
+      endAngle: 360,
+      innerRadius: w(90)
+    }), e("ClockHand").setAll({
+      topWidth: 1,
+      bottomWidth: 10,
+      radius: w(90),
+      pinRadius: 10
+    });
+    {
+      const s = e("Graphics", ["clock", "hand"]);
+      s.setAll({
+        fillOpacity: 1
+      }), ae(s, "fill", t, "alternativeBackground");
+    }
+    {
+      const s = e("Graphics", ["clock", "pin"]);
+      s.setAll({
+        fillOpacity: 1
+      }), ae(s, "fill", t, "alternativeBackground");
+    }
+  }
+}
+class k extends ue {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "radarContainer", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: this.plotContainer.children.push(Ae.new(this._root, { x: N, y: N }))
+    }), Object.defineProperty(this, "_arcGenerator", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: I()
+    }), Object.defineProperty(this, "_maxRadius", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: 1
+    });
+  }
+  _afterNew() {
+    this._defaultThemes.push(Ye.new(this._root)), super._afterNew();
+    const e = this.radarContainer, t = this.gridContainer, s = this.topGridContainer, i = this.seriesContainer, a = this.bulletsContainer;
+    e.children.pushAll([t, i, s, a]), i.set("mask", J.new(this._root, {})), t.set("mask", J.new(this._root, {})), this._disposers.push(this.plotContainer.events.on("boundschanged", () => {
+      this._updateRadius();
+    }));
+  }
+  _maskGrid() {
+  }
+  _prepareChildren() {
+    if (super._prepareChildren(), this._sizeDirty || this.isDirty("radius") || this.isDirty("innerRadius") || this.isDirty("startAngle") || this.isDirty("endAngle")) {
+      const e = this.chartContainer, t = e.innerWidth(), s = e.innerHeight(), i = this.get("startAngle", 0), a = this.get("endAngle", 0), r = this.get("innerRadius");
+      let n = re(0, 0, i, a, 1);
+      const l = t / (n.right - n.left), u = s / (n.bottom - n.top);
+      let o = { left: 0, right: 0, top: 0, bottom: 0 };
+      if (r instanceof Ce) {
+        let f = r.value, T = Math.min(l, u);
+        f = Math.max(T * f, T - Math.min(s, t)) / T, o = re(0, 0, i, a, f), this.setPrivateRaw("irModifyer", f / r.value);
+      }
+      n = pe([n, o]), this._maxRadius = Math.max(0, Math.min(l, u));
+      const y = R(this.get("radius", 0), this._maxRadius);
+      this.radarContainer.setAll({
+        dy: -y * (n.bottom + n.top) / 2,
+        dx: -y * (n.right + n.left) / 2
+      }), this._updateRadius();
+    }
+  }
+  _addCursor(e) {
+    this.radarContainer.children.push(e);
+  }
+  // do not delete
+  _updateRadius() {
+    const e = R(this.get("radius", w(80)), this._maxRadius);
+    this.setPrivateRaw("radius", e);
+    let t = R(this.get("innerRadius", 0), e);
+    t < 0 && (t = e + t), this.setPrivateRaw("innerRadius", t), this.xAxes.each((i) => {
+      i.get("renderer").updateLayout();
+    }), this.yAxes.each((i) => {
+      i.get("renderer").updateLayout();
+    }), this._updateMask(this.seriesContainer, t, e), this._updateMask(this.gridContainer, t, e), this.series.each((i) => {
+      i.get("maskBullets") ? this._updateMask(i.bulletsContainer, t, e) : i.bulletsContainer.remove("mask");
+    });
+    const s = this.get("cursor");
+    s && s.updateLayout();
+  }
+  /**
+   * @ignore
+   */
+  _updateMask(e, t, s) {
+    const i = e.get("mask");
+    i && i.set("draw", (a) => {
+      this._arcGenerator.context(a), this._arcGenerator({ innerRadius: t, outerRadius: s + 0.5, startAngle: (this.get("startAngle", 0) + 90) * c, endAngle: (this.get("endAngle", 0) + 90) * c });
+    });
+  }
+  /**
+   * @ignore
+   */
+  processAxis(e) {
+    this.radarContainer.children.push(e);
+  }
+  _processSeries(e) {
+    super._processSeries(e), this._updateRadius();
+  }
+  /**
+   * @ignore
+   */
+  inPlot(e, t, s) {
+    const i = Math.hypot(e.x, e.y), a = L(Math.atan2(e.y, e.x) * C);
+    let r = L(this.get("startAngle", 0)), n = L(this.get("endAngle", 0)), l = !1;
+    return r < n && r < a && a < n && (l = !0), r > n && (a > r && (l = !0), a < n && (l = !0)), r == n && (l = !0), l ? (t == null && (t = this.getPrivate("radius", 0)), s == null && (s = this.getPrivate("innerRadius", 0)), s > t && ([s, t] = [t, s]), i <= t + 0.5 && i >= s - 0.5) : !1;
+  }
+  _tooltipToLocal(e) {
+    return this.radarContainer._display.toLocal(e);
+  }
+  _handlePinch() {
+  }
+}
+Object.defineProperty(k, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "RadarChart"
+});
+Object.defineProperty(k, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: ue.classNames.concat([k.className])
+});
+class B extends he {
+  constructor() {
+    super(...arguments), Object.defineProperty(this, "_fillGenerator", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: I()
+    });
+  }
+  _afterNew() {
+    this._settings.themeTags = M(this._settings.themeTags, ["radar", "cursor"]), super._afterNew();
+  }
+  _handleXLine() {
+  }
+  _handleYLine() {
+  }
+  _getPosition(e) {
+    const t = Math.hypot(e.x, e.y);
+    let s = L(Math.atan2(e.y, e.x) * C);
+    const i = this.getPrivate("innerRadius");
+    let a = L(this.getPrivate("startAngle")), r = L(this.getPrivate("endAngle"));
+    (r < a || r == a) && (s < a && (s += 360), r = r + 360);
+    let n = (s - a) / (r - a);
+    return n < 0 && (n = 1 + n), n < 3e-3 && (n = 0), n > 0.997 && (n = 1), { x: n, y: (t - i) / (this.getPrivate("radius") - i) };
+  }
+  _getPoint(e, t) {
+    const s = this.getPrivate("innerRadius"), i = this.getPrivate("startAngle"), a = this.getPrivate("endAngle"), r = this.getPrivate("radius"), n = i + e * (a - i), l = s + (r - s) * t;
+    return { x: l * h(n), y: l * g(n) };
+  }
+  /**
+   * @ignore
+   */
+  updateLayout() {
+    const e = this.chart;
+    if (e) {
+      const t = e.getPrivate("radius", 0);
+      this.setPrivate("radius", R(this.get("radius", K), t));
+      let s = R(this.get("innerRadius", e.getPrivate("innerRadius", 0)), t);
+      s < 0 && (s = t + s), this.setPrivate("innerRadius", s);
+      let i = this.get("startAngle", e.get("startAngle", -90)), a = this.get("endAngle", e.get("endAngle", 270));
+      this.setPrivate("startAngle", i), this.setPrivate("endAngle", a);
+    }
+  }
+  _updateLines(e, t) {
+    this._tooltipX || this._drawXLine(e, t), this._tooltipY || this._drawYLine(e, t);
+  }
+  _drawXLine(e, t) {
+    const s = this.getPrivate("innerRadius"), i = this.getPrivate("radius"), a = Math.atan2(t, e);
+    this.lineX.set("draw", (r) => {
+      r.moveTo(s * Math.cos(a), s * Math.sin(a)), r.lineTo(i * Math.cos(a), i * Math.sin(a));
+    });
+  }
+  _drawYLine(e, t) {
+    const s = Math.hypot(e, t);
+    this.lineY.set("draw", (i) => {
+      i.arc(0, 0, s, this.getPrivate("startAngle", 0) * c, this.getPrivate("endAngle", 0) * c);
+    });
+  }
+  _updateXLine(e) {
+    let t = e.get("pointTo");
+    t && (t = this._display.toLocal(t), this._drawXLine(t.x, t.y));
+  }
+  _updateYLine(e) {
+    let t = e.get("pointTo");
+    t && (t = this._display.toLocal(t), this._drawYLine(t.x, t.y));
+  }
+  _inPlot(e) {
+    const t = this.chart;
+    return t ? t.inPlot(e, this.getPrivate("radius"), this.getPrivate("innerRadius")) : !1;
+  }
+  _updateSelection(e) {
+    this.selection.set("draw", (t) => {
+      const s = this.get("behavior"), i = this._downPoint, a = this.getPrivate("startAngle"), r = this.getPrivate("endAngle");
+      let n = this.getPrivate("radius"), l = this.getPrivate("innerRadius");
+      n < l && ([n, l] = [l, n]);
+      let u = a, o = r, y = n, f = l;
+      i && (s == "zoomXY" || s == "selectXY" ? (u = Math.atan2(i.y, i.x) * C, o = Math.atan2(e.y, e.x) * C, f = Math.hypot(i.x, i.y), y = Math.hypot(e.x, e.y)) : s == "zoomX" || s == "selectX" ? (u = Math.atan2(i.y, i.x) * C, o = Math.atan2(e.y, e.x) * C) : (s == "zoomY" || s == "selectY") && (f = Math.hypot(i.x, i.y), y = Math.hypot(e.x, e.y))), f = ne(f, l, n), y = ne(y, l, n), u = le(u, a, r), o = le(o, a, r), u == o && (o = u + 360), u *= c, o *= c, this._fillGenerator.context(t), this._fillGenerator({ innerRadius: f, outerRadius: y, startAngle: u + Math.PI / 2, endAngle: o + Math.PI / 2 });
+    });
+  }
+}
+Object.defineProperty(B, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "RadarCursor"
+});
+Object.defineProperty(B, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: he.classNames.concat([B.className])
+});
+class F extends ge {
+  _afterNew() {
+    super._afterNew(), this.set("maskContent", !1), this.bulletsContainer.set("maskContent", !1), this.bulletsContainer.set("mask", J.new(this._root, {}));
+  }
+  _handleMaskBullets() {
+  }
+  getPoint(e, t) {
+    const s = this.get("yAxis"), i = this.get("xAxis"), a = s.get("renderer"), r = a.positionToCoordinate(t) + a.getPrivate("innerRadius", 0), l = i.get("renderer").positionToAngle(e);
+    return { x: r * h(l), y: r * g(l) };
+  }
+  _endLine(e, t) {
+    this.get("connectEnds") && t && e.push(t);
+  }
+  _shouldInclude(e) {
+    const t = this.get("xAxis");
+    return !(e < t.get("start") || e > t.get("end"));
+  }
+  _shouldShowBullet(e, t) {
+    const s = this.get("xAxis");
+    return e < s.get("start") || e > s.get("end") ? !1 : this._showBullets;
+  }
+  _positionBullet(e) {
+    let t = e.get("sprite");
+    if (t) {
+      let s = t.dataItem, i = e.get("locationX", s.get("locationX", 0.5)), a = e.get("locationY", s.get("locationY", 0.5)), r = this.get("xAxis"), n = this.get("yAxis");
+      const l = r.getDataItemPositionX(s, this._xField, i, this.get("vcx", 1)), u = n.getDataItemPositionY(s, this._yField, a, this.get("vcy", 1));
+      let o = this.getPoint(l, u);
+      this._shouldShowBullet(l, u) ? (t.setPrivate("visible", !0), t.set("x", o.x), t.set("y", o.y)) : t.setPrivate("visible", !1);
+    }
+  }
+}
+Object.defineProperty(F, "className", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: "RadarLineSeries"
+});
+Object.defineProperty(F, "classNames", {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: ge.classNames.concat([F.className])
+});
+const Ue = (_) => {
+  const e = ye({ props: _, name: "HCStackedAreaRadar" }), {
+    dimensions: t,
+    values: s,
+    data: i,
+    initDelay: a = 0,
+    baseInterval: r,
+    colors: n,
+    sx: l,
+    ...u
+  } = e, o = be(), f = `hc-stacked-area-radar-${Re().replace(/:/g, "")}`, T = _e(null);
+  we(() => {
+    let V;
+    return V = setTimeout(() => {
+      var se, ie;
+      const d = xe.new(f);
+      T.current = d, d.setThemes([ve.new(d)]), d.interfaceColors.setAll({
+        text: Y(o.palette.text.primary),
+        grid: Y(o.palette.divider),
+        stroke: Y(o.palette.divider)
+      });
+      const b = d.container.children.push(
+        k.new(d, {
+          panX: !1,
+          panY: !1,
+          wheelX: "none",
+          wheelY: "none",
+          innerRadius: w(40),
+          radius: w(70),
+          arrangeTooltips: !1
+        })
+      );
+      if (b.set("colors", Te(d, n)), b.get("colors", {}).set("step", 2), b.set(
+        "cursor",
+        B.new(d, { behavior: "zoomX" })
+      ).lineY.set("visible", !1), t.length < 2) {
+        console.error("StackedAreaRadar requires at least 2 dimensions");
+        return;
+      }
+      if (s.length < 1) {
+        console.error("StackedAreaRadar requires at least 1 value");
+        return;
+      }
+      const x = t[0], fe = t[1];
+      let v = [];
+      const z = U.groupBy(i, fe.value);
+      Object.keys(z).forEach((A) => {
+        z[A].forEach((P) => {
+          const p = P[x.value], q = U.findIndex(v, { [x.value]: p });
+          q === -1 ? v.push({
+            [x.value]: p,
+            [A]: P[s[0].dataFieldName]
+          }) : v[q] = {
+            ...v[q],
+            [A]: P[s[0].dataFieldName]
+          };
+        });
+      });
+      const S = j.new(d, {
+        minGridDistance: 30
+      });
+      S.labels.template.setAll({
+        textType: "radial",
+        radius: 10,
+        paddingTop: 0,
+        paddingBottom: 0,
+        centerY: N,
+        fontSize: "0.8em"
+      }), S.grid.template.setAll({
+        location: 0.5,
+        strokeDasharray: [2, 2]
+      });
+      let D;
+      if (x.type === "date") {
+        const A = (r == null ? void 0 : r.timeUnit) || "day";
+        let P = "DD/MM/YYYY";
+        A === "month" ? P = "MM YYYY" : A === "year" && (P = "YYYY"), D = b.xAxes.push(
+          oe.new(d, {
+            maxDeviation: 0,
+            categoryField: x.value,
+            renderer: S,
+            tooltip: H.new(d, {})
+          })
+        ), v = U.orderBy(v, [x.value]), v = v.map((p) => ({
+          ...p,
+          [x.value]: Pe(p[x.value]).format(P)
+        }));
+      } else
+        D = b.xAxes.push(
+          oe.new(d, {
+            maxDeviation: 0,
+            categoryField: x.value,
+            renderer: S,
+            tooltip: H.new(d, {})
+          })
+        );
+      const Q = G.new(d, {
+        minGridDistance: 30
+      }), Z = b.yAxes.push(
+        Le.new(d, { renderer: Q })
+      );
+      Q.grid.template.setAll({ strokeDasharray: [2, 2] }), (se = D.get("renderer")) == null || se.grid.template.setAll({
+        stroke: Y(o.palette.divider),
+        strokeOpacity: 1
+      }), (ie = Z.get("renderer")) == null || ie.grid.template.setAll({
+        stroke: Y(o.palette.divider),
+        strokeOpacity: 1
+      });
+      const ee = [];
+      let X = "";
+      const te = Object.keys(z);
+      te.forEach((A, P) => {
+        X.length > 0 && (X += `
+`), X += `${A}: {${A}}`;
+        const p = b.series.push(
+          F.new(d, {
+            name: A,
+            xAxis: D,
+            yAxis: Z,
+            valueYField: A,
+            categoryXField: x.value,
+            ...P === te.length - 1 && {
+              stacked: !0,
+              tooltip: H.new(d, { labelText: X })
+            }
+          })
+        );
+        p.strokes.template.setAll({ strokeOpacity: 0 }), p.fills.template.setAll({ visible: !0, fillOpacity: 0.5 }), p.data.setAll(v), p.appear(1e3), ee.push(p);
+      }), b.radarContainer.children.push(
+        De.new(d, {
+          width: 150,
+          centerX: N,
+          centerY: N
+        })
+      ).data.setAll(ee), D.data.setAll(v), b.appear(1e3, 100);
+    }, a), () => {
+      var d;
+      V && clearTimeout(V), (d = T.current) == null || d.dispose(), T.current = null;
+    };
+  }, [i, t, s, o.palette.mode, n]);
+  const ce = { ...e };
+  return { chartId: f, ownerState: ce, sx: l, other: u };
+};
+export {
+  Ue as useStackedAreaRadarLogic
+};