@alfadocs/ui-kit-debug 1.55.0 → 1.57.0

package/dist/_chunks/chart-DQ5GxqgT.js

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