@undp/data-viz 1.2.8 → 1.3.1

package/dist/RadarChart.js

@@ -0,0 +1,678 @@
+import { j as a, m as E } from "./index-CHPV5EwG-BPSP-7Jg.js";
+import { useRef as ut, useState as j, useEffect as kt } from "react";
+import { u as pt } from "./index-CaAIPGZo.js";
+import { i as jt } from "./index-27yTRcko.js";
+import { X as It } from "./Modal-CUU6ZK3U.js";
+import { T as Ct } from "./Tooltip-DyM5snqx.js";
+import { Colors as L } from "./Colors.js";
+import { n as xt } from "./numberFormattingFunction-14YCbkN2.js";
+import { s as Nt } from "./string2HTML-CWHGfz_d.js";
+import { c as O } from "./checkIfNullOrUndefined-DmfiKkNw.js";
+import { u as Pt } from "./use-in-view-BAHrBy6b.js";
+import { a as ft } from "./linear-DUdu7l2G.js";
+import { c as St, l as Ot } from "./line-CPfhohvF.js";
+import { m as X } from "./proxy-DJxJg1kD.js";
+import { A as Tt } from "./index-BxAUvrua.js";
+import { GraphFooter as $t } from "./GraphFooter.js";
+import { GraphHeader as Dt } from "./GraphHeader.js";
+import { E as Vt } from "./EmptyState-DdTp-Mdn.js";
+import { ColorLegendWithMouseOver as Et } from "./ColorLegendWithMouseOver.js";
+var Lt = _t(St);
+function gt(t) {
+  this._curve = t;
+}
+gt.prototype = {
+  areaStart: function() {
+    this._curve.areaStart();
+  },
+  areaEnd: function() {
+    this._curve.areaEnd();
+  },
+  lineStart: function() {
+    this._curve.lineStart();
+  },
+  lineEnd: function() {
+    this._curve.lineEnd();
+  },
+  point: function(t, e) {
+    this._curve.point(e * Math.sin(t), e * -Math.cos(t));
+  }
+};
+function _t(t) {
+  function e(s) {
+    return new gt(t(s));
+  }
+  return e._curve = t, e;
+}
+function At(t) {
+  var e = t.curve;
+  return t.angle = t.x, delete t.x, t.radius = t.y, delete t.y, t.curve = function(s) {
+    return arguments.length ? e(_t(s)) : e()._curve;
+  }, t;
+}
+function Ht() {
+  return At(Ot().curve(Lt));
+}
+function et() {
+}
+function dt(t, e, s) {
+  t._context.bezierCurveTo(
+    t._x1 + t._k * (t._x2 - t._x0),
+    t._y1 + t._k * (t._y2 - t._y0),
+    t._x2 + t._k * (t._x1 - e),
+    t._y2 + t._k * (t._y1 - s),
+    t._x2,
+    t._y2
+  );
+}
+function yt(t, e) {
+  this._context = t, this._k = (1 - e) / 6;
+}
+yt.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._point = 0;
+  },
+  lineEnd: function() {
+    switch (this._point) {
+      case 2:
+        this._context.lineTo(this._x2, this._y2);
+        break;
+      case 3:
+        dt(this, this._x1, this._y1);
+        break;
+    }
+    (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+  },
+  point: function(t, e) {
+    switch (t = +t, e = +e, this._point) {
+      case 0:
+        this._point = 1, this._line ? this._context.lineTo(t, e) : this._context.moveTo(t, e);
+        break;
+      case 1:
+        this._point = 2, this._x1 = t, this._y1 = e;
+        break;
+      case 2:
+        this._point = 3;
+      // falls through
+      default:
+        dt(this, t, e);
+        break;
+    }
+    this._x0 = this._x1, this._x1 = this._x2, this._x2 = t, this._y0 = this._y1, this._y1 = this._y2, this._y2 = e;
+  }
+};
+(function t(e) {
+  function s(c) {
+    return new yt(c, e);
+  }
+  return s.tension = function(c) {
+    return t(+c);
+  }, s;
+})(0);
+function vt(t, e) {
+  this._context = t, this._k = (1 - e) / 6;
+}
+vt.prototype = {
+  areaStart: et,
+  areaEnd: et,
+  lineStart: function() {
+    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN, this._point = 0;
+  },
+  lineEnd: function() {
+    switch (this._point) {
+      case 1: {
+        this._context.moveTo(this._x3, this._y3), this._context.closePath();
+        break;
+      }
+      case 2: {
+        this._context.lineTo(this._x3, this._y3), this._context.closePath();
+        break;
+      }
+      case 3: {
+        this.point(this._x3, this._y3), this.point(this._x4, this._y4), this.point(this._x5, this._y5);
+        break;
+      }
+    }
+  },
+  point: function(t, e) {
+    switch (t = +t, e = +e, this._point) {
+      case 0:
+        this._point = 1, this._x3 = t, this._y3 = e;
+        break;
+      case 1:
+        this._point = 2, this._context.moveTo(this._x4 = t, this._y4 = e);
+        break;
+      case 2:
+        this._point = 3, this._x5 = t, this._y5 = e;
+        break;
+      default:
+        dt(this, t, e);
+        break;
+    }
+    this._x0 = this._x1, this._x1 = this._x2, this._x2 = t, this._y0 = this._y1, this._y1 = this._y2, this._y2 = e;
+  }
+};
+const Rt = function t(e) {
+  function s(c) {
+    return new vt(c, e);
+  }
+  return s.tension = function(c) {
+    return t(+c);
+  }, s;
+}(0);
+function Mt(t) {
+  this._context = t;
+}
+Mt.prototype = {
+  areaStart: et,
+  areaEnd: et,
+  lineStart: function() {
+    this._point = 0;
+  },
+  lineEnd: function() {
+    this._point && this._context.closePath();
+  },
+  point: function(t, e) {
+    t = +t, e = +e, this._point ? this._context.lineTo(t, e) : (this._point = 1, this._context.moveTo(t, e));
+  }
+};
+function Wt(t) {
+  return new Mt(t);
+}
+function Ft(t) {
+  const {
+    data: e,
+    radius: s,
+    lineColors: c,
+    tooltip: I,
+    onSeriesMouseOver: A,
+    onSeriesMouseClick: v,
+    colorDomain: u,
+    detailsOnClick: M,
+    styles: _,
+    classNames: m,
+    selectedColor: T,
+    axisLabels: Y,
+    strokeWidth: at,
+    showValues: nt,
+    showDots: ot,
+    rightMargin: st,
+    topMargin: z,
+    bottomMargin: rt,
+    leftMargin: H,
+    curveType: q,
+    noOfTicks: B,
+    minValue: $,
+    maxValue: D,
+    resetSelectionOnDoubleClick: lt,
+    fillShape: h,
+    highlightedLines: f,
+    animate: d,
+    dimmedOpacity: g,
+    precision: C,
+    customLayers: U
+  } = t, J = ut(null), V = Pt(J, {
+    once: d.once,
+    amount: d.amount
+  }), w = q === "linear" ? Wt : Rt, b = {
+    top: z,
+    left: H
+  }, y = Math.min(
+    (2 * s - H - st) / 2,
+    (2 * s - z - rt) / 2
+  ), [k, R] = j(void 0), [N, W] = j(void 0), [K, F] = j(void 0), [Q, G] = j(void 0), l = ft().domain([0, e[0].values.length]).range([0, 2 * Math.PI]), Z = O(D) ? Math.max(
+    ...e.map(
+      (i) => Math.max(...i.values.filter((n) => !O(n)))
+    )
+  ) < 0 ? 0 : Math.max(
+    ...e.map(
+      (i) => Math.max(...i.values.filter((n) => !O(n)))
+    )
+  ) : D, ct = O($) ? Math.min(
+    ...e.map(
+      (i) => Math.min(...i.values.filter((n) => !O(n)))
+    )
+  ) >= 0 ? 0 : Math.min(
+    ...e.map(
+      (i) => Math.min(...i.values.filter((n) => !O(n)))
+    )
+  ) : $, p = ft().domain([ct, Z]).range([0, y]).nice(), ht = p.ticks(B), P = Ht().radius((i) => p(i)).angle((i, n) => l(n)).curve(w);
+  return /* @__PURE__ */ a.jsxs(a.Fragment, { children: [
+    /* @__PURE__ */ a.jsx(
+      X.svg,
+      {
+        width: `${s * 2}px`,
+        height: `${s * 2}px`,
+        viewBox: `0 0 ${s * 2} ${s * 2}`,
+        direction: "ltr",
+        ref: J,
+        children: /* @__PURE__ */ a.jsxs("g", { transform: `translate(${b.left},${b.top})`, children: [
+          U.filter((i) => i.position === "before").map((i) => i.layer),
+          /* @__PURE__ */ a.jsxs("g", { transform: `translate(${y},${y})`, children: [
+            Y.map((i, n) => /* @__PURE__ */ a.jsxs("g", { children: [
+              /* @__PURE__ */ a.jsx(
+                "line",
+                {
+                  x1: 0,
+                  y1: 0,
+                  x2: Math.cos(l(n) - Math.PI / 2) * y,
+                  y2: Math.sin(l(n) - Math.PI / 2) * y,
+                  className: E(
+                    "stroke-1 stroke-primary-gray-500 dark:stroke-primary-gray-550",
+                    m?.xAxis?.axis
+                  ),
+                  style: _?.xAxis?.axis
+                },
+                n
+              ),
+              /* @__PURE__ */ a.jsx(
+                "text",
+                {
+                  x: Math.cos(l(n) - Math.PI / 2) * (y + 6),
+                  y: Math.sin(l(n) - Math.PI / 2) * (y + 6),
+                  style: {
+                    textAnchor: Math.cos(l(n) - Math.PI / 2) < 0 ? "end" : Math.cos(l(n) - Math.PI / 2) < 1e-5 ? "middle" : "start",
+                    ..._?.xAxis?.labels || ""
+                  },
+                  dy: Math.sin(l(n) - Math.PI / 2) < 0 ? 0 : Math.sin(l(n) - Math.PI / 2) < 1e-5 ? 5 : 10,
+                  className: E(
+                    "fill-primary-gray-700 dark:fill-primary-gray-300 text-xs",
+                    m?.xAxis?.labels
+                  ),
+                  children: i
+                }
+              )
+            ] }, n)),
+            ht.map((i, n) => /* @__PURE__ */ a.jsxs("g", { children: [
+              /* @__PURE__ */ a.jsx(
+                "path",
+                {
+                  d: P(Array(Y.length).fill(i)) || "",
+                  className: E(
+                    "stroke-primary-gray-500 dark:stroke-primary-gray-550",
+                    m?.xAxis?.gridLines
+                  ),
+                  style: {
+                    ..._?.xAxis?.gridLines,
+                    fill: "none"
+                  }
+                }
+              ),
+              /* @__PURE__ */ a.jsx(
+                "foreignObject",
+                {
+                  x: -25,
+                  y: Math.sin(-Math.PI / 2) * p(i) > -1e-4 ? Math.sin(-Math.PI / 2) * p(i) - 7 : Math.sin(-Math.PI / 2) * p(i) - 5,
+                  width: 50,
+                  height: 12,
+                  children: /* @__PURE__ */ a.jsx("div", { className: "flex justify-center", children: /* @__PURE__ */ a.jsx(
+                    "p",
+                    {
+                      className: E(
+                        "fill-primary-gray-500 dark:fill-primary-gray-550 text-xs m-0 py-0 px-1.5 text-center leading-none bg-primary-white dark:bg-primary-gray-700",
+                        m?.xAxis?.labels
+                      ),
+                      style: _?.xAxis?.labels,
+                      children: xt(i, "NA", C)
+                    }
+                  ) })
+                }
+              )
+            ] }, n)),
+            /* @__PURE__ */ a.jsx(Tt, { children: e.map((i, n) => /* @__PURE__ */ a.jsxs(
+              X.g,
+              {
+                variants: {
+                  initial: {
+                    opacity: k ? i.label === k.label ? 1 : g : T ? i.color && c[u.indexOf(i.color)] === T ? 1 : g : f.length !== 0 ? i.label && f.indexOf(i.label) !== -1 ? 1 : 0.3 : 1
+                  },
+                  whileInView: {
+                    opacity: k ? i.label === k.label ? 1 : g : T ? i.color && c[u.indexOf(i.color)] === T ? 1 : g : f.length !== 0 ? i.label && f.indexOf(i.label) !== -1 ? 1 : g : 1,
+                    transition: { duration: d.duration }
+                  }
+                },
+                initial: "initial",
+                animate: V ? "whileInView" : "initial",
+                exit: { opacity: 0, transition: { duration: d.duration } },
+                onMouseEnter: (r) => {
+                  R(i), G(r.clientY), F(r.clientX), A?.(i);
+                },
+                onMouseMove: (r) => {
+                  R(i), G(r.clientY), F(r.clientX);
+                },
+                onMouseLeave: () => {
+                  R(void 0), F(void 0), G(void 0), A?.(void 0);
+                },
+                onClick: () => {
+                  (v || M) && (jt(N, i) && lt ? (W(void 0), v?.(void 0)) : (W(i), v?.(i)));
+                },
+                children: [
+                  /* @__PURE__ */ a.jsx(
+                    X.path,
+                    {
+                      d: P(i.values) || "",
+                      variants: {
+                        initial: { d: P(i.values.map((r) => 0)) || "" },
+                        whileInView: {
+                          d: P(i.values) || "",
+                          transition: { duration: d.duration }
+                        }
+                      },
+                      initial: "initial",
+                      animate: V ? "whileInView" : "initial",
+                      exit: { opacity: 0, transition: { duration: d.duration } },
+                      style: {
+                        stroke: e.filter((r) => r.color).length === 0 ? c[0] : i.color ? c[u.indexOf(i.color)] : L.gray,
+                        fill: h ? e.filter((r) => r.color).length === 0 ? c[0] : i.color ? c[u.indexOf(i.color)] : L.gray : "none",
+                        fillOpacity: 0.1,
+                        strokeWidth: at
+                      }
+                    }
+                  ),
+                  /* @__PURE__ */ a.jsx("g", { children: i.values.map((r, x) => /* @__PURE__ */ a.jsx("g", { children: O(r) ? null : /* @__PURE__ */ a.jsxs(a.Fragment, { children: [
+                    ot ? /* @__PURE__ */ a.jsx(
+                      X.circle,
+                      {
+                        cx: Math.cos(l(x) - Math.PI / 2) * p(r),
+                        cy: Math.sin(l(x) - Math.PI / 2) * p(r),
+                        r: 4,
+                        style: {
+                          fill: e.filter((tt) => tt.color).length === 0 ? c[0] : i.color ? c[u.indexOf(i.color)] : L.gray
+                        },
+                        variants: {
+                          initial: { cx: 0, cy: 0, opacity: 0 },
+                          whileInView: {
+                            cx: Math.cos(l(x) - Math.PI / 2) * p(r),
+                            cy: Math.sin(l(x) - Math.PI / 2) * p(r),
+                            opacity: 1,
+                            transition: { duration: d.duration }
+                          }
+                        },
+                        initial: "initial",
+                        animate: V ? "whileInView" : "initial",
+                        exit: { opacity: 0, transition: { duration: d.duration } }
+                      }
+                    ) : null,
+                    nt ? /* @__PURE__ */ a.jsx(
+                      X.text,
+                      {
+                        x: Math.cos(l(x) - Math.PI / 2) * (p(r) + 6),
+                        y: Math.sin(l(x) - Math.PI / 2) * (p(r) + 6),
+                        style: {
+                          fill: c[n],
+                          textAnchor: Math.cos(l(x) - Math.PI / 2) < 0 ? "end" : Math.cos(l(x) - Math.PI / 2) < 1e-5 ? "middle" : "start",
+                          ..._?.graphObjectValues || {}
+                        },
+                        dy: Math.sin(l(x) - Math.PI / 2) < 0 ? 10 : (Math.sin(l(x) - Math.PI / 2) < 1e-5, 0),
+                        className: E(
+                          "graph-value text-xs font-bold",
+                          m?.graphObjectValues
+                        ),
+                        variants: {
+                          initial: { opacity: 0 },
+                          whileInView: {
+                            opacity: 1,
+                            transition: { duration: d.duration }
+                          }
+                        },
+                        initial: "initial",
+                        animate: V ? "whileInView" : "initial",
+                        exit: { opacity: 0, transition: { duration: d.duration } },
+                        children: xt(r, "NA", C)
+                      }
+                    ) : null
+                  ] }) }, x)) })
+                ]
+              },
+              i.label || n
+            )) })
+          ] }),
+          U.filter((i) => i.position === "after").map((i) => i.layer)
+        ] })
+      }
+    ),
+    k && I && K && Q ? /* @__PURE__ */ a.jsx(
+      Ct,
+      {
+        data: k,
+        body: I,
+        xPos: K,
+        yPos: Q,
+        backgroundStyle: _?.tooltip,
+        className: m?.tooltip
+      }
+    ) : null,
+    M && N !== void 0 ? /* @__PURE__ */ a.jsx(
+      It,
+      {
+        open: N !== void 0,
+        onClose: () => {
+          W(void 0);
+        },
+        children: /* @__PURE__ */ a.jsx(
+          "div",
+          {
+            className: "graph-modal-content m-0",
+            dangerouslySetInnerHTML: typeof M == "string" ? { __html: Nt(M, N) } : void 0,
+            children: typeof M == "function" ? M(N) : null
+          }
+        )
+      }
+    ) : null
+  ] });
+}
+function li(t) {
+  const {
+    graphTitle: e,
+    colors: s,
+    sources: c,
+    graphDescription: I,
+    footNote: A,
+    radius: v,
+    data: u,
+    showColorScale: M = !0,
+    padding: _,
+    backgroundColor: m = !1,
+    tooltip: T,
+    onSeriesMouseOver: Y,
+    graphID: at,
+    onSeriesMouseClick: nt,
+    topMargin: ot = 75,
+    bottomMargin: st = 75,
+    leftMargin: z = 75,
+    rightMargin: rt = 75,
+    graphDownload: H = !1,
+    dataDownload: q = !1,
+    colorDomain: B,
+    language: $ = "en",
+    theme: D = "light",
+    highlightedLines: lt = [],
+    width: h,
+    height: f,
+    minHeight: d = 0,
+    strokeWidth: g = 2,
+    relativeHeight: C,
+    ariaLabel: U,
+    colorLegendTitle: J,
+    detailsOnClick: V,
+    styles: w,
+    classNames: b,
+    showNAColor: y = !0,
+    axisLabels: k,
+    showDots: R = !0,
+    showValues: N = !1,
+    curveType: W = "curve",
+    noOfTicks: K = 5,
+    minValue: F,
+    maxValue: Q,
+    fillShape: G = !1,
+    resetSelectionOnDoubleClick: l = !0,
+    animate: Z = !1,
+    dimmedOpacity: ct = 0.3,
+    precision: p = 2,
+    customLayers: ht = []
+  } = t, [P, i] = j(0), [n, r] = j(0), [x, tt] = j(0), [wt, bt] = j(void 0), S = ut(null), mt = ut(null);
+  return kt(() => {
+    const o = new ResizeObserver((it) => {
+      r(h || it[0].target.clientWidth || 420), tt(f || it[0].target.clientHeight || 420), i(
+        (Math.min(
+          h || it[0].target.clientWidth || 620,
+          f || it[0].target.clientHeight || 480
+        ) || 420) / 2
+      );
+    });
+    return S.current && (tt(S.current.clientHeight || 420), r(S.current.clientWidth || 420), i(
+      (Math.min(S.current.clientWidth, S.current.clientHeight) || 420) / 2
+    ), (!h || !v) && o.observe(S.current)), () => o.disconnect();
+  }, [h, f, v]), /* @__PURE__ */ a.jsx(
+    "div",
+    {
+      className: `${D || "light"} flex  ${h ? "w-fit grow-0" : "w-full grow"}`,
+      dir: $ === "he" || $ === "ar" ? "rtl" : void 0,
+      children: /* @__PURE__ */ a.jsx(
+        "div",
+        {
+          className: E(
+            `${m ? m === !0 ? "bg-primary-gray-200 dark:bg-primary-gray-650 " : "" : "bg-transparent "}ml-auto mr-auto flex flex-col grow h-inherit ${$ || "en"}`,
+            b?.graphContainer
+          ),
+          style: {
+            ...w?.graphContainer || {},
+            minHeight: "inherit",
+            ...m && m !== !0 ? { backgroundColor: m } : {}
+          },
+          id: at,
+          ref: mt,
+          "aria-label": U || `${e ? `The graph shows ${e}. ` : ""}This is a donut or pie chart chart. ${I ? ` ${I}` : ""}`,
+          children: /* @__PURE__ */ a.jsx(
+            "div",
+            {
+              className: "flex grow",
+              style: { padding: m ? _ || "1rem" : _ || 0 },
+              children: /* @__PURE__ */ a.jsxs("div", { className: "flex flex-col gap-2 w-full grow justify-between", children: [
+                e || I || H || q ? /* @__PURE__ */ a.jsx(
+                  Dt,
+                  {
+                    styles: {
+                      title: w?.title,
+                      description: w?.description
+                    },
+                    classNames: {
+                      title: b?.title,
+                      description: b?.description
+                    },
+                    graphTitle: e,
+                    graphDescription: I,
+                    width: h,
+                    graphDownload: H ? mt.current : void 0,
+                    dataDownload: q ? u.map((o) => o.data).filter((o) => o !== void 0).length > 0 ? u.map((o) => o.data).filter((o) => o !== void 0) : u.filter((o) => o !== void 0) : null
+                  }
+                ) : null,
+                /* @__PURE__ */ a.jsx(
+                  "div",
+                  {
+                    className: "flex grow flex-col justify-center items-stretch gap-8 flex-wrap",
+                    style: {
+                      width: h ? `${h}px` : "100%"
+                    },
+                    children: u.length === 0 ? /* @__PURE__ */ a.jsx(Vt, {}) : /* @__PURE__ */ a.jsxs(a.Fragment, { children: [
+                      M && u.filter((o) => o.color).length !== 0 ? /* @__PURE__ */ a.jsx(
+                        Et,
+                        {
+                          width: h,
+                          colorLegendTitle: J,
+                          colors: s || L[D].categoricalColors.colors,
+                          colorDomain: B || pt(
+                            u.filter((o) => o.color),
+                            "color"
+                          ).map((o) => o.color),
+                          setSelectedColor: bt,
+                          showNAColor: y
+                        }
+                      ) : null,
+                      /* @__PURE__ */ a.jsx(
+                        "div",
+                        {
+                          className: `flex ${h ? "grow-0" : "grow"} items-center justify-center leading-0`,
+                          style: {
+                            width: h ? `${h}px` : "100%",
+                            height: f ? `${Math.max(
+                              d,
+                              f || (C ? d ? (h || n) * C > d ? (h || n) * C : d : (h || n) * C : x)
+                            )}px` : "auto"
+                          },
+                          ref: S,
+                          "aria-label": "Graph area",
+                          children: /* @__PURE__ */ a.jsx("div", { className: "w-full flex justify-center leading-0", children: v || P ? /* @__PURE__ */ a.jsx(
+                            Ft,
+                            {
+                              data: u,
+                              lineColors: u.filter((o) => o.color).length === 0 ? s ? [s] : [L.primaryColors["blue-600"]] : s || L[D].categoricalColors.colors,
+                              radius: v || P,
+                              tooltip: T,
+                              colorDomain: B || pt(
+                                u.filter((o) => o.color),
+                                "color"
+                              ).map((o) => o.color),
+                              onSeriesMouseOver: Y,
+                              onSeriesMouseClick: nt,
+                              styles: w,
+                              detailsOnClick: V,
+                              selectedColor: wt,
+                              axisLabels: k,
+                              strokeWidth: g,
+                              showValues: N,
+                              showDots: R,
+                              topMargin: ot,
+                              bottomMargin: st,
+                              leftMargin: z,
+                              rightMargin: rt,
+                              curveType: W,
+                              noOfTicks: K,
+                              minValue: F,
+                              maxValue: Q,
+                              fillShape: G,
+                              highlightedLines: lt,
+                              resetSelectionOnDoubleClick: l,
+                              animate: Z === !0 ? { duration: 0.5, once: !0, amount: 0.5 } : Z || { duration: 0, once: !0, amount: 0 },
+                              dimmedOpacity: ct,
+                              precision: p,
+                              customLayers: ht
+                            }
+                          ) : null })
+                        }
+                      )
+                    ] })
+                  }
+                ),
+                c || A ? /* @__PURE__ */ a.jsx(
+                  $t,
+                  {
+                    styles: { footnote: w?.footnote, source: w?.source },
+                    classNames: {
+                      footnote: b?.footnote,
+                      source: b?.source
+                    },
+                    sources: c,
+                    footNote: A,
+                    width: h
+                  }
+                ) : /* @__PURE__ */ a.jsx("div", {})
+              ] })
+            }
+          )
+        }
+      )
+    }
+  );
+}
+export {
+  li as RadarChart
+};
+//# sourceMappingURL=RadarChart.js.map