@alfadocs/ui-kit 0.82.0 → 0.84.0

package/dist/_chunks/{actions-cell-renderer-DLrcSTK_.js → actions-cell-renderer-DaL80uqL.js}

@@ -6,7 +6,7 @@ import { c as ot } from "./index-D2ZczOXr.js";
 import { useTranslation as w } from "react-i18next";
 import { useGridFilter as it, AgGridReact as st } from "ag-grid-react";
 import { ModuleRegistry as lt, AllCommunityModule as dt } from "ag-grid-community";
-import { I as we } from "./icon-button-group-C_lqXTAj.js";
+import { I as we } from "./icon-button-group-BLHPN6jg.js";
 import { B as J } from "./button-CPGiR_bH.js";
 import { I as q } from "./icon-button-C_kbcd7I.js";
 import { P as Z } from "./popover-Cc0a69sw.js";
@@ -1543,4 +1543,4 @@ export {
   _t as e,
   Ae as f
 };
-//# sourceMappingURL=actions-cell-renderer-DLrcSTK_.js.map
+//# sourceMappingURL=actions-cell-renderer-DaL80uqL.js.map

package/dist/_chunks/chart-GFLv4cXm.js

@@ -0,0 +1,609 @@
+import { jsxs as w, jsx as c } from "react/jsx-runtime";
+import { forwardRef as be, useId as ve, useMemo as d, useRef as ge, useState as H, useEffect as ee, useImperativeHandle as Te } from "react";
+import { c as Se } from "./index-D2ZczOXr.js";
+import { useTranslation as we } from "react-i18next";
+import Ie from "react-apexcharts";
+import te from "apexcharts";
+import { u as Ce, g as ae } from "./apexcharts-theme-BJigns_V.js";
+import { u as ke } from "./use-prefers-reduced-motion-BMwIQRjB.js";
+import { u as Re } from "./registry-DvAUVLHh.js";
+import { I as _e } from "./icon-button-C_kbcd7I.js";
+import { I as Le } from "./icon-button-group-BLHPN6jg.js";
+import { c as I } 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 xe = [
+  ["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"
+    }
+  ]
+], Ee = I("chart-area", xe);
+/**
+ * @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 Ne = [
+  ["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" }]
+], Ae = I("chart-column", Ne);
+/**
+ * @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 Pe = [
+  ["path", { d: "M3 3v16a2 2 0 0 0 2 2h16", key: "c24i48" }],
+  ["path", { d: "m19 9-5 5-4-4-3 3", key: "2osh9i" }]
+], ze = I("chart-line", Pe);
+/**
+ * @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 Be = [
+  [
+    "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" }]
+], Me = I("chart-pie", Be);
+/**
+ * @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 Oe = [
+  [
+    "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" }]
+], $e = I("donut", Oe), He = {
+  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: (a) => a.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: (a) => a.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: (a) => a.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: (a, h) => a.setType(h.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" } }
+                  },
+                  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 write targets the live instance only: a later type switch re-reads the original props and discards it.",
+      invoke: (a, h) => {
+        a.updateSeries(h.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.",
+      invoke: (a) => a.dataURI()
+    }
+  },
+  domHooks: {
+    root: { attr: "data-component", value: "chart" },
+    instanceId: {
+      attr: "data-component-id",
+      sourceProp: "id",
+      description: "Sourced from the id prop."
+    }
+  }
+}, Ge = Se("ds:relative ds:block ds:w-full", {
+  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" }
+}), je = [
+  "verticalLines",
+  "horizontalLines",
+  "slantedLines",
+  "squares",
+  "circles"
+], De = ["line", "bar", "area"], Ke = ["pie", "donut", "radialBar"], re = [
+  "line",
+  "bar",
+  "area",
+  "pie",
+  "donut"
+], Ue = {
+  line: "chart.typeSwitcher.line",
+  bar: "chart.typeSwitcher.bar",
+  area: "chart.typeSwitcher.area",
+  pie: "chart.typeSwitcher.pie",
+  donut: "chart.typeSwitcher.donut"
+}, Ve = {
+  line: /* @__PURE__ */ c(ze, {}),
+  bar: /* @__PURE__ */ c(Ae, {}),
+  area: /* @__PURE__ */ c(Ee, {}),
+  pie: /* @__PURE__ */ c(Me, {}),
+  donut: /* @__PURE__ */ c($e, {})
+};
+function f(a) {
+  return Ke.includes(a);
+}
+function We(a) {
+  return De.includes(a);
+}
+function Ye(a, h) {
+  return f(h) ? [
+    {
+      name: "",
+      data: a
+    }
+  ] : a;
+}
+const qe = be(
+  ({
+    title: a,
+    id: h,
+    type: l,
+    series: C,
+    categories: G,
+    labels: L,
+    height: j,
+    width: oe,
+    patterns: D = !1,
+    colors: k,
+    toolbar: x = !1,
+    locale: ie,
+    radialValueFormatter: m,
+    valueFormatter: K,
+    switchableTypes: R,
+    onTypeChange: E,
+    density: ne,
+    className: U
+  }, se) => {
+    const { t: r, i18n: ce } = we(), V = ve(), y = d(
+      () => `chart-${V.replace(/[^a-zA-Z0-9-_]/g, "")}`,
+      [V]
+    ), N = `${y}-summary`, A = ge(null), [W, de] = H(0);
+    Ce(A);
+    const b = ie ?? ce.language ?? "en", [Y, le] = H(
+      () => {
+        try {
+          return ae();
+        } catch {
+          return {};
+        }
+      }
+    );
+    ee(() => {
+      if (typeof document > "u") return;
+      let e;
+      const t = new MutationObserver(() => {
+        clearTimeout(e), e = setTimeout(() => {
+          try {
+            le(ae());
+          } catch {
+          }
+        }, 50);
+      });
+      return t.observe(document.documentElement, {
+        attributes: !0,
+        attributeFilter: ["class"]
+      }), () => {
+        clearTimeout(e), t.disconnect();
+      };
+    }, []), ee(() => {
+      const e = A.current;
+      if (!e || typeof ResizeObserver > "u") return;
+      const t = new ResizeObserver((i) => {
+        const n = i[0];
+        n && de(Math.floor(n.contentRect.width));
+      });
+      return t.observe(e), () => t.disconnect();
+    }, []);
+    const v = d(() => {
+      if (!R || R.length === 0) return [];
+      const e = R.filter(
+        (i) => re.includes(i)
+      );
+      if (!re.includes(l))
+        return [];
+      const t = e.includes(l) ? e : [l, ...e];
+      return [...new Set(t)];
+    }, [R, l]), u = v.length >= 2, [P, q] = H(null), o = u && P && v.includes(P) ? P : l, z = f(l), Z = f(o), { effectiveSeries: g, effectiveCategories: _, effectiveLabels: T } = d(() => {
+      if (z === Z)
+        return {
+          effectiveSeries: C,
+          effectiveCategories: G,
+          effectiveLabels: L
+        };
+      if (!z) {
+        const t = C;
+        return {
+          effectiveSeries: t.map(
+            (n) => n.data.reduce((p, s) => p + s, 0)
+          ),
+          effectiveCategories: void 0,
+          effectiveLabels: t.map((n) => n.name)
+        };
+      }
+      const e = C;
+      return {
+        effectiveSeries: [
+          { name: r("chart.table.value"), data: e }
+        ],
+        effectiveCategories: L ?? [],
+        effectiveLabels: void 0
+      };
+    }, [C, G, L, z, Z, r]), B = d(
+      () => ({
+        async dataURI() {
+          const e = te.getChartByID(y);
+          return e ? (await e.dataURI()).imgURI : "";
+        },
+        updateSeries(e) {
+          const t = te.getChartByID(y);
+          if (!t) return;
+          const i = f(l), n = f(o);
+          if (i === n) {
+            t.updateSeries(e);
+            return;
+          }
+          if (!i) {
+            const p = e;
+            t.updateOptions(
+              { labels: p.map((s) => s.name) },
+              !1,
+              !0
+            ), t.updateSeries(
+              p.map((s) => s.data.reduce(($, ye) => $ + ye, 0))
+            );
+            return;
+          }
+          t.updateSeries([
+            { name: r("chart.table.value"), data: e }
+          ]);
+        },
+        setType(e) {
+          return !u || !v.includes(e) ? !1 : (q(e), !0);
+        },
+        getTypeState() {
+          return {
+            declaredType: l,
+            effectiveType: o,
+            availableTypes: u ? [...v] : []
+          };
+        }
+      }),
+      [y, l, o, r, u, v]
+    );
+    Te(se, () => B, [B]), Re(He, B, h);
+    const M = typeof document < "u" && document.documentElement.dir === "rtl", F = d(
+      () => Ye(g, o),
+      [g, o]
+    ), J = d(
+      () => new Intl.NumberFormat(b),
+      [b]
+    ), S = d(
+      () => K ?? ((e) => J.format(e)),
+      [K, J]
+    ), Q = d(
+      () => ({
+        name: b,
+        options: {
+          toolbar: {
+            download: r("chart.toolbar.download"),
+            selection: r("chart.toolbar.selection"),
+            selectionZoom: r("chart.toolbar.selectionZoom"),
+            zoomIn: r("chart.toolbar.zoomIn"),
+            zoomOut: r("chart.toolbar.zoomOut"),
+            pan: r("chart.toolbar.pan"),
+            reset: r("chart.toolbar.reset"),
+            exportToSVG: r("chart.toolbar.exportToSVG"),
+            exportToPNG: r("chart.toolbar.exportToPNG"),
+            exportToCSV: r("chart.toolbar.exportToCSV")
+          }
+        }
+      }),
+      [b, r]
+    ), O = ke(), pe = d(() => {
+      var i, n, p;
+      const e = Y, t = {
+        ...e,
+        chart: {
+          ...e.chart,
+          id: y,
+          toolbar: { show: x },
+          zoom: { enabled: x },
+          animations: {
+            enabled: !O,
+            dynamicAnimation: { enabled: !O }
+          },
+          locales: [Q],
+          defaultLocale: b,
+          parentHeightOffset: 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.
+        ...T ? { labels: T } : {},
+        legend: {
+          ...e.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: M ? "right" : "left",
+          fontFamily: "inherit"
+        },
+        tooltip: {
+          ...e.tooltip,
+          y: {
+            formatter: (s) => S(s)
+          }
+        },
+        noData: {
+          text: r("chart.noData")
+        }
+      };
+      if (k && k.length > 0 && (t.colors = k), We(o) && (t.xaxis = {
+        ...e.xaxis,
+        categories: _ ?? []
+      }, t.yaxis = {
+        ...e.yaxis,
+        opposite: M,
+        labels: {
+          formatter: (s) => S(s)
+        }
+      }, t.stroke = {
+        curve: "smooth",
+        width: o === "bar" ? 0 : 2
+      }, t.dataLabels = { enabled: !1 }), o === "radialBar" && m) {
+        const s = e.plotOptions ?? {};
+        t.plotOptions = {
+          ...s,
+          radialBar: {
+            ...s.radialBar ?? {},
+            dataLabels: {
+              ...((i = s.radialBar) == null ? void 0 : i.dataLabels) ?? {},
+              value: {
+                ...((p = (n = s.radialBar) == null ? void 0 : n.dataLabels) == null ? void 0 : p.value) ?? {},
+                formatter: ($) => m(Number($))
+              }
+            }
+          }
+        };
+      }
+      return D ? t.fill = {
+        type: "pattern",
+        opacity: o === "area" ? 0.3 : 1,
+        pattern: {
+          style: [...je],
+          strokeWidth: 2
+        }
+      } : o === "area" && (t.fill = {
+        type: "gradient",
+        opacity: 0.3
+      }), t;
+    }, [
+      Y,
+      y,
+      x,
+      O,
+      Q,
+      b,
+      T,
+      S,
+      r,
+      o,
+      _,
+      M,
+      D,
+      k,
+      m
+    ]), he = oe ?? (W > 0 ? W : "100%"), ue = j ?? 320, fe = d(() => {
+      const e = f(o) ? T ?? [] : _ ?? [], t = F;
+      return /* @__PURE__ */ w("table", { id: N, className: "ds:sr-only", children: [
+        /* @__PURE__ */ c("caption", { children: a }),
+        /* @__PURE__ */ c("thead", { children: /* @__PURE__ */ w("tr", { children: [
+          /* @__PURE__ */ c("th", { scope: "col", children: r("chart.table.series") }),
+          e.map((i, n) => /* @__PURE__ */ c("th", { scope: "col", children: i }, `${i}-${n}`))
+        ] }) }),
+        /* @__PURE__ */ c("tbody", { children: t.map((i, n) => /* @__PURE__ */ w("tr", { children: [
+          /* @__PURE__ */ c("th", { scope: "row", children: i.name || r("chart.table.value") }),
+          i.data.map((p, s) => /* @__PURE__ */ c("td", { children: o === "radialBar" && m ? m(p) : S(p) }, `${n}-${s}`))
+        ] }, `${i.name}-${n}`)) })
+      ] });
+    }, [
+      o,
+      F,
+      T,
+      _,
+      N,
+      a,
+      r,
+      S,
+      m
+    ]), me = d(() => (f(o), g), [g, o]), X = /* @__PURE__ */ w(
+      "div",
+      {
+        ref: A,
+        role: "img",
+        "aria-label": a,
+        "aria-describedby": N,
+        className: Ge({
+          // Explicit height wins over the density min-height unless the
+          // caller also asked for a density explicitly.
+          density: ne ?? (j !== void 0 ? "none" : void 0),
+          className: u ? void 0 : U
+        }),
+        ...u ? {} : { "data-component": "chart", "data-component-id": h },
+        children: [
+          fe,
+          /* @__PURE__ */ c(
+            Ie,
+            {
+              type: o,
+              series: me,
+              options: pe,
+              width: he,
+              height: ue,
+              "aria-hidden": "true"
+            },
+            o
+          )
+        ]
+      }
+    );
+    return u ? /* @__PURE__ */ w(
+      "div",
+      {
+        "data-component": "chart",
+        "data-component-id": h,
+        className: `ds:block ds:w-full ${U ?? ""}`.trim(),
+        children: [
+          /* @__PURE__ */ c("div", { className: "ds:mb-[var(--spacing-xs)] ds:flex ds:justify-end", children: /* @__PURE__ */ c(
+            Le,
+            {
+              role: "radiogroup",
+              mode: "toggle-single",
+              size: "sm",
+              "aria-label": r("chart.typeSwitcher.label"),
+              value: o,
+              onValueChange: (e) => {
+                e !== o && (q(e), E == null || E(e));
+              },
+              children: v.map((e) => /* @__PURE__ */ c(
+                _e,
+                {
+                  value: e,
+                  type: "button",
+                  icon: Ve[e],
+                  "aria-label": r(Ue[e])
+                },
+                e
+              ))
+            }
+          ) }),
+          X
+        ]
+      }
+    ) : X;
+  }
+);
+qe.displayName = "Chart";
+export {
+  qe as C,
+  Ge as a,
+  He as c
+};
+//# sourceMappingURL=chart-GFLv4cXm.js.map