@alfadocs/ui-kit 0.83.0 → 0.84.1

package/dist/_chunks/dashboard-grid-D2dm0IRN.js

@@ -0,0 +1,691 @@
+import { jsxs as _, jsx as w } from "react/jsx-runtime";
+import { forwardRef as Te, useRef as S, useMemo as L, useState as O, useCallback as D, useEffect as X, useImperativeHandle as We, useContext as $e, Children as Ie, isValidElement as Ae, Fragment as je, createContext as Fe } from "react";
+import { c as Ge } from "./index-D2ZczOXr.js";
+import { useTranslation as ke } from "react-i18next";
+import { I as re } from "./icon-button-C_kbcd7I.js";
+import { u as U } from "./use-isomorphic-layout-effect-BGfaCOP1.js";
+import { u as Ke } from "./registry-DvAUVLHh.js";
+import { P as _e } from "./plus-DzMQ_c6b.js";
+import { G as Ve } from "./grip-vertical-onSb1JXO.js";
+import { X as Be } from "./x-B5YnXwCz.js";
+import { c as He } 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 Ye = [
+  ["path", { d: "M19 13v6h-6", key: "1hxl6d" }],
+  ["path", { d: "M5 11V5h6", key: "12e2xe" }],
+  ["path", { d: "m5 5 14 14", key: "11anup" }]
+], qe = He("move-diagonal-2", Ye), Oe = {
+  id: "dashboard-grid",
+  // The board's whole purpose is in-place rearrangement of its widgets.
+  capabilities: ["edit_inline"],
+  state: {
+    layout: {
+      type: "{ id: string, x: number, y: number, w: number, h: number }[]",
+      descriptionKey: "ui.agent.dashboardGrid.state.layout",
+      description: "Current widget geometry in cell units — ids and rectangles only, no widget content.",
+      read: (t) => t.getGridState().layout
+    },
+    cols: {
+      type: "number",
+      descriptionKey: "ui.agent.dashboardGrid.state.cols",
+      description: "Logical column count of the board.",
+      read: (t) => t.getGridState().cols
+    },
+    editing: {
+      type: "boolean",
+      descriptionKey: "ui.agent.dashboardGrid.state.editing",
+      description: "Whether edit mode is on. Move/resize actions are refused while it is off — the host app owns the toggle.",
+      read: (t) => t.getGridState().editing
+    }
+  },
+  actions: {
+    move_widget: {
+      // Rearranging the board mutates user configuration — a write,
+      // reversible by moving back.
+      safety: "write",
+      argsType: "id, x, y",
+      argsSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Widget id (see layout state)." },
+          x: {
+            type: "integer",
+            minimum: 0,
+            description: "0-based logical column."
+          },
+          y: { type: "integer", minimum: 0, description: "0-based row." }
+        },
+        required: ["id", "x", "y"]
+      },
+      returns: "boolean (accepted)",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when applied; false when edit mode is off or the id is unknown."
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.dashboardGrid.actions.moveWidget",
+      description: "Move a widget to a cell. Out-of-bounds targets are clamped; colliding widgets are pushed down and the layout re-compacts. Refused while edit mode is off.",
+      invoke: (t, s) => t.moveWidgetTo(s.id, s.x, s.y)
+    },
+    resize_widget: {
+      safety: "write",
+      argsType: "id, w, h",
+      argsSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Widget id (see layout state)." },
+          w: {
+            type: "integer",
+            minimum: 1,
+            description: "Column span (≥ 1)."
+          },
+          h: { type: "integer", minimum: 1, description: "Row span (≥ 1)." }
+        },
+        required: ["id", "w", "h"]
+      },
+      returns: "boolean (accepted)",
+      returnsSchema: {
+        type: "boolean",
+        description: "True when applied; false when edit mode is off or the id is unknown."
+      },
+      idempotent: !0,
+      descriptionKey: "ui.agent.dashboardGrid.actions.resizeWidget",
+      description: "Resize a widget to a span. Clamped to the grid and the widget’s min/max; colliding widgets are pushed down. Refused while edit mode is off.",
+      invoke: (t, s) => t.resizeWidgetTo(s.id, s.w, s.h)
+    }
+  },
+  domHooks: {
+    root: { attr: "data-component", value: "dashboard-grid" },
+    instanceId: {
+      attr: "data-component-id",
+      sourceProp: "id",
+      description: "Sourced from the id prop."
+    },
+    item: {
+      attr: "data-widget-id",
+      description: "Each widget wrapper carries its layout id."
+    }
+  }
+};
+function A(t, s) {
+  return t.x < s.x + s.w && s.x < t.x + t.w && t.y < s.y + s.h && s.y < t.y + t.h;
+}
+function J(t, s) {
+  const n = Math.max(1, t.minW ?? 1), g = Math.max(1, t.minH ?? 1), f = Math.min(s, t.maxW ?? s), c = t.maxH ?? Number.POSITIVE_INFINITY, l = Math.min(Math.max(t.w, n), f), a = Math.min(Math.max(t.h, g), c), i = Math.min(Math.max(0, t.x), s - l), m = Math.max(0, t.y);
+  return { ...t, x: i, y: m, w: l, h: a };
+}
+function T(t, s, n) {
+  const g = t.map((i) => J(i, s)), f = [...g].sort((i, m) => i.id === n ? -1 : m.id === n ? 1 : i.y - m.y || i.x - m.x), c = [], l = n ? g.find((i) => i.id === n) : void 0;
+  for (const i of f) {
+    if (i.id !== n) {
+      if (l && A(l, i)) {
+        const m = { ...i, y: Math.max(0, l.y - i.h) };
+        !A(l, m) && !c.some((y) => y.id !== n && A(y, m)) && (i.y = m.y);
+      }
+      for (; c.some((m) => A(m, i)); )
+        i.y += 1;
+      for (; i.y > 0; ) {
+        const m = { ...i, y: i.y - 1 };
+        if (c.some((y) => A(y, m))) break;
+        i.y -= 1;
+      }
+    }
+    c.push(i);
+  }
+  const a = new Map(c.map((i) => [i.id, i]));
+  return t.map((i) => a.get(i.id));
+}
+function te(t, s, n, g, f) {
+  const c = t.map(
+    (l) => l.id === s ? J({ ...l, x: n, y: g }, f) : l
+  );
+  return T(c, f, s);
+}
+function ne(t, s, n, g, f) {
+  const c = t.map(
+    (l) => l.id === s ? (
+      // Resizing never moves the widget: the width clamps to the space
+      // between its position and the grid edge (clampRect would slide it).
+      // minW wins over the edge clamp so clampRect cannot re-raise w and
+      // slide x as a side effect.
+      J(
+        {
+          ...l,
+          w: Math.max(l.minW ?? 1, Math.min(n, f - l.x)),
+          h: g
+        },
+        f
+      )
+    ) : l
+  );
+  return T(c, f, s);
+}
+function xe(t, s, n, g) {
+  const f = Math.min(Math.max(1, n), s), c = t.reduce((l, a) => Math.max(l, a.y + a.h), 0);
+  for (let l = 0; l <= c; l += 1)
+    for (let a = 0; a <= s - f; a += 1) {
+      const i = {
+        x: a,
+        y: l,
+        w: f,
+        h: g
+      };
+      if (!t.some((m) => A(m, i)))
+        return { x: a, y: l };
+    }
+  return { x: 0, y: c };
+}
+function Xe(t) {
+  return t.reduce((s, n) => Math.max(s, n.y + n.h), 0);
+}
+const Ue = Ge(
+  [
+    "ds:grid ds:w-full",
+    "ds:gap-[var(--spacing-md)]",
+    "ds:[grid-template-columns:repeat(var(--dg-cols),minmax(0,1fr))]",
+    "ds:[grid-auto-rows:var(--dg-row)]",
+    // Edit-mode surface: tint the whole plane, draw faint cell lines, and
+    // reserve spare rows (--dg-min-block) so the AVAILABLE space reads at
+    // a glance instead of the board ending at the last occupied row.
+    "ds:data-[editing=true]:rounded-[var(--radius-lg)] ds:data-[editing=true]:bg-muted/10",
+    "ds:data-[editing=true]:[background-image:var(--dg-grid-lines)]",
+    "ds:data-[editing=true]:min-h-[var(--dg-min-block)]"
+  ].join(" "),
+  { variants: {}, defaultVariants: {} }
+), Je = Ge(
+  [
+    "ds:relative ds:flex ds:min-h-0 ds:min-w-0 ds:flex-col ds:overflow-hidden",
+    // Mirror of Card variant="elevated" so widgets read as kit cards.
+    "ds:rounded-[var(--radius-lg)] ds:bg-[var(--card)] ds:text-[var(--card-foreground)]",
+    "ds:border ds:border-[color:var(--card-border)] ds:shadow-[var(--shadow-card)] ds:[.theme-accessible_&]:border-2",
+    "ds:[grid-column-start:var(--dg-x)] ds:[grid-column-end:span_var(--dg-w)]",
+    "ds:[grid-row-start:var(--dg-y)] ds:[grid-row-end:span_var(--dg-h)]",
+    // Grabbed feedback (keyboard or pointer drag in flight).
+    "ds:data-[grabbed=true]:ring-[length:var(--focus-ring-width)] ds:data-[grabbed=true]:ring-ring ds:data-[grabbed=true]:z-10"
+  ].join(" "),
+  { variants: {}, defaultVariants: {} }
+), Me = Fe(
+  null
+);
+function oe(t, s) {
+  Ie.forEach(t, (n) => {
+    if (Ae(n)) {
+      if (n.type === je) {
+        oe(
+          n.props.children,
+          s
+        );
+        return;
+      }
+      s(n);
+    }
+  });
+}
+function Se({
+  id: t,
+  title: s,
+  actionsSlot: n,
+  children: g
+}) {
+  var y, V, B;
+  const { t: f } = ke(), c = $e(Me), l = S(null), a = c == null ? void 0 : c.layoutById.get(t);
+  if (U(() => {
+    const p = l.current;
+    !p || !a || (p.style.setProperty("--dg-x", String(a.x + 1)), p.style.setProperty("--dg-y", String(a.y + 1)), p.style.setProperty("--dg-w", String(a.w)), p.style.setProperty("--dg-h", String(a.h)));
+  }, [a == null ? void 0 : a.x, a == null ? void 0 : a.y, a == null ? void 0 : a.w, a == null ? void 0 : a.h, a]), !c || !a) return null;
+  const i = ((y = c.grab) == null ? void 0 : y.id) === t, m = c.editing;
+  return /* @__PURE__ */ _(
+    "div",
+    {
+      ref: l,
+      role: "listitem",
+      "aria-label": s,
+      "data-component": "dashboard-grid-widget",
+      "data-widget-id": t,
+      "data-grabbed": i || void 0,
+      className: Je(),
+      children: [
+        /* @__PURE__ */ _("div", { className: "ds:flex ds:items-center ds:gap-[var(--spacing-xs)] ds:ps-[var(--spacing-sm)] ds:pe-[var(--spacing-sm)] ds:pt-[var(--spacing-sm)]", children: [
+          m ? /* @__PURE__ */ w(
+            re,
+            {
+              size: "sm",
+              intent: "outline",
+              type: "button",
+              icon: /* @__PURE__ */ w(Ve, {}),
+              "aria-label": f("dashboardGrid.move", { title: s }),
+              "aria-pressed": i && ((V = c.grab) == null ? void 0 : V.kind) === "move",
+              className: "ds:cursor-grab ds:touch-none ds:bg-[var(--card)]",
+              onPointerDown: (p) => c.startPointerGrab("move", t, p),
+              onKeyDown: (p) => c.keyboardStep(p, t),
+              onClick: () => c.startKeyboardGrab("move", t)
+            }
+          ) : null,
+          /* @__PURE__ */ w("span", { className: "ds:min-w-0 ds:flex-1 ds:truncate ds:text-sm ds:font-medium", children: s }),
+          n,
+          m && c.canRemove ? /* @__PURE__ */ w(
+            re,
+            {
+              size: "sm",
+              intent: "outline",
+              type: "button",
+              icon: /* @__PURE__ */ w(Be, {}),
+              className: "ds:bg-[var(--card)]",
+              "aria-label": f("dashboardGrid.remove", { title: s }),
+              onClick: () => c.requestRemove(t)
+            }
+          ) : null
+        ] }),
+        /* @__PURE__ */ w("div", { className: "ds:min-h-0 ds:flex-1 ds:overflow-hidden ds:ps-[var(--spacing-md)] ds:pe-[var(--spacing-md)] ds:pb-[var(--spacing-md)] ds:pt-[var(--spacing-xs)]", children: g }),
+        m ? /* @__PURE__ */ w("span", { className: "ds:absolute ds:bottom-[var(--spacing-sm)] ds:end-[var(--spacing-sm)]", children: /* @__PURE__ */ w(
+          re,
+          {
+            size: "sm",
+            intent: "outline",
+            type: "button",
+            icon: /* @__PURE__ */ w(qe, {}),
+            flipIconInRtl: !0,
+            "aria-label": f("dashboardGrid.resize", { title: s }),
+            "aria-pressed": i && ((B = c.grab) == null ? void 0 : B.kind) === "resize",
+            className: "ds:touch-none ds:bg-[var(--card)]",
+            onPointerDown: (p) => c.startPointerGrab("resize", t, p),
+            onKeyDown: (p) => c.keyboardStep(p, t),
+            onClick: () => c.startKeyboardGrab("resize", t)
+          }
+        ) }) : null
+      ]
+    }
+  );
+}
+Se.displayName = "DashboardGrid.Widget";
+const Ne = Te(
+  ({
+    "aria-label": t,
+    id: s,
+    cols: n = 12,
+    rowHeight: g = 96,
+    layout: f,
+    defaultLayout: c,
+    onLayoutChange: l,
+    editing: a = !1,
+    onRemoveWidget: i,
+    onRequestAdd: m,
+    children: y,
+    className: V
+  }, B) => {
+    const { t: p } = ke(), N = S(null), ae = L(() => {
+      const e = [];
+      return oe(y, (r) => {
+        r.props.id && e.push(r.props.id);
+      }), e;
+    }, [y]), se = L(() => {
+      const e = /* @__PURE__ */ new Map();
+      return oe(y, (r) => {
+        r.props.id && e.set(r.props.id, {
+          defaultW: r.props.defaultW ?? 4,
+          defaultH: r.props.defaultH ?? 2
+        });
+      }), e;
+    }, [y]), [Pe, De] = O(() => c ?? []), ie = f ?? Pe, P = D(
+      (e) => {
+        f === void 0 && De(e), l == null || l(e);
+      },
+      [f, l]
+    ), { resolved: v, autoPlaced: de } = L(() => {
+      const e = ie.map((u) => J(u, n)), r = ae.filter(
+        (u) => !e.some((d) => d.id === u)
+      );
+      if (r.length === 0)
+        return { resolved: e, autoPlaced: !1 };
+      const o = [...e];
+      for (const u of r) {
+        const d = se.get(u) ?? { defaultW: 4, defaultH: 2 }, b = Math.min(d.defaultW, n), h = xe(o, n, b, d.defaultH);
+        o.push({ id: u, x: h.x, y: h.y, w: b, h: d.defaultH });
+      }
+      return { resolved: T(o, n), autoPlaced: !0 };
+    }, [ie, ae, se, n]), ce = S("");
+    X(() => {
+      if (!de) return;
+      const e = v.map(
+        (r) => `${r.id}:${r.x},${r.y},${r.w},${r.h}`
+      ).join("|");
+      ce.current !== e && (ce.current = e, P(v));
+    }, [de, v, P]);
+    const [Re, Ce] = O(null), [k, ue] = O(null), [Ee, W] = O(""), Q = S(null), C = S(null), j = S(null), H = S(!1), F = S(n);
+    F.current = n;
+    const $ = S(v);
+    $.current = v;
+    const R = D((e) => {
+      Q.current = e, Ce(e);
+    }, []), Y = D(
+      (e, r, o) => {
+        const u = { kind: e, id: r, via: o };
+        C.current = { ...u, baseLayout: $.current }, ue(u), R($.current);
+      },
+      [R]
+    ), K = Re ?? v, le = L(
+      () => new Map(K.map((e) => [e.id, e])),
+      [K]
+    ), pe = D(
+      (e, r) => {
+        W(
+          e === "move" ? p("dashboardGrid.movedTo", { col: r.x + 1, row: r.y + 1 }) : p("dashboardGrid.resizedTo", { cols: r.w, rows: r.h })
+        );
+      },
+      [p]
+    ), x = D(
+      (e) => {
+        const r = Q.current, o = C.current;
+        if (C.current = null, j.current = null, ue(null), R(null), !e || !r || !o) {
+          W(p("dashboardGrid.cancelled"));
+          return;
+        }
+        const u = T(r, F.current), d = (h) => h.map((G) => `${G.id}:${G.x},${G.y},${G.w},${G.h}`).join("|");
+        if (d(u) === d($.current)) {
+          W(p("dashboardGrid.cancelled"));
+          return;
+        }
+        P(u);
+        const b = u.find((h) => h.id === o.id);
+        W(
+          b ? p("dashboardGrid.droppedAt", {
+            col: b.x + 1,
+            row: b.y + 1
+          }) : p("dashboardGrid.cancelled")
+        );
+      },
+      [R, P, p]
+    ), me = D(
+      (e, r) => {
+        if (!a) return;
+        if (H.current) {
+          H.current = !1;
+          return;
+        }
+        const o = C.current;
+        if ((o == null ? void 0 : o.via) !== "pointer") {
+          if (o && o.id === r && o.kind === e) {
+            x(!0);
+            return;
+          }
+          Y(e, r, "keyboard"), W(
+            p(e === "move" ? "dashboardGrid.grabbed" : "dashboardGrid.resizeGrabbed")
+          );
+        }
+      },
+      [a, Y, x, p]
+    ), fe = D(
+      (e, r) => {
+        const o = C.current;
+        if (!o || o.id !== r || o.via !== "keyboard")
+          return;
+        if (e.key === "Escape") {
+          e.preventDefault(), x(!1);
+          return;
+        }
+        if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(e.key)) return;
+        e.preventDefault();
+        const d = typeof window < "u" && N.current ? window.getComputedStyle(N.current).direction === "rtl" : !1, b = e.key === "ArrowRight" ? d ? -1 : 1 : e.key === "ArrowLeft" ? d ? 1 : -1 : 0, h = e.key === "ArrowDown" ? 1 : e.key === "ArrowUp" ? -1 : 0, M = (Q.current ?? o.baseLayout).find((I) => I.id === r);
+        if (!M) return;
+        const E = o.kind === "move" ? te(
+          o.baseLayout,
+          r,
+          M.x + b,
+          M.y + h,
+          n
+        ) : ne(
+          o.baseLayout,
+          r,
+          M.w + b,
+          M.h + h,
+          n
+        );
+        R(E);
+        const z = E.find((I) => I.id === r);
+        z && pe(o.kind, z);
+      },
+      [n, x, R, pe]
+    ), ge = D(
+      (e, r, o) => {
+        var z, I, we, ve;
+        if (!a || C.current) return;
+        const u = N.current, d = $.current.find((Le) => Le.id === r);
+        if (!u || !d) return;
+        o.preventDefault(), (I = (z = o.currentTarget).focus) == null || I.call(z);
+        const b = u.getBoundingClientRect();
+        if (b.width <= 0) return;
+        const h = window.getComputedStyle(u), G = Number.parseFloat(h.columnGap) || 0, M = Number.parseFloat(h.rowGap) || 0, E = (b.width - G * (n - 1)) / n;
+        j.current = {
+          kind: e,
+          id: r,
+          pointerId: o.pointerId,
+          startClientX: o.clientX,
+          startClientY: o.clientY,
+          origin: d,
+          colStride: E + G,
+          rowStride: g + M,
+          isRtl: h.direction === "rtl"
+        };
+        try {
+          (ve = (we = o.currentTarget).setPointerCapture) == null || ve.call(we, o.pointerId);
+        } catch {
+        }
+        Y(e, r, "pointer");
+      },
+      [a, n, g, Y]
+    );
+    X(() => {
+      if (!k || k.via !== "pointer") return;
+      const e = (u) => {
+        const d = j.current, b = C.current;
+        if (!d || !b || u.pointerId !== d.pointerId)
+          return;
+        const h = u.clientX - d.startClientX, G = u.clientY - d.startClientY, M = Math.round(h / d.colStride) * (d.isRtl ? -1 : 1), E = Math.round(G / d.rowStride), z = d.kind === "move" ? te(
+          b.baseLayout,
+          d.id,
+          d.origin.x + M,
+          d.origin.y + E,
+          F.current
+        ) : ne(
+          b.baseLayout,
+          d.id,
+          d.origin.w + M,
+          d.origin.h + E,
+          F.current
+        );
+        R(z);
+      }, r = (u) => {
+        const d = j.current;
+        !d || u.pointerId !== d.pointerId || (H.current = !0, x(!0));
+      }, o = (u) => {
+        const d = j.current;
+        !d || u.pointerId !== d.pointerId || (H.current = !0, x(!1));
+      };
+      return window.addEventListener("pointermove", e), window.addEventListener("pointerup", r), window.addEventListener("pointercancel", o), () => {
+        window.removeEventListener("pointermove", e), window.removeEventListener("pointerup", r), window.removeEventListener("pointercancel", o);
+      };
+    }, [k, x, R]), X(() => {
+      if (!k) return;
+      const e = (r) => {
+        r.key === "Escape" && x(!1);
+      };
+      return window.addEventListener("keydown", e), () => window.removeEventListener("keydown", e);
+    }, [k, x]), X(() => {
+      if (!k || k.via !== "keyboard") return;
+      const e = (o) => {
+        var d;
+        const u = o.relatedTarget;
+        (!u || !((d = N.current) != null && d.contains(u))) && x(!1);
+      }, r = N.current;
+      return r == null || r.addEventListener("focusout", e), () => r == null ? void 0 : r.removeEventListener("focusout", e);
+    }, [k, x]), U(() => {
+      const e = N.current;
+      e && (e.style.setProperty("--dg-cols", String(n)), e.style.setProperty("--dg-row", `${g}px`));
+    }, [n, g]);
+    const be = Xe(K);
+    U(() => {
+      const e = N.current;
+      e && (e.style.setProperty(
+        "--dg-grid-lines",
+        `repeating-linear-gradient(to right, color-mix(in srgb, var(--border) 50%, transparent) 0 1px, transparent 1px calc((100% + var(--spacing-md)) / ${n})), repeating-linear-gradient(to bottom, color-mix(in srgb, var(--border) 50%, transparent) 0 1px, transparent 1px calc(${g}px + var(--spacing-md)))`
+      ), e.style.setProperty(
+        "--dg-min-block",
+        `calc(${be + 2} * (${g}px + var(--spacing-md)) - var(--spacing-md))`
+      ));
+    }, [n, g, be]);
+    const he = S(null), Z = a && !!m, q = L(
+      () => Z ? xe(K, n, 2, 2) : null,
+      [Z, K, n]
+    );
+    U(() => {
+      const e = he.current;
+      !e || !q || (e.style.setProperty("--dg-x", String(q.x + 1)), e.style.setProperty("--dg-y", String(q.y + 1)), e.style.setProperty("--dg-w", "2"), e.style.setProperty("--dg-h", "2"));
+    }, [q]);
+    const ye = D(
+      (e) => {
+        P(
+          T(
+            $.current.filter((r) => r.id !== e),
+            F.current
+          )
+        ), W(p("dashboardGrid.removed")), i == null || i(e), requestAnimationFrame(() => {
+          const r = N.current;
+          if (!r) return;
+          const o = r.querySelector("button");
+          o ? o.focus() : r.focus();
+        });
+      },
+      [P, i, p]
+    ), ee = L(
+      () => ({
+        moveWidgetTo(e, r, o) {
+          return !a || !Number.isFinite(r) || !Number.isFinite(o) || !v.some((u) => u.id === e) ? !1 : (P(
+            T(
+              te(v, e, Math.round(r), Math.round(o), n),
+              n
+            )
+          ), !0);
+        },
+        resizeWidgetTo(e, r, o) {
+          return !a || !Number.isFinite(r) || !Number.isFinite(o) || !v.some((u) => u.id === e) ? !1 : (P(
+            T(
+              ne(
+                v,
+                e,
+                Math.round(r),
+                Math.round(o),
+                n
+              ),
+              n
+            )
+          ), !0);
+        },
+        getGridState() {
+          return {
+            cols: n,
+            editing: a,
+            layout: v.map((e) => ({ ...e }))
+          };
+        }
+      }),
+      [a, v, n, P]
+    );
+    We(B, () => ee, [ee]), Ke(Oe, ee, s);
+    const ze = L(
+      () => ({
+        editing: a,
+        layoutById: le,
+        grab: k,
+        canRemove: !!i,
+        requestRemove: ye,
+        startKeyboardGrab: me,
+        keyboardStep: fe,
+        startPointerGrab: ge
+      }),
+      [
+        a,
+        le,
+        k,
+        i,
+        ye,
+        me,
+        fe,
+        ge
+      ]
+    );
+    return /* @__PURE__ */ _(
+      "div",
+      {
+        "data-component": "dashboard-grid",
+        "data-component-id": s,
+        "data-editing": a || void 0,
+        className: `ds:block ds:w-full ${V ?? ""}`.trim(),
+        children: [
+          /* @__PURE__ */ w("div", { role: "status", "aria-live": "polite", className: "ds:sr-only", children: Ee }),
+          /* @__PURE__ */ _(
+            "div",
+            {
+              ref: N,
+              role: "list",
+              "aria-label": t,
+              tabIndex: -1,
+              "data-editing": a || void 0,
+              className: Ue(),
+              children: [
+                /* @__PURE__ */ w(Me.Provider, { value: ze, children: y }),
+                Z ? (
+                  // role="list" allows only listitem children — the tile wrapper
+                  // carries the grid placement, the button fills it.
+                  /* @__PURE__ */ w(
+                    "div",
+                    {
+                      ref: he,
+                      role: "listitem",
+                      className: [
+                        "ds:flex",
+                        "ds:[grid-column-start:var(--dg-x)] ds:[grid-column-end:span_var(--dg-w)]",
+                        "ds:[grid-row-start:var(--dg-y)] ds:[grid-row-end:span_var(--dg-h)]"
+                      ].join(" "),
+                      children: /* @__PURE__ */ _(
+                        "button",
+                        {
+                          type: "button",
+                          onClick: m,
+                          className: [
+                            "ds:flex ds:flex-1 ds:items-center ds:justify-center ds:gap-[var(--spacing-xs)]",
+                            "ds:rounded-[var(--radius-lg)] ds:border ds:border-dashed ds:border-border",
+                            "ds:text-sm ds:text-muted-foreground ds:transition-colors",
+                            "ds:hover:bg-muted/10 ds:hover:text-foreground",
+                            "ds:focus-visible:outline-[length:var(--focus-ring-width)] ds:focus-visible:outline-solid ds:focus-visible:outline-ring"
+                          ].join(" "),
+                          children: [
+                            /* @__PURE__ */ w(_e, { "aria-hidden": "true", className: "ds:size-4" }),
+                            p("dashboardGrid.add")
+                          ]
+                        }
+                      )
+                    }
+                  )
+                ) : null
+              ]
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+Ne.displayName = "DashboardGrid";
+const cr = Object.assign(Ne, {
+  Widget: Se
+});
+export {
+  cr as D,
+  Oe as d
+};
+//# sourceMappingURL=dashboard-grid-D2dm0IRN.js.map