@alfadocs/ui-kit-debug 1.61.0 → 1.62.0

package/dist/_chunks/chart-DgYHN8Xq.js

@@ -0,0 +1,991 @@
+import { jsx as v, jsxs as Y } from "react/jsx-runtime";
+import { useEffect as X, forwardRef as tt, useId as rt, useMemo as w, useRef as G, useState as B, useImperativeHandle as at } from "react";
+import { c as ge } from "./index-D2ZczOXr.js";
+import { useTranslation as nt } from "react-i18next";
+import st from "react-apexcharts";
+import De from "apexcharts";
+import { u as ot, a as it, g as Ge, b as ct, r as lt } from "./apexcharts-theme-DNoXvgnZ.js";
+import { u as dt } from "./use-prefers-reduced-motion-BMwIQRjB.js";
+import { u as ut } from "./use-isomorphic-layout-effect-BGfaCOP1.js";
+import { c as pt } from "./compose-refs-C0k0tdqF.js";
+import { u as ht } from "./registry-DvAUVLHh.js";
+import { I as mt } from "./icon-button-C_1TgRiK.js";
+import { I as ft } from "./icon-button-group-NIHji7_y.js";
+import { c as J } from "./createLucideIcon-DhHxpK9K.js";
+/**
+ * @license lucide-react v1.22.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const bt = [
+  ["path", { d: "M3 3v16a2 2 0 0 0 2 2h16", key: "c24i48" }],
+  [
+    "path",
+    {
+      d: "M7 11.207a.5.5 0 0 1 .146-.353l2-2a.5.5 0 0 1 .708 0l3.292 3.292a.5.5 0 0 0 .708 0l4.292-4.292a.5.5 0 0 1 .854.353V16a1 1 0 0 1-1 1H8a1 1 0 0 1-1-1z",
+      key: "q0gr47"
+    }
+  ]
+], yt = J("chart-area", bt);
+/**
+ * @license lucide-react v1.22.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const vt = [
+  ["path", { d: "M3 3v16a2 2 0 0 0 2 2h16", key: "c24i48" }],
+  ["path", { d: "M18 17V9", key: "2bz60n" }],
+  ["path", { d: "M13 17V5", key: "1frdt8" }],
+  ["path", { d: "M8 17v-3", key: "17ska0" }]
+], gt = J("chart-column", vt);
+/**
+ * @license lucide-react v1.22.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const xt = [
+  ["path", { d: "M3 3v16a2 2 0 0 0 2 2h16", key: "c24i48" }],
+  ["path", { d: "m19 9-5 5-4-4-3 3", key: "2osh9i" }]
+], St = J("chart-line", xt);
+/**
+ * @license lucide-react v1.22.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const wt = [
+  [
+    "path",
+    {
+      d: "M21 12c.552 0 1.005-.449.95-.998a10 10 0 0 0-8.953-8.951c-.55-.055-.998.398-.998.95v8a1 1 0 0 0 1 1z",
+      key: "pzmjnu"
+    }
+  ],
+  ["path", { d: "M21.21 15.89A10 10 0 1 1 8 2.83", key: "k2fpak" }]
+], At = J("chart-pie", wt);
+/**
+ * @license lucide-react v1.22.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Tt = [
+  [
+    "path",
+    {
+      d: "M20.5 10a2.5 2.5 0 0 1-2.4-3H18a2.95 2.95 0 0 1-2.6-4.4 10 10 0 1 0 6.3 7.1c-.3.2-.8.3-1.2.3",
+      key: "19sr3x"
+    }
+  ],
+  ["circle", { cx: "12", cy: "12", r: "3", key: "1v7zrd" }]
+], Et = J("donut", Tt), Ct = ".apexcharts-legend, .apexcharts-toolbar";
+function de(e, r, t) {
+  !e || e.getAttribute(r) === t || (t === null ? e.removeAttribute(r) : e.setAttribute(r, t));
+}
+function Lt(e, r) {
+  X(() => {
+    if (!e) return;
+    const t = () => {
+      e.querySelectorAll(".apexcharts-canvas").forEach((d) => {
+        Array.from(d.children).forEach((h) => {
+          h.matches(Ct) || de(h, "aria-hidden", "true");
+        });
+      }), e.querySelectorAll(".apexcharts-toolbar").forEach((d) => {
+        var s;
+        const h = ((s = d.querySelector(".apexcharts-menu-icon")) == null ? void 0 : s.getAttribute("aria-expanded")) === "true";
+        de(
+          d.querySelector(".apexcharts-menu"),
+          "inert",
+          h ? null : ""
+        );
+      }), e.querySelectorAll(
+        '.apexcharts-legend-series[role="button"]'
+      ).forEach((d) => {
+        de(d, "aria-label", null);
+        const h = d.getAttribute("data:collapsed") === "true" ? "false" : "true";
+        de(d, "aria-pressed", r ? h : null);
+      });
+    };
+    let i = 0;
+    const p = (d) => {
+      const h = d.target instanceof Element ? d.target.closest(".apexcharts-legend-series") : null, s = h == null ? void 0 : h.getAttribute("rel");
+      s && (cancelAnimationFrame(i), i = requestAnimationFrame(() => {
+        var l;
+        const g = document.activeElement;
+        g && g !== document.body || (l = e.querySelector(
+          `.apexcharts-legend-series[rel="${CSS.escape(s)}"]`
+        )) == null || l.focus();
+      }));
+    };
+    t();
+    const c = new MutationObserver(t);
+    return c.observe(e, {
+      childList: !0,
+      subtree: !0,
+      attributes: !0,
+      attributeFilter: [
+        "aria-hidden",
+        "aria-label",
+        "aria-pressed",
+        "aria-expanded"
+      ]
+    }), e.addEventListener("click", p), () => {
+      c.disconnect(), e.removeEventListener("click", p), cancelAnimationFrame(i);
+    };
+  }, [e, r]);
+}
+function ue(e, r, t) {
+  t && e.getAttribute(r) !== "true" ? e.setAttribute(r, "true") : !t && e.hasAttribute(r) && e.removeAttribute(r);
+}
+function It(e, r) {
+  X(() => {
+    if (!e || !r) return;
+    let t = null;
+    const i = () => {
+      if (!t) return;
+      const s = Math.abs(t.scrollLeft), g = t.scrollWidth - t.clientWidth;
+      ue(t, "data-fade-start", s > 1), ue(t, "data-fade-end", g - s > 1);
+    }, p = () => {
+      const s = e.querySelector(".apexcharts-legend");
+      s !== t && (t == null || t.removeEventListener("scroll", i), t = s, t == null || t.addEventListener("scroll", i, { passive: !0 })), i();
+    }, c = (s) => {
+      const { target: g } = s;
+      !t || !(g instanceof HTMLElement) || !t.contains(g) || !g.matches(":focus-visible") || g.scrollIntoView({ block: "nearest", inline: "nearest" });
+    }, d = (s) => s instanceof Element && (s.closest(".apexcharts-legend") !== null || s.querySelector(".apexcharts-legend") !== null), h = new MutationObserver((s) => {
+      s.some(
+        (l) => [l.target, ...l.addedNodes, ...l.removedNodes].some(
+          d
+        )
+      ) && p();
+    });
+    return p(), h.observe(e, { childList: !0, subtree: !0 }), e.addEventListener("focusin", c), () => {
+      h.disconnect(), e.removeEventListener("focusin", c), t && (t.removeEventListener("scroll", i), ue(t, "data-fade-start", !1), ue(t, "data-fade-end", !1));
+    };
+  }, [e, r]);
+}
+const Rt = {
+  id: "chart",
+  // view_change backs the opt-in type switcher (`switchableTypes` prop):
+  // the same chart re-presented as line / bar / area / pie / donut.
+  capabilities: ["view_change"],
+  state: {
+    declaredType: {
+      type: "'line' | 'bar' | 'pie' | 'donut' | 'area' | 'radialBar'",
+      descriptionKey: "ui.agent.chart.state.declaredType",
+      description: "The consumer-declared chart type — the shape `update_series` expects.",
+      read: (e) => e.getTypeState().declaredType
+    },
+    effectiveType: {
+      type: "'line' | 'bar' | 'pie' | 'donut' | 'area' | 'radialBar'",
+      descriptionKey: "ui.agent.chart.state.effectiveType",
+      description: "The type currently rendered — differs from declaredType after a type-switcher pick.",
+      read: (e) => e.getTypeState().effectiveType
+    },
+    availableTypes: {
+      type: "ChartType[]",
+      descriptionKey: "ui.agent.chart.state.availableTypes",
+      description: "Types the switcher offers. Empty when the chart has no type switcher.",
+      read: (e) => e.getTypeState().availableTypes
+    }
+  },
+  actions: {
+    change_view: {
+      // Switching the presentation is a write (it changes what the user
+      // sees) but is trivially reversible by switching back.
+      safety: "write",
+      argsType: "type",
+      argsSchema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["line", "bar", "area", "pie", "donut"],
+            description: "The chart type to render."
+          }
+        },
+        required: ["type"]
+      },
+      returns: "boolean (accepted)",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when the switch was applied; false when the chart has no type switcher or the type is not offered (check availableTypes first)."
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.chart.actions.changeView",
+      description: "Switch the rendered chart type via the type switcher. No-op (returns false) when the chart has no switcher or the type is not offered.",
+      invoke: (e, r) => e.setType(r.type)
+    },
+    update_series: {
+      // Replacing the rendered series mutates what the chart displays — it
+      // is a write, reversible by pushing the prior series back.
+      safety: "write",
+      argsType: "series",
+      // `series` is `ChartSeries[]` (line/bar/area) OR `number[]`
+      // (pie/donut/radialBar). Both shapes are accepted; the handle routes
+      // by chart type internally.
+      argsSchema: {
+        type: "object",
+        properties: {
+          series: {
+            oneOf: [
+              {
+                type: "array",
+                description: "Categorical series for line / bar / area charts.",
+                items: {
+                  type: "object",
+                  properties: {
+                    name: { type: "string" },
+                    data: { type: "array", items: { type: "number" } },
+                    role: {
+                      type: "string",
+                      enum: ["primary", "compare"],
+                      description: "Optional. 'compare' renders this series as a secondary, colour-blind-safe overlay (e.g. the previous period) — a dotted stroke in its paired primary's colour for line/area, a tinted bar with a dotted outline for bar. Omit for a normal primary series."
+                    }
+                  },
+                  required: ["name", "data"]
+                }
+              },
+              {
+                type: "array",
+                description: "Flat values for pie / donut / radialBar charts.",
+                items: { type: "number" }
+              }
+            ]
+          }
+        },
+        required: ["series"]
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.chart.actions.updateSeries",
+      description: "Replace the chart series without remounting. Pass the DECLARED type’s shape (see declaredType state); when the user has switched the view cross-shape the values are converted to the rendered shape. The data and its summary table persist across type switches, resizes and theme changes until the host passes a new series prop.",
+      invoke: (e, r) => {
+        e.updateSeries(r.series);
+      }
+    },
+    export_png: {
+      safety: "read",
+      returns: "string (PNG data URI)",
+      returnsSchema: {
+        type: "string",
+        description: "A `data:image/png;base64,…` URI of the rendered chart."
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.chart.actions.exportPng",
+      description: "Return a PNG data URI of the chart for export or screenshotting. Waits until series pushed with update_series are drawn.",
+      invoke: (e) => e.dataURI()
+    }
+  },
+  domHooks: {
+    root: { attr: "data-component", value: "chart" },
+    instanceId: {
+      attr: "data-component-id",
+      sourceProp: "id",
+      description: "Sourced from the id prop."
+    }
+  }
+}, kt = ge(
+  "ds:relative ds:block ds:w-full apex-theme-alfadocs",
+  {
+    variants: {
+      density: {
+        compact: "ds:min-h-[var(--chart-min-height-compact)]",
+        comfortable: "ds:min-h-[var(--chart-min-height-comfortable)]",
+        // Applied when an explicit `height` prop is given and no density was
+        // requested: the wrapper must not exceed the caller's height (a 96px
+        // KPI chart inside a card must not reserve 320px).
+        none: ""
+      }
+    },
+    defaultVariants: { density: "comfortable" }
+  }
+), _t = ge("", {
+  variants: {
+    fill: {
+      none: "",
+      // The figure is the root: it takes the share itself, and as a flex item
+      // may still shrink below what it last drew.
+      root: "ds:h-[var(--chart-fill-size)] ds:min-h-0",
+      // Below the switcher row: the rest, whatever ApexCharts draws inside.
+      rest: "ds:min-h-0 ds:flex-1"
+    }
+  },
+  defaultVariants: { fill: "none" }
+}), Ot = ge("ds:w-full", {
+  variants: {
+    fill: {
+      false: "ds:block",
+      true: "ds:flex ds:flex-col ds:h-[var(--chart-fill-size)] ds:min-h-0"
+    }
+  },
+  defaultVariants: { fill: !1 }
+}), Nt = [
+  "verticalLines",
+  "horizontalLines",
+  "slantedLines",
+  "squares",
+  "circles"
+], Mt = ["line", "bar", "area"], Bt = ["pie", "donut", "radialBar"], Ve = [
+  "line",
+  "bar",
+  "area",
+  "pie",
+  "donut"
+], Ht = {
+  line: "chart.typeSwitcher.line",
+  bar: "chart.typeSwitcher.bar",
+  area: "chart.typeSwitcher.area",
+  pie: "chart.typeSwitcher.pie",
+  donut: "chart.typeSwitcher.donut"
+}, zt = {
+  line: /* @__PURE__ */ v(St, {}),
+  bar: /* @__PURE__ */ v(gt, {}),
+  area: /* @__PURE__ */ v(yt, {}),
+  pie: /* @__PURE__ */ v(At, {}),
+  donut: /* @__PURE__ */ v(Et, {})
+}, Pt = 2, Ye = "0 6", qt = 5, $t = -45, Wt = 640, Ft = 300, Dt = 160;
+function Gt(e, r) {
+  !e || r.length === 0 || e.querySelectorAll(
+    ".apexcharts-bar-series > .apexcharts-series"
+  ).forEach((t) => {
+    const i = Number(t.getAttribute("data:realIndex"));
+    r.includes(i) && t.querySelectorAll("path.apexcharts-bar-area").forEach(
+      (p) => {
+        if (typeof p.getBBox != "function") return;
+        const c = p.getBBox();
+        p.setAttribute(
+          "d",
+          `M ${c.x} ${c.y + c.height} L ${c.x} ${c.y} L ${c.x + c.width} ${c.y} L ${c.x + c.width} ${c.y + c.height}`
+        ), p.setAttribute("stroke-dasharray", Ye), p.setAttribute("stroke-linecap", "round");
+      }
+    );
+  });
+}
+function Ke(e) {
+  const r = getComputedStyle(e), t = (i) => Number.parseFloat(r.getPropertyValue(i)) || 0;
+  return t("--min-target-size") + t("--focus-ring-offset") + t("--focus-ring-width");
+}
+function Vt(e, r) {
+  if (e === void 0) return r;
+  if (typeof e == "number") return e;
+  const t = Number.parseInt(e, 10);
+  return e.trim().endsWith("%") ? r * t / 100 : t;
+}
+function Kt(e) {
+  return typeof e == "number" ? e : e.trim().endsWith("%") ? Number.NaN : Number.parseInt(e, 10);
+}
+function je(e, r, t, i, p, c) {
+  if (i === p)
+    return {
+      effectiveSeries: e,
+      effectiveCategories: r,
+      effectiveLabels: t
+    };
+  if (!i) {
+    const s = e.filter((l) => l.role !== "compare");
+    return {
+      effectiveSeries: s.map((l) => l.data.reduce((R, $) => R + $, 0)),
+      effectiveCategories: void 0,
+      effectiveLabels: s.map((l) => l.name)
+    };
+  }
+  return {
+    effectiveSeries: [{ name: c, data: e }],
+    effectiveCategories: t ?? [],
+    effectiveLabels: void 0
+  };
+}
+function Ue({
+  themeOptions: e,
+  toolbarBand: r,
+  chartId: t,
+  toolbar: i,
+  reducedMotion: p,
+  toolbarLocale: c,
+  locale: d,
+  effectiveLabels: h,
+  formatValue: s,
+  noDataText: g,
+  effectiveType: l,
+  effectiveSeries: R,
+  effectiveCategories: $,
+  isRtl: H,
+  patterns: he,
+  stacked: z,
+  orientation: W,
+  curve: F,
+  colors: P,
+  radialValueFormatter: Q,
+  narrow: ee,
+  wrapperRef: me
+}) {
+  var re, K, D, ae, C, ne;
+  const o = e, L = pe(l) && Array.isArray(R) ? R.map((n) => n.role === "compare") : [], I = L.some(Boolean), k = I && l === "bar", V = k && R.some(
+    (n) => n.role === "compare" && n.data.some((m) => m < 0)
+  ), te = k && W === "vertical" && !V, f = I ? ct() : 0.3, u = {
+    ...o,
+    chart: {
+      ...o.chart,
+      id: t,
+      toolbar: { show: i },
+      zoom: { enabled: i },
+      animations: {
+        enabled: !p,
+        dynamicAnimation: { enabled: !p }
+      },
+      locales: [c],
+      defaultLocale: d,
+      parentHeightOffset: 0,
+      // Keep the keyboard-operable legend; drop Apex's data-point navigation
+      // and live announcements (English-only, and the summary table covers them).
+      accessibility: {
+        enabled: !0,
+        announcements: { enabled: !1 },
+        keyboard: { enabled: !0, navigation: { enabled: !1 } }
+      },
+      // Stacking is axis-only, so a slice or radial chart never receives it.
+      // Sent as false too: ApexCharts merges an update into its config, so
+      // leaving it out would keep an earlier `true`.
+      ...pe(l) ? { stacked: z } : {}
+    },
+    // Only set `labels` when the effective type actually has them (slice
+    // charts). Emitting `labels: undefined` crashes ApexCharts' bar
+    // renderer — `parseDataAxisCharts` reads `labels.length` and throws
+    // "Cannot read properties of undefined (reading 'length')", which
+    // aborts the render and leaves a blank chart. Absent is safe; area /
+    // line tolerate the undefined but bar does not, so never pass it.
+    ...h ? { labels: h } : {},
+    legend: {
+      ...o.legend,
+      position: "bottom",
+      // ApexCharts legend.horizontalAlign is a physical prop mapped internally
+      // to the chart's own text flow. For RTL we flip via `yaxis.opposite`
+      // and ApexCharts' own `direction: 'rtl'` handling; legend stays anchored
+      // to the inline-start by asking for 'left' on LTR and 'right' on RTL.
+      horizontalAlign: H ? "right" : "left",
+      fontFamily: "inherit",
+      // apexcharts-theme.css sizes the legend hit areas and ring room from
+      // this 4px; pinned so an ApexCharts default change cannot break them.
+      itemMargin: { horizontal: 5, vertical: 4 }
+    },
+    tooltip: {
+      ...o.tooltip,
+      y: {
+        formatter: (n) => s(n)
+      }
+    },
+    noData: {
+      text: g
+    }
+  };
+  if (u.title = i && r ? { ...u.title, text: "", margin: r } : { ...u.title, text: void 0, margin: qt }, P && P.length > 0 && (u.colors = P), I) {
+    const n = u.colors ?? o.colors ?? [], m = (T) => n[T % Math.max(n.length, 1)], A = R.map((T, N) => T.role === "compare" ? -1 : N).filter((T) => T >= 0);
+    let O = 0;
+    u.colors = R.map((T, N) => {
+      if (T.role !== "compare") return m(N);
+      const M = A.length ? A[Math.min(O++, A.length - 1)] : N;
+      return m(M);
+    });
+    const j = u.colors.map(
+      (T, N) => L[N] ? lt(T) : T
+    );
+    u.legend = {
+      ...u.legend,
+      markers: {
+        ...((re = u.legend) == null ? void 0 : re.markers) ?? {},
+        fillColors: j
+      }
+    };
+  }
+  if (pe(l)) {
+    const n = l === "bar" && W === "horizontal";
+    u.xaxis = {
+      ...o.xaxis,
+      categories: $ ?? [],
+      labels: {
+        ...(K = o.xaxis) == null ? void 0 : K.labels,
+        formatter: n ? (m) => s(Number(m)) : void 0,
+        // A narrow chart thins crowded labels rather than turning them sideways.
+        // Sent both ways, so a widened chart rotates; the thinning is pinned
+        // so an ApexCharts default change cannot leave narrow labels overlapping.
+        rotate: ee ? 0 : $t,
+        hideOverlappingLabels: !0
+      }
+    }, u.yaxis = {
+      ...o.yaxis,
+      opposite: H,
+      ...n ? {} : { labels: { formatter: (m) => s(m) } }
+    }, u.stroke = {
+      curve: F,
+      width: l === "bar" ? I ? L.map((m) => m ? Pt : 0) : 0 : 2,
+      ...I ? {
+        lineCap: "round",
+        // Runtime accepts a string dash; the published types say
+        // `number` → one documented cast. `'0 6'` + round cap ⇒ dots.
+        dashArray: L.map(
+          (m) => m ? Ye : 0
+        )
+      } : {}
+    }, u.dataLabels = { enabled: !1 };
+  }
+  if (l === "radialBar" && Q) {
+    const n = o.plotOptions ?? {};
+    u.plotOptions = {
+      ...n,
+      radialBar: {
+        ...n.radialBar ?? {},
+        dataLabels: {
+          ...((D = n.radialBar) == null ? void 0 : D.dataLabels) ?? {},
+          value: {
+            ...((C = (ae = n.radialBar) == null ? void 0 : ae.dataLabels) == null ? void 0 : C.value) ?? {},
+            formatter: (m) => Q(Number(m))
+          }
+        }
+      }
+    };
+  }
+  if (l === "bar") {
+    const n = o.plotOptions ?? {};
+    u.plotOptions = {
+      ...n,
+      bar: {
+        ...n.bar ?? {},
+        horizontal: W === "horizontal"
+      }
+    };
+  }
+  if (he ? u.fill = {
+    type: I ? L.map((n) => n ? "solid" : "pattern") : "pattern",
+    opacity: I ? L.map(
+      (n) => n ? f : l === "area" ? 0.3 : 1
+    ) : l === "area" ? 0.3 : 1,
+    pattern: {
+      style: [...Nt],
+      strokeWidth: 2
+    }
+  } : k ? u.fill = {
+    type: "solid",
+    opacity: L.map((n) => n ? f : 1)
+  } : l === "area" && (u.fill = I ? {
+    type: "gradient",
+    opacity: L.map((n) => n ? f : 0.3)
+  } : {
+    type: "gradient",
+    opacity: 0.3
+  }), te) {
+    const n = L.map((O, j) => O ? j : -1).filter((O) => O >= 0), m = () => Gt(me.current, n), A = () => typeof requestAnimationFrame == "function" ? requestAnimationFrame(m) : m();
+    u.chart = {
+      ...u.chart,
+      events: {
+        ...((ne = u.chart) == null ? void 0 : ne.events) ?? {},
+        mounted: () => A(),
+        updated: () => A(),
+        animationEnd: () => m()
+      }
+    };
+  }
+  return jt(u, l);
+}
+function jt(e, r) {
+  var i, p, c, d, h, s;
+  if (!pe(r)) return e;
+  const t = (i = e.chart) == null ? void 0 : i.events;
+  return {
+    ...e,
+    colors: e.colors,
+    chart: {
+      ...e.chart,
+      events: {
+        ...t,
+        mounted: t == null ? void 0 : t.mounted,
+        updated: t == null ? void 0 : t.updated,
+        animationEnd: t == null ? void 0 : t.animationEnd
+      }
+    },
+    stroke: {
+      ...e.stroke,
+      lineCap: ((p = e.stroke) == null ? void 0 : p.lineCap) ?? (r === "bar" ? "square" : "butt"),
+      dashArray: ((c = e.stroke) == null ? void 0 : c.dashArray) ?? 0
+    },
+    legend: {
+      ...e.legend,
+      markers: {
+        ...(d = e.legend) == null ? void 0 : d.markers,
+        fillColors: (s = (h = e.legend) == null ? void 0 : h.markers) == null ? void 0 : s.fillColors
+      }
+    },
+    fill: e.fill ?? { type: "solid", opacity: 0.85 }
+  };
+}
+function Z(e) {
+  return Bt.includes(e);
+}
+function pe(e) {
+  return Mt.includes(e);
+}
+function Ut(e, r) {
+  return Z(r) ? [
+    {
+      name: "",
+      data: e
+    }
+  ] : e;
+}
+const Yt = tt(
+  ({
+    title: e,
+    id: r,
+    type: t,
+    series: i,
+    categories: p,
+    labels: c,
+    height: d,
+    width: h,
+    patterns: s = !1,
+    stacked: g = !1,
+    orientation: l = "vertical",
+    curve: R = "smooth",
+    colors: $,
+    toolbar: H = !1,
+    locale: he,
+    radialValueFormatter: z,
+    valueFormatter: W,
+    switchableTypes: F,
+    onTypeChange: P,
+    density: Q,
+    className: ee
+  }, me) => {
+    const { t: o, i18n: L } = nt("ui"), I = rt(), k = w(
+      () => `chart-${I.replace(/[^a-zA-Z0-9-_]/g, "")}`,
+      [I]
+    ), V = `${k}-summary`, te = G(null), [f, u] = B(null), re = w(
+      () => pt(te, u),
+      []
+    ), K = w(() => ({ current: f }), [f]), [D, ae] = B(0), C = typeof d == "string" && d.trim().endsWith("%") ? d.trim() : void 0, [ne, n] = B(0), m = G(!1);
+    m.current = C !== void 0, ut(() => {
+      C && f && n(Math.floor(f.clientHeight));
+    }, [C, f]), ot(K), it(K);
+    const A = he ?? L.language ?? "en", [O, j] = B(() => {
+      try {
+        return Ge();
+      } catch {
+        return {};
+      }
+    });
+    X(() => {
+      if (typeof document > "u") return;
+      let a;
+      const y = new MutationObserver(() => {
+        clearTimeout(a), a = setTimeout(() => {
+          try {
+            j(Ge());
+          } catch {
+          }
+        }, 50);
+      });
+      return y.observe(document.documentElement, {
+        attributes: !0,
+        attributeFilter: ["class"]
+      }), () => {
+        clearTimeout(a), y.disconnect();
+      };
+    }, []);
+    const [T, N] = B(
+      () => typeof document > "u" ? 0 : Ke(document.documentElement)
+    );
+    X(() => {
+      if (!f || !H) return;
+      const a = new ResizeObserver(() => y()), y = () => {
+        const S = f.querySelector(".apexcharts-toolbar");
+        S && a.observe(S), N(
+          Math.max(Ke(f), (S == null ? void 0 : S.offsetHeight) ?? 0)
+        );
+      };
+      y();
+      const x = new MutationObserver(y);
+      for (let S = f.parentElement; S; S = S.parentElement)
+        x.observe(S, { attributes: !0, attributeFilter: ["class"] });
+      const E = new MutationObserver((S) => {
+        S.flatMap((U) => [...U.addedNodes]).some(
+          (U) => U instanceof Element && (U.matches(".apexcharts-toolbar") || U.querySelector(".apexcharts-toolbar"))
+        ) && y();
+      });
+      return E.observe(f, { childList: !0, subtree: !0 }), () => {
+        a.disconnect(), x.disconnect(), E.disconnect();
+      };
+    }, [f, H]), X(() => {
+      const a = f;
+      if (!a || typeof ResizeObserver > "u") return;
+      const y = new ResizeObserver((x) => {
+        const E = x[0];
+        E && (ae(Math.floor(E.contentRect.width)), m.current && n(Math.floor(E.contentRect.height)));
+      });
+      return y.observe(a), () => y.disconnect();
+    }, [f]);
+    const M = w(() => {
+      if (!F || F.length === 0) return [];
+      const a = F.filter(
+        (x) => Ve.includes(x)
+      );
+      if (!Ve.includes(t))
+        return [];
+      const y = a.includes(t) ? a : [t, ...a];
+      return [...new Set(y)];
+    }, [F, t]), _ = M.length >= 2, [fe, xe] = B(null), b = _ && fe && M.includes(fe) ? fe : t;
+    Lt(
+      f,
+      b !== "pie" && b !== "donut"
+    );
+    const be = Z(t), ye = Z(b), [se, Se] = B(null), [we, Ze] = B(i);
+    we !== i && (Ze(i), se && Se(null));
+    const Ae = se && se.base === i && we === i ? se.next : i, Te = G(i);
+    Te.current = i;
+    const { effectiveSeries: q, effectiveCategories: oe, effectiveLabels: ie } = w(
+      () => je(
+        Ae,
+        p,
+        c,
+        be,
+        ye,
+        o("chart.table.value")
+      ),
+      [Ae, p, c, be, ye, o]
+    ), Ee = (a) => je(
+      a,
+      p,
+      c,
+      be,
+      ye,
+      o("chart.table.value")
+    ), Ce = G(Ee);
+    Ce.current = Ee;
+    const Le = G(Promise.resolve()), ve = w(
+      () => ({
+        async dataURI() {
+          await Le.current;
+          const a = De.getChartByID(k);
+          return a ? (await a.dataURI()).imgURI : "";
+        },
+        updateSeries(a) {
+          Se({ base: Te.current, next: a });
+          const y = De.getChartByID(k);
+          if (!y) return;
+          const x = Ce.current(a), E = { ...He.current, ...x };
+          Le.current = y.updateOptions(
+            { ...Ue(E), series: x.effectiveSeries },
+            !1,
+            !0
+          ).catch(() => {
+          });
+        },
+        setType(a) {
+          return !_ || !M.includes(a) ? !1 : (xe(a), !0);
+        },
+        getTypeState() {
+          return {
+            declaredType: t,
+            effectiveType: b,
+            availableTypes: _ ? [...M] : []
+          };
+        }
+      }),
+      [k, t, b, _, M]
+    );
+    at(me, () => ve, [ve]), ht(Rt, ve, r);
+    const Ie = typeof document < "u" && document.documentElement.dir === "rtl", Re = w(
+      () => Ut(q, b),
+      [q, b]
+    ), ke = w(
+      () => new Intl.NumberFormat(A),
+      [A]
+    ), ce = w(
+      () => W ?? ((a) => ke.format(a)),
+      [W, ke]
+    ), _e = w(
+      () => ({
+        name: A,
+        options: {
+          toolbar: {
+            download: o("chart.toolbar.download"),
+            // Names the button that opens the export menu (Apex: "Menu").
+            menu: o("chart.toolbar.download"),
+            selection: o("chart.toolbar.selection"),
+            selectionZoom: o("chart.toolbar.selectionZoom"),
+            zoomIn: o("chart.toolbar.zoomIn"),
+            zoomOut: o("chart.toolbar.zoomOut"),
+            pan: o("chart.toolbar.pan"),
+            reset: o("chart.toolbar.reset"),
+            exportToSVG: o("chart.toolbar.exportToSVG"),
+            exportToPNG: o("chart.toolbar.exportToPNG"),
+            exportToCSV: o("chart.toolbar.exportToCSV")
+          }
+        }
+      }),
+      [A, o]
+    ), Oe = dt(), Ne = o("chart.noData"), Me = Vt(h, D), Be = Me > 0 && Me < Wt, le = w(
+      () => ({
+        themeOptions: O,
+        toolbarBand: T,
+        chartId: k,
+        toolbar: H,
+        reducedMotion: Oe,
+        toolbarLocale: _e,
+        locale: A,
+        effectiveLabels: ie,
+        formatValue: ce,
+        noDataText: Ne,
+        effectiveType: b,
+        effectiveSeries: q,
+        effectiveCategories: oe,
+        isRtl: Ie,
+        patterns: s,
+        stacked: g,
+        orientation: l,
+        curve: R,
+        colors: $,
+        radialValueFormatter: z,
+        narrow: Be,
+        wrapperRef: te
+      }),
+      [
+        O,
+        T,
+        k,
+        H,
+        Oe,
+        _e,
+        A,
+        ie,
+        ce,
+        Ne,
+        b,
+        q,
+        oe,
+        Ie,
+        s,
+        g,
+        l,
+        R,
+        $,
+        z,
+        Be
+      ]
+    ), Xe = w(
+      () => Ue(le),
+      [le]
+    ), He = G(le);
+    He.current = le;
+    const Je = h ?? (D > 0 ? D : "100%"), ze = C ? Math.max(ne, Dt) : d ?? 320, Pe = Kt(ze), qe = Pe > 0 && Pe < Ft;
+    It(f, qe);
+    const Qe = w(() => {
+      const a = Z(b) ? ie ?? [] : oe ?? [], y = Re;
+      return /* @__PURE__ */ v("div", { className: "ds:sr-only", children: /* @__PURE__ */ Y("table", { id: V, children: [
+        /* @__PURE__ */ v("caption", { children: e }),
+        /* @__PURE__ */ v("thead", { children: /* @__PURE__ */ Y("tr", { children: [
+          /* @__PURE__ */ v("th", { scope: "col", children: o("chart.table.series") }),
+          a.map((x, E) => /* @__PURE__ */ v("th", { scope: "col", children: x }, `${x}-${E}`))
+        ] }) }),
+        /* @__PURE__ */ v("tbody", { children: y.map((x, E) => /* @__PURE__ */ Y("tr", { children: [
+          /* @__PURE__ */ v("th", { scope: "row", children: x.name || o("chart.table.value") }),
+          x.data.map((S, Fe) => /* @__PURE__ */ v("td", { children: b === "radialBar" && z ? z(S) : ce(S) }, `${E}-${Fe}`))
+        ] }, `${x.name}-${E}`)) })
+      ] }) });
+    }, [
+      b,
+      Re,
+      ie,
+      oe,
+      V,
+      e,
+      o,
+      ce,
+      z
+    ]), et = w(() => (Z(b), q), [q, b]), $e = C ? {
+      "--chart-fill-size": C
+    } : void 0, We = /* @__PURE__ */ Y(
+      "div",
+      {
+        ref: re,
+        role: "figure",
+        "aria-label": e,
+        "aria-describedby": V,
+        "data-legend-layout": qe ? "row" : void 0,
+        className: kt({
+          // Explicit height wins over the density min-height unless the
+          // caller also asked for a density explicitly.
+          // A `%` height takes its height from the parent, never a density.
+          density: C ? "none" : Q ?? (d !== void 0 ? "none" : void 0),
+          className: [
+            _t({
+              fill: C ? _ ? "rest" : "root" : "none"
+            }),
+            _ ? void 0 : ee
+          ].filter(Boolean).join(" ")
+        }),
+        style: _ ? void 0 : $e,
+        ..._ ? {} : { "data-component": "chart", "data-component-id": r },
+        children: [
+          Qe,
+          /* @__PURE__ */ v(
+            st,
+            {
+              type: b,
+              series: et,
+              options: Xe,
+              width: Je,
+              height: ze
+            },
+            b
+          )
+        ]
+      }
+    );
+    return _ ? /* @__PURE__ */ Y(
+      "div",
+      {
+        "data-component": "chart",
+        "data-component-id": r,
+        className: Ot({
+          fill: C !== void 0,
+          className: ee
+        }),
+        style: $e,
+        children: [
+          /* @__PURE__ */ v("div", { className: "ds:mb-[var(--spacing-xs)] ds:flex ds:justify-end", children: /* @__PURE__ */ v(
+            ft,
+            {
+              role: "radiogroup",
+              mode: "toggle-single",
+              size: "sm",
+              "aria-label": o("chart.typeSwitcher.label"),
+              value: b,
+              onValueChange: (a) => {
+                a !== b && (xe(a), P == null || P(a));
+              },
+              children: M.map((a) => /* @__PURE__ */ v(
+                mt,
+                {
+                  value: a,
+                  type: "button",
+                  icon: zt[a],
+                  "aria-label": o(Ht[a])
+                },
+                a
+              ))
+            }
+          ) }),
+          We
+        ]
+      }
+    ) : We;
+  }
+);
+Yt.displayName = "Chart";
+export {
+  Yt as C,
+  kt as a,
+  Rt as c
+};
+//# sourceMappingURL=chart-DgYHN8Xq.js.map