@alfadocs/ui-kit 1.54.3 → 1.56.0

package/dist/_chunks/chart-HsF1KHbx.js

@@ -0,0 +1,909 @@
+import { jsxs as Y, jsx as g } from "react/jsx-runtime";
+import { useEffect as ce, forwardRef as Ge, useId as Ke, useMemo as x, useRef as j, useState as z, useImperativeHandle as Ue } from "react";
+import { c as Ye } from "./index-D2ZczOXr.js";
+import { useTranslation as je } from "react-i18next";
+import Ve from "react-apexcharts";
+import Le from "apexcharts";
+import { u as Ze, a as Je, g as _e, b as Qe, r as Xe } from "./apexcharts-theme-DNoXvgnZ.js";
+import { u as et } from "./use-prefers-reduced-motion-BMwIQRjB.js";
+import { c as tt } from "./compose-refs-C0k0tdqF.js";
+import { u as rt } from "./registry-DvAUVLHh.js";
+import { I as at } from "./icon-button-COX76Jdj.js";
+import { I as nt } from "./icon-button-group-C5hhI-R5.js";
+import { c as Z } 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 ot = [
+  ["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"
+    }
+  ]
+], st = Z("chart-area", ot);
+/**
+ * @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 it = [
+  ["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" }]
+], ct = Z("chart-column", it);
+/**
+ * @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 lt = [
+  ["path", { d: "M3 3v16a2 2 0 0 0 2 2h16", key: "c24i48" }],
+  ["path", { d: "m19 9-5 5-4-4-3 3", key: "2osh9i" }]
+], dt = Z("chart-line", lt);
+/**
+ * @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 pt = [
+  [
+    "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" }]
+], ut = Z("chart-pie", pt);
+/**
+ * @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 ht = [
+  [
+    "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" }]
+], mt = Z("donut", ht), ft = ".apexcharts-legend, .apexcharts-toolbar";
+function ie(e, s, t) {
+  !e || e.getAttribute(s) === t || (t === null ? e.removeAttribute(s) : e.setAttribute(s, t));
+}
+function yt(e, s) {
+  ce(() => {
+    if (!e) return;
+    const t = () => {
+      e.querySelectorAll(".apexcharts-canvas").forEach((u) => {
+        Array.from(u.children).forEach((y) => {
+          y.matches(ft) || ie(y, "aria-hidden", "true");
+        });
+      }), e.querySelectorAll(".apexcharts-toolbar").forEach((u) => {
+        var v;
+        const y = ((v = u.querySelector(".apexcharts-menu-icon")) == null ? void 0 : v.getAttribute("aria-expanded")) === "true";
+        ie(
+          u.querySelector(".apexcharts-menu"),
+          "inert",
+          y ? null : ""
+        );
+      }), e.querySelectorAll(
+        '.apexcharts-legend-series[role="button"]'
+      ).forEach((u) => {
+        ie(u, "aria-label", null);
+        const y = u.getAttribute("data:collapsed") === "true" ? "false" : "true";
+        ie(u, "aria-pressed", s ? y : null);
+      });
+    };
+    let i = 0;
+    const p = (u) => {
+      const y = u.target instanceof Element ? u.target.closest(".apexcharts-legend-series") : null, v = y == null ? void 0 : y.getAttribute("rel");
+      v && (cancelAnimationFrame(i), i = requestAnimationFrame(() => {
+        var l;
+        const k = document.activeElement;
+        k && k !== document.body || (l = e.querySelector(
+          `.apexcharts-legend-series[rel="${CSS.escape(v)}"]`
+        )) == 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, s]);
+}
+const bt = {
+  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, s) => e.setType(s.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) — dashed grey for line/area, hatched grey 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, s) => {
+        e.updateSeries(s.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."
+    }
+  }
+}, gt = Ye(
+  "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" }
+  }
+), vt = [
+  "verticalLines",
+  "horizontalLines",
+  "slantedLines",
+  "squares",
+  "circles"
+], wt = ["line", "bar", "area"], St = ["pie", "donut", "radialBar"], Be = [
+  "line",
+  "bar",
+  "area",
+  "pie",
+  "donut"
+], xt = {
+  line: "chart.typeSwitcher.line",
+  bar: "chart.typeSwitcher.bar",
+  area: "chart.typeSwitcher.area",
+  pie: "chart.typeSwitcher.pie",
+  donut: "chart.typeSwitcher.donut"
+}, Tt = {
+  line: /* @__PURE__ */ g(dt, {}),
+  bar: /* @__PURE__ */ g(ct, {}),
+  area: /* @__PURE__ */ g(st, {}),
+  pie: /* @__PURE__ */ g(ut, {}),
+  donut: /* @__PURE__ */ g(mt, {})
+}, At = 2, Pe = "0 6";
+function Ct(e, s) {
+  !e || s.length === 0 || e.querySelectorAll(
+    ".apexcharts-bar-series > .apexcharts-series"
+  ).forEach((t) => {
+    const i = Number(t.getAttribute("data:realIndex"));
+    s.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", Pe), p.setAttribute("stroke-linecap", "round");
+      }
+    );
+  });
+}
+function Ne(e) {
+  const s = getComputedStyle(e), t = (i) => Number.parseFloat(s.getPropertyValue(i)) || 0;
+  return t("--min-target-size") + t("--focus-ring-offset") + t("--focus-ring-width");
+}
+function ze(e, s, t, i, p, c) {
+  if (i === p)
+    return {
+      effectiveSeries: e,
+      effectiveCategories: s,
+      effectiveLabels: t
+    };
+  if (!i) {
+    const v = e.filter((l) => l.role !== "compare");
+    return {
+      effectiveSeries: v.map((l) => l.data.reduce((C, M) => C + M, 0)),
+      effectiveCategories: void 0,
+      effectiveLabels: v.map((l) => l.name)
+    };
+  }
+  return {
+    effectiveSeries: [{ name: c, data: e }],
+    effectiveCategories: t ?? [],
+    effectiveLabels: void 0
+  };
+}
+function Me({
+  themeOptions: e,
+  toolbarBand: s,
+  chartId: t,
+  toolbar: i,
+  reducedMotion: p,
+  toolbarLocale: c,
+  locale: u,
+  effectiveLabels: y,
+  formatValue: v,
+  noDataText: k,
+  effectiveType: l,
+  effectiveSeries: C,
+  effectiveCategories: M,
+  isRtl: L,
+  patterns: de,
+  stacked: _,
+  orientation: P,
+  curve: $,
+  colors: B,
+  radialValueFormatter: J,
+  wrapperRef: Q
+}) {
+  var X, ee, D, W, te;
+  const A = e, o = le(l) && Array.isArray(C) ? C.map((r) => r.role === "compare") : [], E = o.some(Boolean), q = E && l === "bar", R = q && C.some(
+    (r) => r.role === "compare" && r.data.some((d) => d < 0)
+  ), F = q && P === "vertical" && !R, H = E ? Qe() : 0.3, n = {
+    ...A,
+    chart: {
+      ...A.chart,
+      id: t,
+      toolbar: { show: i },
+      zoom: { enabled: i },
+      animations: {
+        enabled: !p,
+        dynamicAnimation: { enabled: !p }
+      },
+      locales: [c],
+      defaultLocale: u,
+      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 an axis-only concept — gate on the categorical types
+      // so a slice/radial chart never receives it, and omit the key
+      // entirely when unstacked so the default output is byte-identical.
+      ..._ && le(l) ? { stacked: !0 } : {}
+    },
+    // 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.
+    ...y ? { labels: y } : {},
+    legend: {
+      ...A.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: L ? "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: {
+      ...A.tooltip,
+      y: {
+        formatter: (r) => v(r)
+      }
+    },
+    noData: {
+      text: k
+    }
+  };
+  if (i && s && (n.title = { ...n.title, text: "", margin: s }), B && B.length > 0 && (n.colors = B), E) {
+    const r = n.colors ?? A.colors ?? [], d = (f) => r[f % Math.max(r.length, 1)], I = C.map((f, S) => f.role === "compare" ? -1 : S).filter((f) => f >= 0);
+    let O = 0;
+    n.colors = C.map((f, S) => {
+      if (f.role !== "compare") return d(S);
+      const K = I.length ? I[Math.min(O++, I.length - 1)] : S;
+      return d(K);
+    });
+    const G = n.colors.map(
+      (f, S) => o[S] ? Xe(f) : f
+    );
+    n.legend = {
+      ...n.legend,
+      markers: {
+        ...((X = n.legend) == null ? void 0 : X.markers) ?? {},
+        fillColors: G
+      }
+    };
+  }
+  if (le(l)) {
+    const r = l === "bar" && P === "horizontal";
+    n.xaxis = {
+      ...A.xaxis,
+      categories: M ?? [],
+      ...r ? {
+        labels: {
+          formatter: (d) => v(Number(d))
+        }
+      } : {}
+    }, n.yaxis = {
+      ...A.yaxis,
+      opposite: L,
+      ...r ? {} : { labels: { formatter: (d) => v(d) } }
+    }, n.stroke = {
+      curve: $,
+      width: l === "bar" ? E ? o.map((d) => d ? At : 0) : 0 : 2,
+      ...E ? {
+        lineCap: "round",
+        // Runtime accepts a string dash; the published types say
+        // `number` → one documented cast. `'0 6'` + round cap ⇒ dots.
+        dashArray: o.map(
+          (d) => d ? Pe : 0
+        )
+      } : {}
+    }, n.dataLabels = { enabled: !1 };
+  }
+  if (l === "radialBar" && J) {
+    const r = A.plotOptions ?? {};
+    n.plotOptions = {
+      ...r,
+      radialBar: {
+        ...r.radialBar ?? {},
+        dataLabels: {
+          ...((ee = r.radialBar) == null ? void 0 : ee.dataLabels) ?? {},
+          value: {
+            ...((W = (D = r.radialBar) == null ? void 0 : D.dataLabels) == null ? void 0 : W.value) ?? {},
+            formatter: (d) => J(Number(d))
+          }
+        }
+      }
+    };
+  }
+  if (l === "bar" && P === "horizontal") {
+    const r = A.plotOptions ?? {};
+    n.plotOptions = {
+      ...r,
+      bar: { ...r.bar ?? {}, horizontal: !0 }
+    };
+  }
+  if (de ? n.fill = {
+    type: E ? o.map((r) => r ? "solid" : "pattern") : "pattern",
+    opacity: E ? o.map(
+      (r) => r ? H : l === "area" ? 0.3 : 1
+    ) : l === "area" ? 0.3 : 1,
+    pattern: {
+      style: [...vt],
+      strokeWidth: 2
+    }
+  } : q ? n.fill = {
+    type: "solid",
+    opacity: o.map((r) => r ? H : 1)
+  } : l === "area" && (n.fill = E ? {
+    type: "gradient",
+    opacity: o.map((r) => r ? H : 0.3)
+  } : {
+    type: "gradient",
+    opacity: 0.3
+  }), F) {
+    const r = o.map((O, G) => O ? G : -1).filter((O) => O >= 0), d = () => Ct(Q.current, r), I = () => typeof requestAnimationFrame == "function" ? requestAnimationFrame(d) : d();
+    n.chart = {
+      ...n.chart,
+      events: {
+        ...((te = n.chart) == null ? void 0 : te.events) ?? {},
+        mounted: () => I(),
+        updated: () => I(),
+        animationEnd: () => d()
+      }
+    };
+  }
+  return n;
+}
+function Et(e, s) {
+  var p, c, u;
+  if (!le(s)) return e;
+  const t = (p = e.chart) == null ? void 0 : p.events, i = {
+    ...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
+      }
+    }
+  };
+  return ((c = e.stroke) == null ? void 0 : c.dashArray) !== void 0 ? i : {
+    ...i,
+    stroke: {
+      ...e.stroke,
+      lineCap: s === "bar" ? "square" : "butt",
+      dashArray: 0
+    },
+    legend: {
+      ...e.legend,
+      markers: { ...(u = e.legend) == null ? void 0 : u.markers, fillColors: void 0 }
+    },
+    fill: e.fill ?? { type: "solid", opacity: 0.85 }
+  };
+}
+function V(e) {
+  return St.includes(e);
+}
+function le(e) {
+  return wt.includes(e);
+}
+function kt(e, s) {
+  return V(s) ? [
+    {
+      name: "",
+      data: e
+    }
+  ] : e;
+}
+const Rt = Ge(
+  ({
+    title: e,
+    id: s,
+    type: t,
+    series: i,
+    categories: p,
+    labels: c,
+    height: u,
+    width: y,
+    patterns: v = !1,
+    stacked: k = !1,
+    orientation: l = "vertical",
+    curve: C = "smooth",
+    colors: M,
+    toolbar: L = !1,
+    locale: de,
+    radialValueFormatter: _,
+    valueFormatter: P,
+    switchableTypes: $,
+    onTypeChange: B,
+    density: J,
+    className: Q
+  }, A) => {
+    const { t: o, i18n: E } = je("ui"), q = Ke(), R = x(
+      () => `chart-${q.replace(/[^a-zA-Z0-9-_]/g, "")}`,
+      [q]
+    ), F = `${R}-summary`, H = j(null), [n, X] = z(null), ee = x(
+      () => tt(H, X),
+      []
+    ), D = x(() => ({ current: n }), [n]), [W, te] = z(0);
+    Ze(D), Je(D);
+    const r = de ?? E.language ?? "en", [d, I] = z(() => {
+      try {
+        return _e();
+      } catch {
+        return {};
+      }
+    });
+    ce(() => {
+      if (typeof document > "u") return;
+      let a;
+      const m = new MutationObserver(() => {
+        clearTimeout(a), a = setTimeout(() => {
+          try {
+            I(_e());
+          } catch {
+          }
+        }, 50);
+      });
+      return m.observe(document.documentElement, {
+        attributes: !0,
+        attributeFilter: ["class"]
+      }), () => {
+        clearTimeout(a), m.disconnect();
+      };
+    }, []);
+    const [O, G] = z(
+      () => typeof document > "u" ? 0 : Ne(document.documentElement)
+    );
+    ce(() => {
+      if (!n || !L) return;
+      const a = new ResizeObserver(() => m()), m = () => {
+        const w = n.querySelector(".apexcharts-toolbar");
+        w && a.observe(w), G(
+          Math.max(Ne(n), (w == null ? void 0 : w.offsetHeight) ?? 0)
+        );
+      };
+      m();
+      const b = new MutationObserver(m);
+      for (let w = n.parentElement; w; w = w.parentElement)
+        b.observe(w, { attributes: !0, attributeFilter: ["class"] });
+      const T = new MutationObserver((w) => {
+        w.flatMap((U) => [...U.addedNodes]).some(
+          (U) => U instanceof Element && (U.matches(".apexcharts-toolbar") || U.querySelector(".apexcharts-toolbar"))
+        ) && m();
+      });
+      return T.observe(n, { childList: !0, subtree: !0 }), () => {
+        a.disconnect(), b.disconnect(), T.disconnect();
+      };
+    }, [n, L]), ce(() => {
+      const a = n;
+      if (!a || typeof ResizeObserver > "u") return;
+      const m = new ResizeObserver((b) => {
+        const T = b[0];
+        T && te(Math.floor(T.contentRect.width));
+      });
+      return m.observe(a), () => m.disconnect();
+    }, [n]);
+    const f = x(() => {
+      if (!$ || $.length === 0) return [];
+      const a = $.filter(
+        (b) => Be.includes(b)
+      );
+      if (!Be.includes(t))
+        return [];
+      const m = a.includes(t) ? a : [t, ...a];
+      return [...new Set(m)];
+    }, [$, t]), S = f.length >= 2, [K, me] = z(null), h = S && K && f.includes(K) ? K : t;
+    yt(
+      n,
+      h !== "pie" && h !== "donut"
+    );
+    const pe = V(t), ue = V(h), [re, fe] = z(null), [ye, $e] = z(i);
+    ye !== i && ($e(i), re && fe(null));
+    const be = re && re.base === i && ye === i ? re.next : i, ge = j(i);
+    ge.current = i;
+    const { effectiveSeries: N, effectiveCategories: ae, effectiveLabels: ne } = x(
+      () => ze(
+        be,
+        p,
+        c,
+        pe,
+        ue,
+        o("chart.table.value")
+      ),
+      [be, p, c, pe, ue, o]
+    ), ve = (a) => ze(
+      a,
+      p,
+      c,
+      pe,
+      ue,
+      o("chart.table.value")
+    ), we = j(ve);
+    we.current = ve;
+    const Se = j(Promise.resolve()), he = x(
+      () => ({
+        async dataURI() {
+          await Se.current;
+          const a = Le.getChartByID(R);
+          return a ? (await a.dataURI()).imgURI : "";
+        },
+        updateSeries(a) {
+          fe({ base: ge.current, next: a });
+          const m = Le.getChartByID(R);
+          if (!m) return;
+          const b = we.current(a), T = { ...Re.current, ...b };
+          Se.current = m.updateOptions(
+            {
+              ...Et(
+                Me(T),
+                T.effectiveType
+              ),
+              series: b.effectiveSeries
+            },
+            !1,
+            !0
+          ).catch(() => {
+          });
+        },
+        setType(a) {
+          return !S || !f.includes(a) ? !1 : (me(a), !0);
+        },
+        getTypeState() {
+          return {
+            declaredType: t,
+            effectiveType: h,
+            availableTypes: S ? [...f] : []
+          };
+        }
+      }),
+      [R, t, h, S, f]
+    );
+    Ue(A, () => he, [he]), rt(bt, he, s);
+    const xe = typeof document < "u" && document.documentElement.dir === "rtl", Te = x(
+      () => kt(N, h),
+      [N, h]
+    ), Ae = x(
+      () => new Intl.NumberFormat(r),
+      [r]
+    ), oe = x(
+      () => P ?? ((a) => Ae.format(a)),
+      [P, Ae]
+    ), Ce = x(
+      () => ({
+        name: r,
+        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")
+          }
+        }
+      }),
+      [r, o]
+    ), Ee = et(), ke = o("chart.noData"), se = x(
+      () => ({
+        themeOptions: d,
+        toolbarBand: O,
+        chartId: R,
+        toolbar: L,
+        reducedMotion: Ee,
+        toolbarLocale: Ce,
+        locale: r,
+        effectiveLabels: ne,
+        formatValue: oe,
+        noDataText: ke,
+        effectiveType: h,
+        effectiveSeries: N,
+        effectiveCategories: ae,
+        isRtl: xe,
+        patterns: v,
+        stacked: k,
+        orientation: l,
+        curve: C,
+        colors: M,
+        radialValueFormatter: _,
+        wrapperRef: H
+      }),
+      [
+        d,
+        O,
+        R,
+        L,
+        Ee,
+        Ce,
+        r,
+        ne,
+        oe,
+        ke,
+        h,
+        N,
+        ae,
+        xe,
+        v,
+        k,
+        l,
+        C,
+        M,
+        _
+      ]
+    ), qe = x(
+      () => Me(se),
+      [se]
+    ), Re = j(se);
+    Re.current = se;
+    const He = y ?? (W > 0 ? W : "100%"), Fe = u ?? 320, De = x(() => {
+      const a = V(h) ? ne ?? [] : ae ?? [], m = Te;
+      return /* @__PURE__ */ Y("table", { id: F, className: "ds:sr-only", children: [
+        /* @__PURE__ */ g("caption", { children: e }),
+        /* @__PURE__ */ g("thead", { children: /* @__PURE__ */ Y("tr", { children: [
+          /* @__PURE__ */ g("th", { scope: "col", children: o("chart.table.series") }),
+          a.map((b, T) => /* @__PURE__ */ g("th", { scope: "col", children: b }, `${b}-${T}`))
+        ] }) }),
+        /* @__PURE__ */ g("tbody", { children: m.map((b, T) => /* @__PURE__ */ Y("tr", { children: [
+          /* @__PURE__ */ g("th", { scope: "row", children: b.name || o("chart.table.value") }),
+          b.data.map((w, Oe) => /* @__PURE__ */ g("td", { children: h === "radialBar" && _ ? _(w) : oe(w) }, `${T}-${Oe}`))
+        ] }, `${b.name}-${T}`)) })
+      ] });
+    }, [
+      h,
+      Te,
+      ne,
+      ae,
+      F,
+      e,
+      o,
+      oe,
+      _
+    ]), We = x(() => (V(h), N), [N, h]), Ie = /* @__PURE__ */ Y(
+      "div",
+      {
+        ref: ee,
+        role: "figure",
+        "aria-label": e,
+        "aria-describedby": F,
+        className: gt({
+          // Explicit height wins over the density min-height unless the
+          // caller also asked for a density explicitly.
+          density: J ?? (u !== void 0 ? "none" : void 0),
+          className: S ? void 0 : Q
+        }),
+        ...S ? {} : { "data-component": "chart", "data-component-id": s },
+        children: [
+          De,
+          /* @__PURE__ */ g(
+            Ve,
+            {
+              type: h,
+              series: We,
+              options: qe,
+              width: He,
+              height: Fe
+            },
+            h
+          )
+        ]
+      }
+    );
+    return S ? /* @__PURE__ */ Y(
+      "div",
+      {
+        "data-component": "chart",
+        "data-component-id": s,
+        className: `ds:block ds:w-full ${Q ?? ""}`.trim(),
+        children: [
+          /* @__PURE__ */ g("div", { className: "ds:mb-[var(--spacing-xs)] ds:flex ds:justify-end", children: /* @__PURE__ */ g(
+            nt,
+            {
+              role: "radiogroup",
+              mode: "toggle-single",
+              size: "sm",
+              "aria-label": o("chart.typeSwitcher.label"),
+              value: h,
+              onValueChange: (a) => {
+                a !== h && (me(a), B == null || B(a));
+              },
+              children: f.map((a) => /* @__PURE__ */ g(
+                at,
+                {
+                  value: a,
+                  type: "button",
+                  icon: Tt[a],
+                  "aria-label": o(xt[a])
+                },
+                a
+              ))
+            }
+          ) }),
+          Ie
+        ]
+      }
+    ) : Ie;
+  }
+);
+Rt.displayName = "Chart";
+export {
+  Rt as C,
+  gt as a,
+  bt as c
+};
+//# sourceMappingURL=chart-HsF1KHbx.js.map