@alfadocs/ui-kit 1.60.0 → 1.62.0

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

@@ -0,0 +1,1428 @@
+import { jsxs as ge, jsx as R } from "react/jsx-runtime";
+import { forwardRef as Dt, useRef as S, useState as J, useCallback as L, useMemo as se, useEffect as B, useImperativeHandle as Pt, useContext as Wt, Children as Ht, isValidElement as zt, Fragment as Xt, createContext as Ft, cloneElement as lt } from "react";
+import { c as ue } from "./index-D2ZczOXr.js";
+import { useTranslation as xt } from "react-i18next";
+import { I as Fe } from "./icon-button-C_1TgRiK.js";
+import { D as Ie } from "./dropdown-menu-D1we7oAY.js";
+import { T as Yt } from "./tooltip-uEBdD1-5.js";
+import { u as re } from "./use-isomorphic-layout-effect-BGfaCOP1.js";
+import { u as Ot } from "./registry-DvAUVLHh.js";
+import { P as jt } from "./plus-DzMQ_c6b.js";
+import { X as Vt } from "./x-B5YnXwCz.js";
+import { G as $t } from "./grip-vertical-onSb1JXO.js";
+import { E as qt } from "./ellipsis-dRo9ouSU.js";
+import { c as Kt } 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 Ut = [
+  ["path", { d: "M19 13v6h-6", key: "1hxl6d" }],
+  ["path", { d: "M5 11V5h6", key: "12e2xe" }],
+  ["path", { d: "m5 5 14 14", key: "11anup" }]
+], Bt = Kt("move-diagonal-2", Ut), Jt = {
+  id: "dashboard-grid",
+  // The board's whole purpose is in-place rearrangement of its widgets.
+  // `scroll` is backed by reveal_widget (the catalogue's name heuristic
+  // cannot see that and warns).
+  capabilities: ["edit_inline", "scroll"],
+  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: (r) => r.getGridState().layout
+    },
+    cols: {
+      type: "number",
+      descriptionKey: "ui.agent.dashboardGrid.state.cols",
+      description: "Logical column count of the board.",
+      read: (r) => r.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: (r) => r.getGridState().editing
+    },
+    stacked: {
+      type: "boolean",
+      descriptionKey: "ui.agent.dashboardGrid.state.stacked",
+      description: "Whether the board is narrower than its stackBelow width and shows its widgets as one read-only column. Move/resize actions are unavailable while it is true, even in edit mode; the saved layout is unchanged.",
+      read: (r) => r.getGridState().stacked
+    },
+    selectedId: {
+      type: "string | null",
+      descriptionKey: "ui.agent.dashboardGrid.state.selectedId",
+      description: "The widget the host has marked (for example while its settings are open), or null. Set by the host, not by agents.",
+      read: (r) => r.getGridState().selectedId
+    }
+  },
+  actions: {
+    reveal_widget: {
+      // Scrolls the view and rings a widget for a moment; changes nothing.
+      safety: "read",
+      argsType: "id",
+      argsSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Widget id (see layout state)." }
+        },
+        required: ["id"]
+      },
+      returns: "Promise<boolean> (revealed)",
+      returnsSchema: {
+        type: "boolean",
+        description: "True once the widget is in view; false if it has not appeared within a second."
+      },
+      idempotent: !0,
+      errors: [
+        "Unknown or not yet rendered widget id: waits up to a second, then resolves false."
+      ],
+      descriptionKey: "ui.agent.dashboardGrid.actions.revealWidget",
+      description: "Scroll a widget into view (its scrolling ancestor and the window) and highlight it briefly. Works in view and edit mode, and for a widget added a moment ago. Does not move focus.",
+      invoke: (r, i) => r.revealWidget(i.id)
+    },
+    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, the board is stacked, or the id is unknown."
+      },
+      idempotent: !0,
+      errors: [
+        "Unavailable while the board is stacked (state stacked is true): returns false and changes nothing.",
+        "Unavailable while edit mode is off: returns false.",
+        "Unknown widget id: returns false."
+      ],
+      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 or the board is stacked.",
+      invoke: (r, i) => r.moveWidgetTo(i.id, i.x, i.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, the board is stacked, or the id is unknown."
+      },
+      idempotent: !0,
+      errors: [
+        "Unavailable while the board is stacked (state stacked is true): returns false and changes nothing.",
+        "Unavailable while edit mode is off: returns false.",
+        "Unknown widget id: returns false."
+      ],
+      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 or the board is stacked.",
+      invoke: (r, i) => r.resizeWidgetTo(i.id, i.w, i.h)
+    }
+  },
+  domHooks: {
+    root: {
+      attr: "data-component",
+      value: "dashboard-grid",
+      description: 'Also carries data-stacked="true" while the board shows one read-only column.'
+    },
+    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 X(r, i) {
+  return r.x < i.x + i.w && i.x < r.x + r.w && r.y < i.y + i.h && i.y < r.y + r.h;
+}
+function Ne(r, i) {
+  const s = Math.max(1, r.minW ?? 1), l = Math.max(1, r.minH ?? 1), g = Math.min(i, r.maxW ?? i), N = r.maxH ?? Number.POSITIVE_INFINITY, p = Math.min(Math.max(r.w, s), g), a = Math.min(Math.max(r.h, l), N), I = Math.min(Math.max(0, r.x), i - p), W = Math.max(0, r.y);
+  return { ...r, x: I, y: W, w: p, h: a };
+}
+function ut(r, i) {
+  if (i.some((s) => X(s, r))) return !1;
+  for (let s = r.y; s < r.y + r.h; s += 1)
+    if (!i.some(
+      (g) => g.x >= r.x + r.w && s >= g.y && s < g.y + g.h
+    )) return !1;
+  return !0;
+}
+function ft(r, i, s) {
+  return Math.abs(r.y * s + r.x - (i.y * s + i.x));
+}
+function oe(r, i, s, l) {
+  const g = r.map((o) => Ne(o, i)), N = [...g].sort((o, w) => o.id === s ? -1 : w.id === s ? 1 : o.y - w.y || o.x - w.x), p = [], a = s ? g.find((o) => o.id === s) : void 0, I = /* @__PURE__ */ new Set();
+  for (const o of N) {
+    if (o.id !== s) {
+      if (a && X(a, o)) {
+        const w = { ...o, y: Math.max(0, a.y - o.h) };
+        !X(a, w) && !p.some((x) => x.id !== s && X(x, w)) && (o.y = w.y);
+      }
+      if (p.some((w) => X(w, o))) {
+        I.add(o.id);
+        const w = g.filter((k) => k.id !== o.id);
+        let x = o.y;
+        for (; p.some((k) => X(k, { ...o, y: x })); )
+          x += 1;
+        let _ = null;
+        for (let k = Math.max(0, o.y - o.h); k <= x; k += 1)
+          for (let E = 0; E <= i - o.w; E += 1) {
+            const H = { ...o, x: E, y: k };
+            (ut(H, w) || l !== void 0 && X(l, H) && !w.some(($) => X($, H))) && (!_ || ft({ x: E, y: k }, o, i) < ft(_, o, i)) && (_ = { x: E, y: k });
+          }
+        if (_)
+          o.x = _.x, o.y = _.y;
+        else {
+          o.y = x;
+          const k = a !== void 0 && a.x < o.x && o.x < a.x + a.w, E = a ? a.x : o.x;
+          for (; k && o.x > E && !w.some((H) => X(H, { ...o, x: o.x - 1 })); )
+            o.x -= 1;
+        }
+      }
+      for (; p.some((w) => X(w, o)); )
+        o.y += 1;
+      for (; o.y > 0; ) {
+        const w = { ...o, y: o.y - 1 };
+        if (p.some((x) => X(x, w))) break;
+        o.y -= 1;
+      }
+    }
+    p.push(o);
+  }
+  const W = a ? [...p].sort((o, w) => o.y - w.y || o.x - w.x) : [];
+  for (const o of W) {
+    if (o.id === s || I.has(o.id)) continue;
+    const w = p.filter((_) => _.id !== o.id);
+    let x = null;
+    for (let _ = 0; _ < o.y && !x; _ += 1) {
+      const k = Array.from(
+        { length: 2 * o.w + 1 },
+        (E, H) => o.x - o.w + H
+      ).filter((E) => E >= 0 && E <= i - o.w).sort((E, H) => Math.abs(E - o.x) - Math.abs(H - o.x) || E - H);
+      for (const E of k)
+        if (ut({ ...o, x: E, y: _ }, w)) {
+          x = { x: E, y: _ };
+          break;
+        }
+    }
+    if (x)
+      for (o.x = x.x, o.y = x.y; o.y > 0; ) {
+        const _ = { ...o, y: o.y - 1 };
+        if (w.some((k) => X(k, _))) break;
+        o.y -= 1;
+      }
+  }
+  const b = new Map(p.map((o) => [o.id, o]));
+  return r.map((o) => b.get(o.id));
+}
+function Qt(r, i, s, l, g) {
+  const N = r.map(
+    (p) => p.id === i ? Ne({ ...p, x: s, y: l }, g) : p
+  );
+  return oe(
+    N,
+    g,
+    i,
+    r.find((p) => p.id === i)
+  );
+}
+function Zt(r, i, s, l, g) {
+  const N = r.map(
+    (p) => p.id === i ? (
+      // 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.
+      Ne(
+        {
+          ...p,
+          w: Math.max(p.minW ?? 1, Math.min(s, g - p.x)),
+          h: l
+        },
+        g
+      )
+    ) : p
+  );
+  return oe(N, g, i);
+}
+function mt(r, i, s, l) {
+  const g = Math.min(Math.max(1, s), i), N = r.reduce((p, a) => Math.max(p, a.y + a.h), 0);
+  for (let p = 0; p <= N; p += 1)
+    for (let a = 0; a <= i - g; a += 1) {
+      const I = {
+        x: a,
+        y: p,
+        w: g,
+        h: l
+      };
+      if (!r.some((W) => X(W, I)))
+        return { x: a, y: p };
+    }
+  return { x: 0, y: N };
+}
+function kt(r) {
+  return r.reduce((i, s) => Math.max(i, s.y + s.h), 0);
+}
+const er = 24;
+function pt(r, i, s) {
+  return i === void 0 || !Number.isFinite(i) || i <= 0 ? !1 : !Number.isFinite(r) || r <= 0 ? s : s ? r < i + er : r < i;
+}
+function tr(r, i) {
+  const s = new Map(i.map((l) => [l.id, l]));
+  return r.map((l, g) => ({ id: l, index: g, entry: s.get(l) })).sort((l, g) => !l.entry || !g.entry ? l.entry ? -1 : g.entry ? 1 : l.index - g.index : l.entry.y - g.entry.y || l.entry.x - g.entry.x || l.index - g.index).map(({ id: l }) => l);
+}
+const rr = ue(
+  [
+    "ds:grid ds:w-full",
+    // A stacking context: a grabbed widget's lift stays inside the board.
+    "ds:isolate",
+    "ds:gap-[var(--spacing-md)]",
+    // 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: {
+      // Stacked: one full-width column; each row takes its widget's block
+      // size. Focus can fall back to the board here (see the focus effect),
+      // so it gets the kit's focus ring.
+      stacked: {
+        false: [
+          "ds:[grid-template-columns:repeat(var(--dg-cols),minmax(0,1fr))]",
+          "ds:[grid-auto-rows:var(--dg-row)]"
+        ].join(" "),
+        true: [
+          "ds:grid-cols-1 ds:auto-rows-auto",
+          "ds:focus-visible:outline-[length:var(--focus-ring-width)] ds:focus-visible:outline-solid ds:focus-visible:outline-ring ds:focus-visible:outline-offset-[length:var(--focus-ring-offset)]"
+        ].join(" ")
+      }
+    },
+    defaultVariants: { stacked: !1 }
+  }
+), nr = ue(
+  [
+    "ds:relative ds:min-h-0 ds:min-w-0 ds:overflow-hidden",
+    // Its own stacking context: a sticky or raised layer inside a widget
+    // can never paint over the page's chrome (a sticky toolbar, say).
+    "ds:isolate",
+    // Header actions fold into one menu below a set widget width.
+    "ds:@container/widget",
+    // 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:[:where(&)]:border-[length:var(--surface-border-width,var(--border-width-sm))] ds:border-[color:var(--card-border)] ds:shadow-[var(--shadow-card)]",
+    // 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",
+    // Selected (and briefly revealed): an inset edge in --primary, the
+    // kit's selected colour, so it reads apart from focus and from a grab.
+    "ds:data-[selected=true]:ring-[length:var(--border-width-md)] ds:data-[selected=true]:ring-inset ds:data-[selected=true]:ring-[color:var(--primary)]",
+    "ds:data-[revealed=true]:ring-[length:var(--border-width-md)] ds:data-[revealed=true]:ring-inset ds:data-[revealed=true]:ring-[color:var(--primary)]",
+    "ds:forced-colors:data-[selected=true]:outline-[length:var(--border-width-md)] ds:forced-colors:data-[selected=true]:outline-solid ds:forced-colors:data-[selected=true]:outline-[Highlight]",
+    // Only reachable when stacking removes the focused edit control: the
+    // widget then takes focus itself (tabindex -1, set at that moment).
+    "ds:focus-visible:outline-[length:var(--focus-ring-width)] ds:focus-visible:outline-solid ds:focus-visible:outline-ring ds:focus-visible:outline-offset-[length:var(--focus-ring-offset)]"
+  ].join(" "),
+  {
+    variants: {
+      stacked: {
+        false: [
+          "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(" "),
+        true: "ds:col-span-full ds:row-auto"
+      },
+      stackedHeight: { grid: "", content: "" }
+    },
+    compoundVariants: [
+      { stacked: !1, class: "ds:flex ds:flex-col" },
+      // At least the block size the widget has in the grid (h rows plus the
+      // h - 1 gaps). A minimum, not a fixed size: at 200% zoom the widget
+      // grows instead of clipping its content (WCAG 1.4.4, 1.4.10).
+      {
+        stacked: !0,
+        stackedHeight: "grid",
+        class: [
+          "ds:flex ds:flex-col",
+          "ds:[min-block-size:calc(var(--dg-h)*var(--dg-row)_+_(var(--dg-h)_-_1)*var(--spacing-md))]"
+        ].join(" ")
+      },
+      // As tall as the content, or minStackedHeight. A grid, not a flex
+      // column, so the body row is a definite box a 100% chart can fill.
+      {
+        stacked: !0,
+        stackedHeight: "content",
+        class: [
+          "ds:grid ds:grid-cols-[minmax(0,1fr)] ds:grid-rows-[auto_1fr]",
+          "ds:[min-block-size:var(--dg-min-stacked)]"
+        ].join(" ")
+      }
+    ],
+    defaultVariants: { stacked: !1, stackedHeight: "grid" }
+  }
+), ir = ue(
+  "ds:ps-[var(--spacing-md)] ds:pt-[var(--spacing-xs)]",
+  {
+    variants: {
+      // `box`: fill the widget's block size and clip to it. `content`: take
+      // the content's own height (the content-height stack), never a box.
+      fit: {
+        box: "ds:min-h-0 ds:flex-1 ds:overflow-hidden",
+        content: "ds:min-w-0"
+      },
+      // Editing: clear of the resize grip's whole hit area, a
+      // --min-target-size square in the corner. Block-end takes the full
+      // size, keeping the width narrow widgets need; inline-end the glyph.
+      editing: {
+        false: "ds:pe-[var(--spacing-md)] ds:pb-[var(--spacing-md)]",
+        true: [
+          "ds:pe-[calc(var(--spacing-lg)_+_var(--spacing-2xs))]",
+          "ds:pb-[var(--min-target-size)]"
+        ].join(" ")
+      }
+    },
+    defaultVariants: { fit: "box", editing: !1 }
+  }
+), sr = ue(
+  [
+    "ds:absolute ds:bottom-[var(--spacing-2xs)] ds:end-[var(--spacing-2xs)]",
+    "ds:inline-flex ds:size-[var(--spacing-lg)] ds:items-center ds:justify-center",
+    "ds:rounded-[var(--radius-sm)] ds:text-[var(--muted-foreground)] ds:touch-none",
+    "ds:cursor-nwse-resize ds:rtl:cursor-nesw-resize",
+    "ds:hover:bg-muted/20 ds:hover:text-[var(--foreground)]",
+    "ds:aria-pressed:bg-muted/20 ds:aria-pressed:text-[var(--foreground)]",
+    "ds:[&_svg]:size-3.5 ds:rtl:[&_svg]:-scale-x-100",
+    "ds:before:absolute ds:before:content-['']",
+    "ds:before:bottom-[calc(-1*var(--spacing-2xs))] ds:before:end-[calc(-1*var(--spacing-2xs))]",
+    "ds:before:size-[var(--min-target-size)]",
+    "ds:focus-visible:outline-[length:var(--focus-ring-width)] ds:focus-visible:outline-solid ds:focus-visible:outline-ring ds:focus-visible:outline-offset-[length:var(--focus-ring-offset)]"
+  ].join(" ")
+), gt = ue(
+  "ds:items-center ds:gap-[calc(var(--min-target-size)_-_var(--spacing-xl))]",
+  {
+    variants: {
+      when: {
+        always: "ds:flex",
+        wide: "ds:flex ds:@max-[300px]/widget:hidden",
+        narrow: "ds:hidden ds:@max-[300px]/widget:flex"
+      }
+    },
+    defaultVariants: { when: "always" }
+  }
+), Ye = "ds:bg-[var(--card)] ds:data-[component=icon-button]:sm:before:block", or = ue(
+  "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)]",
+  {
+    variants: {
+      editing: {
+        false: "",
+        true: "ds:cursor-grab ds:select-none ds:[-webkit-touch-callout:none]"
+      }
+    },
+    defaultVariants: { editing: !1 }
+  }
+), dr = ue(
+  [
+    "ds:m-0 ds:min-w-0 ds:flex-1 ds:truncate ds:text-sm ds:font-medium",
+    "ds:rounded-[var(--radius-sm)]",
+    "ds:focus-visible:outline-[length:var(--focus-ring-width)] ds:focus-visible:outline-solid ds:focus-visible:outline-ring ds:focus-visible:outline-offset-[length:var(--focus-ring-offset)]"
+  ].join(" ")
+), St = Ft(
+  null
+);
+function ht(r) {
+  return r !== void 0 && Number.isFinite(r) && r >= 1 ? Math.floor(r) : void 0;
+}
+function Le(r, i) {
+  Ht.forEach(r, (s) => {
+    if (zt(s)) {
+      if (s.type === Xt) {
+        Le(
+          s.props.children,
+          i
+        );
+        return;
+      }
+      i(s);
+    }
+  });
+}
+function Mt({
+  id: r,
+  title: i,
+  minStackedHeight: s,
+  actions: l,
+  actionsSlot: g,
+  children: N
+}) {
+  var fe, de, T;
+  const { t: p } = xt("ui"), a = Wt(St), I = S(null), W = S(null), b = a == null ? void 0 : a.layoutById.get(r), [o, w] = J(null), [x, _] = J(!1), [k, E] = J(!1), [H, A] = J(!1);
+  if (B(() => {
+    if (!o) return;
+    const h = () => _(o.scrollWidth > o.clientWidth);
+    h();
+    const z = typeof document < "u" ? document.fonts : void 0;
+    z == null || z.addEventListener("loadingdone", h);
+    const q = typeof ResizeObserver > "u" ? void 0 : new ResizeObserver(h);
+    return q == null || q.observe(o), () => {
+      z == null || z.removeEventListener("loadingdone", h), q == null || q.disconnect();
+    };
+  }, [o, i]), B(() => {
+    x || A(!1);
+  }, [x]), re(() => {
+    const h = I.current;
+    !h || !b || (h.style.setProperty("--dg-x", String(b.x + 1)), h.style.setProperty("--dg-y", String(b.y + 1)), h.style.setProperty("--dg-w", String(b.w)), h.style.setProperty("--dg-h", String(b.h)), h.style.setProperty(
+      "--dg-min-stacked",
+      s !== void 0 && Number.isFinite(s) && s > 0 ? `${s}px` : "auto"
+    ));
+  }, [b == null ? void 0 : b.x, b == null ? void 0 : b.y, b == null ? void 0 : b.w, b == null ? void 0 : b.h, b, s]), !a || !b) return null;
+  const $ = ((fe = a.grab) == null ? void 0 : fe.id) === r, G = a.editing, M = [
+    ...l ?? [],
+    ...G && a.canRemove ? [
+      {
+        id: bt,
+        label: p("dashboardGrid.remove", { title: i }),
+        icon: /* @__PURE__ */ R(Vt, {}),
+        onSelect: () => a.requestRemove(r)
+      }
+    ] : []
+  ], xe = M.length > 1, Q = a.headingLevel ? `h${a.headingLevel}` : "span";
+  return /* @__PURE__ */ ge(
+    "div",
+    {
+      ref: I,
+      role: "listitem",
+      "aria-label": i,
+      "data-component": "dashboard-grid-widget",
+      "data-widget-id": r,
+      "data-grabbed": $ || void 0,
+      "data-selected": a.selectedId === r || void 0,
+      "data-revealed": a.revealedId === r || void 0,
+      "aria-current": a.selectedId === r ? "true" : void 0,
+      className: nr({
+        stacked: a.stacked,
+        stackedHeight: a.stackedHeight
+      }),
+      children: [
+        /* @__PURE__ */ ge(
+          "div",
+          {
+            className: or({ editing: G }),
+            onPointerDown: G ? (h) => a.startHeaderPress(r, h) : void 0,
+            children: [
+              G ? /* @__PURE__ */ R(
+                Fe,
+                {
+                  size: "sm",
+                  intent: "outline",
+                  type: "button",
+                  icon: /* @__PURE__ */ R($t, {}),
+                  "aria-label": p("dashboardGrid.move", { title: i }),
+                  "aria-pressed": $ && ((de = a.grab) == null ? void 0 : de.kind) === "move",
+                  className: `ds:cursor-grab ds:touch-none ${Ye}`,
+                  onPointerDown: (h) => a.startPointerGrab("move", r, h),
+                  onKeyDown: (h) => a.keyboardStep(h, r),
+                  onClick: () => a.startKeyboardGrab("move", r)
+                }
+              ) : null,
+              /* @__PURE__ */ R(
+                Yt,
+                {
+                  label: i,
+                  open: x && H,
+                  onOpenChange: (h) => A(h && x),
+                  children: /* @__PURE__ */ R(
+                    Q,
+                    {
+                      ref: w,
+                      tabIndex: x || k ? 0 : void 0,
+                      "data-dashboard-grid-title": "",
+                      onFocus: () => E(!0),
+                      onBlur: () => E(!1),
+                      className: dr(),
+                      children: i
+                    }
+                  )
+                }
+              ),
+              g,
+              M.length > 0 ? /* @__PURE__ */ R(
+                "div",
+                {
+                  className: gt({
+                    when: xe ? "wide" : "always"
+                  }),
+                  children: M.map((h) => /* @__PURE__ */ R(
+                    Fe,
+                    {
+                      size: "sm",
+                      intent: "outline",
+                      type: "button",
+                      icon: h.icon,
+                      className: Ye,
+                      "aria-label": h.label,
+                      onClick: h.onSelect
+                    },
+                    h.id
+                  ))
+                }
+              ) : null,
+              xe ? /* @__PURE__ */ R("div", { className: gt({ when: "narrow" }), children: /* @__PURE__ */ ge(Ie.Root, { modal: !1, children: [
+                /* @__PURE__ */ R(Ie.Trigger, { asChild: !0, children: /* @__PURE__ */ R(
+                  Fe,
+                  {
+                    size: "sm",
+                    intent: "outline",
+                    type: "button",
+                    icon: /* @__PURE__ */ R(qt, {}),
+                    className: Ye,
+                    "aria-label": p("dashboardGrid.moreActions", { title: i })
+                  }
+                ) }),
+                /* @__PURE__ */ R(
+                  Ie.Content,
+                  {
+                    align: "end",
+                    onCloseAutoFocus: (h) => {
+                      const z = W.current;
+                      if (W.current = null, !z) return;
+                      const q = document.activeElement;
+                      z.onSelect(), (z.id === bt || document.activeElement !== q) && h.preventDefault();
+                    },
+                    children: M.map((h) => /* @__PURE__ */ R(
+                      Ie.Item,
+                      {
+                        startIcon: h.icon,
+                        onSelect: () => {
+                          W.current = h;
+                        },
+                        children: h.label
+                      },
+                      h.id
+                    ))
+                  }
+                )
+              ] }) }) : null
+            ]
+          }
+        ),
+        /* @__PURE__ */ R(
+          "div",
+          {
+            className: ir({
+              fit: a.stacked && a.stackedHeight === "content" ? "content" : "box",
+              editing: G
+            }),
+            children: N
+          }
+        ),
+        G ? /* @__PURE__ */ R(
+          "button",
+          {
+            type: "button",
+            "aria-label": p("dashboardGrid.resize", { title: i }),
+            "aria-pressed": $ && ((T = a.grab) == null ? void 0 : T.kind) === "resize",
+            className: sr(),
+            onPointerDown: (h) => a.startPointerGrab("resize", r, h),
+            onKeyDown: (h) => a.keyboardStep(h, r),
+            onClick: () => a.startKeyboardGrab("resize", r),
+            children: /* @__PURE__ */ R(Bt, { "aria-hidden": "true" })
+          }
+        ) : null
+      ]
+    }
+  );
+}
+Mt.displayName = "DashboardGrid.Widget";
+const vt = 1e3, ar = 1600, cr = [
+  "button",
+  "a",
+  "input",
+  "select",
+  "textarea",
+  "label",
+  "summary",
+  '[contenteditable]:not([contenteditable="false"])',
+  '[role="button"]',
+  '[role="menuitem"]',
+  "[tabindex]:not([data-dashboard-grid-title])"
+].join(", "), bt = "__remove__", wt = 4, lr = 400, ur = 8, Oe = 48, fr = 18;
+function mr(r) {
+  const i = {
+    x: null,
+    y: null
+  }, s = (l) => l === "auto" || l === "scroll" || l === "overlay";
+  for (let l = r.parentElement; l && l !== document.body && l !== document.documentElement && !(i.x && i.y); l = l.parentElement) {
+    const g = window.getComputedStyle(l);
+    !i.y && s(g.overflowY) && l.scrollHeight > l.clientHeight && (i.y = l), !i.x && s(g.overflowX) && l.scrollWidth > l.clientWidth && (i.x = l);
+  }
+  return i;
+}
+function pe(r, i, s, l, g, N, p = !0) {
+  const a = r.find((w) => w.id === s);
+  if (!a) return r;
+  const I = p ? kt(r) + 2 : Number.POSITIVE_INFINITY, W = i === "move" ? Qt(r, s, l, Math.min(g, I - a.h), N) : Zt(r, s, l, Math.min(g, I - a.y), N), b = W.find((w) => w.id === s);
+  return b !== void 0 && b.x === a.x && b.y === a.y && b.w === a.w && b.h === a.h ? r : W;
+}
+function yt(r) {
+  if (r >= Oe) return 0;
+  const i = (Oe - Math.max(0, r)) / Oe;
+  return Math.ceil(i * fr);
+}
+const Et = Dt(
+  ({
+    "aria-label": r,
+    id: i,
+    cols: s = 12,
+    rowHeight: l = 96,
+    layout: g,
+    defaultLayout: N,
+    onLayoutChange: p,
+    editing: a = !1,
+    onRemoveWidget: I,
+    onRequestAdd: W,
+    stackBelow: b,
+    onStackedChange: o,
+    stackedHeight: w = "grid",
+    selectedId: x,
+    widgetHeadingLevel: _,
+    children: k,
+    className: E
+  }, H) => {
+    const { t: A } = xt("ui"), $ = S(null), G = S(null), [M, xe] = J(!1), Q = S(!1);
+    Q.current = M;
+    const fe = S(null), de = L((e) => {
+      var d;
+      if (e === Q.current) return;
+      const t = $.current, n = typeof document < "u" ? document.activeElement : null;
+      fe.current = t && n instanceof HTMLElement && t.contains(n) ? {
+        element: n,
+        widgetId: ((d = n.closest("[data-widget-id]")) == null ? void 0 : d.getAttribute("data-widget-id")) ?? null
+      } : null, Q.current = e, xe(e);
+    }, []);
+    re(() => {
+      const e = $.current;
+      if (!e) return;
+      if (b === void 0) {
+        de(!1);
+        return;
+      }
+      if (de(
+        pt(e.offsetWidth, b, Q.current)
+      ), typeof ResizeObserver > "u") return;
+      const t = new ResizeObserver((n) => {
+        var c, m;
+        const d = n[n.length - 1];
+        if (!d) return;
+        const u = ((m = (c = d.borderBoxSize) == null ? void 0 : c[0]) == null ? void 0 : m.inlineSize) ?? d.contentRect.width;
+        de(pt(u, b, Q.current));
+      });
+      return t.observe(e), () => t.disconnect();
+    }, [b, de]);
+    const T = a && !M, h = se(() => {
+      const e = [];
+      return Le(k, (t) => {
+        t.props.id && e.push(t.props.id);
+      }), e;
+    }, [k]), z = se(() => {
+      const e = /* @__PURE__ */ new Map();
+      return Le(k, (t) => {
+        t.props.id && e.set(t.props.id, {
+          defaultW: t.props.defaultW ?? 4,
+          defaultH: t.props.defaultH ?? 2,
+          minW: ht(t.props.minW),
+          minH: ht(t.props.minH)
+        });
+      }), e;
+    }, [k]), [q, Gt] = J(() => N ?? []), ke = g ?? q, je = S(ke);
+    je.current = ke;
+    const Se = L(
+      (e) => e.map((t) => {
+        const n = je.current.find((m) => m.id === t.id), { minW: d, minH: u, ...c } = t;
+        return {
+          ...c,
+          ...(n == null ? void 0 : n.minW) !== void 0 ? { minW: n.minW } : {},
+          ...(n == null ? void 0 : n.minH) !== void 0 ? { minH: n.minH } : {}
+        };
+      }),
+      []
+    ), Z = L(
+      (e) => {
+        const t = Se(e);
+        g === void 0 && Gt(t), p == null || p(t);
+      },
+      [g, p, Se]
+    ), { resolved: P, autoPlaced: Ve } = se(() => {
+      const e = (u) => {
+        const c = z.get(u.id);
+        return Ne(
+          {
+            ...u,
+            ...(c == null ? void 0 : c.minW) !== void 0 ? { minW: Math.max(u.minW ?? 1, c.minW) } : {},
+            ...(c == null ? void 0 : c.minH) !== void 0 ? { minH: Math.max(u.minH ?? 1, c.minH) } : {}
+          },
+          s
+        );
+      }, t = ke.map(e), n = h.filter(
+        (u) => !t.some((c) => c.id === u)
+      );
+      if (n.length === 0)
+        return {
+          resolved: t.some(
+            (c, m) => t.some((y, f) => f > m && X(c, y))
+          ) ? oe(t, s) : t,
+          autoPlaced: !1
+        };
+      const d = [...t];
+      for (const u of n) {
+        const c = z.get(u) ?? { defaultW: 4, defaultH: 2 }, m = Math.min(Math.max(c.defaultW, c.minW ?? 1), s), y = Math.max(c.defaultH, c.minH ?? 1), f = mt(d, s, m, y);
+        d.push(e({ id: u, x: f.x, y: f.y, w: m, h: y }));
+      }
+      return { resolved: oe(d, s), autoPlaced: !0 };
+    }, [ke, h, z, s]), $e = S("");
+    B(() => {
+      if (!Ve) return;
+      const e = P.map(
+        (t) => `${t.id}:${t.x},${t.y},${t.w},${t.h}`
+      ).join("|");
+      $e.current !== e && ($e.current = e, Z(P));
+    }, [Ve, P, Z]);
+    const [Tt, _t] = J(null), [ae, qe] = J(null), [At, ce] = J(""), De = S(null), V = S(null), le = S(null), Pe = S(!1), he = S(s);
+    he.current = s;
+    const me = S(P);
+    me.current = P;
+    const ne = L((e) => {
+      De.current = e, _t(e);
+    }, []), Me = L(
+      (e, t, n) => {
+        const d = { kind: e, id: t, via: n };
+        V.current = { ...d, baseLayout: me.current }, qe(d), ne(me.current);
+      },
+      [ne]
+    ), ve = Tt ?? P, Ke = se(
+      () => new Map(ve.map((e) => [e.id, e])),
+      [ve]
+    ), Ue = L(
+      (e, t) => {
+        ce(
+          e === "move" ? A("dashboardGrid.movedTo", { col: t.x + 1, row: t.y + 1 }) : A("dashboardGrid.resizedTo", { cols: t.w, rows: t.h })
+        );
+      },
+      [A]
+    ), Y = S(null), O = L(
+      (e) => {
+        var m;
+        (m = Y.current) == null || m.call(Y), Y.current = null;
+        const t = De.current, n = V.current;
+        if (V.current = null, le.current = null, qe(null), ne(null), !e || !t || !n) {
+          ce(A("dashboardGrid.cancelled"));
+          return;
+        }
+        const d = oe(t, he.current), u = (y) => y.map((f) => `${f.id}:${f.x},${f.y},${f.w},${f.h}`).join("|");
+        if (u(d) === u(me.current)) {
+          ce(A("dashboardGrid.cancelled"));
+          return;
+        }
+        Z(d);
+        const c = d.find((y) => y.id === n.id);
+        ce(
+          c ? A("dashboardGrid.droppedAt", {
+            col: c.x + 1,
+            row: c.y + 1
+          }) : A("dashboardGrid.cancelled")
+        );
+      },
+      [ne, Z, A]
+    ), We = S(O);
+    We.current = O;
+    const Be = L(
+      (e, t) => {
+        if (!T) return;
+        if (Pe.current) {
+          Pe.current = !1;
+          return;
+        }
+        const n = V.current;
+        if ((n == null ? void 0 : n.via) !== "pointer") {
+          if (n && n.id === t && n.kind === e) {
+            O(!0);
+            return;
+          }
+          Me(e, t, "keyboard"), ce(
+            A(e === "move" ? "dashboardGrid.grabbed" : "dashboardGrid.resizeGrabbed")
+          );
+        }
+      },
+      [T, Me, O, A]
+    ), Je = L(
+      (e, t) => {
+        const n = V.current;
+        if (!n || n.id !== t || n.via !== "keyboard")
+          return;
+        if (e.key === "Escape") {
+          e.preventDefault(), O(!1);
+          return;
+        }
+        if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(e.key)) return;
+        e.preventDefault();
+        const u = typeof window < "u" && G.current ? window.getComputedStyle(G.current).direction === "rtl" : !1, c = e.key === "ArrowRight" ? u ? -1 : 1 : e.key === "ArrowLeft" ? u ? 1 : -1 : 0, m = e.key === "ArrowDown" ? 1 : e.key === "ArrowUp" ? -1 : 0, f = (De.current ?? n.baseLayout).find((D) => D.id === t);
+        if (!f) return;
+        const v = n.kind === "move" ? pe(
+          n.baseLayout,
+          "move",
+          t,
+          f.x + c,
+          f.y + m,
+          s
+        ) : pe(
+          n.baseLayout,
+          "resize",
+          t,
+          f.w + c,
+          f.h + m,
+          s
+        );
+        ne(v);
+        const C = v.find((D) => D.id === t);
+        C && Ue(n.kind, C);
+      },
+      [s, O, ne, Ue]
+    ), be = L(() => {
+      const e = le.current, t = V.current, n = G.current;
+      if (!e || !t || !n) return;
+      const d = n.getBoundingClientRect(), u = e.lastClientX - d.left - e.startGridX, c = e.lastClientY - d.top - e.startGridY, m = Math.round(u / e.colStride) * (e.isRtl ? -1 : 1), y = Math.round(c / e.rowStride), { origin: f } = e;
+      ne(
+        e.kind === "move" ? pe(
+          t.baseLayout,
+          "move",
+          e.id,
+          f.x + m,
+          f.y + y,
+          he.current
+        ) : pe(
+          t.baseLayout,
+          "resize",
+          e.id,
+          f.w + m,
+          f.h + y,
+          he.current
+        )
+      );
+    }, [ne]), Ee = S(!1), Qe = L(() => {
+      var y;
+      (y = Y.current) == null || y.call(Y);
+      const e = (f) => {
+        const v = le.current;
+        !v || f.pointerId !== v.pointerId || (v.lastClientX = f.clientX, v.lastClientY = f.clientY, v.travelled || (v.travelled = Math.hypot(
+          f.clientX - v.pressX,
+          f.clientY - v.pressY
+        ) > wt), be());
+      }, t = (f) => (v) => {
+        const C = le.current;
+        !C || v.pointerId !== C.pointerId || (Pe.current = C.fromHandle, We.current(f));
+      }, n = t(!0), d = t(!1), u = () => be();
+      let c = 0;
+      const m = () => {
+        c = requestAnimationFrame(m);
+        const f = le.current;
+        if (!(f != null && f.travelled)) return;
+        const v = G.current;
+        if (!v) return;
+        const { lastClientX: C, lastClientY: D } = f, K = mr(v), Re = (U, at, te) => {
+          const Xe = te ? window.innerHeight : window.innerWidth, j = U == null ? void 0 : U.getBoundingClientRect(), It = Math.max(
+            te ? (j == null ? void 0 : j.top) ?? 0 : (j == null ? void 0 : j.left) ?? 0,
+            0
+          ), Lt = Math.min(
+            te ? (j == null ? void 0 : j.bottom) ?? Xe : (j == null ? void 0 : j.right) ?? Xe,
+            Xe
+          ), ye = yt(Lt - at) - yt(at - It);
+          if (ye === 0) return;
+          const ct = () => U ? te ? U.scrollTop : U.scrollLeft : te ? window.scrollY : window.scrollX, Nt = ct();
+          U == null || U.scrollBy(te ? 0 : ye, te ? ye : 0), (!U || ct() === Nt) && window.scrollBy(te ? 0 : ye, te ? ye : 0);
+        };
+        Re(K.y, D, !0), Re(K.x, C, !1);
+      };
+      c = requestAnimationFrame(m), window.addEventListener("pointermove", e), window.addEventListener("pointerup", n), window.addEventListener("pointercancel", d), window.addEventListener("scroll", u, {
+        capture: !0,
+        passive: !0
+      }), Y.current = () => {
+        cancelAnimationFrame(c), Ee.current = !1, window.removeEventListener("pointermove", e), window.removeEventListener("pointerup", n), window.removeEventListener("pointercancel", d), window.removeEventListener("scroll", u, { capture: !0 });
+      };
+    }, [be]);
+    B(
+      () => () => {
+        var e;
+        (e = Y.current) == null || e.call(Y), Y.current = null;
+      },
+      []
+    );
+    const Ge = L(
+      (e, t, n, d, u) => {
+        var K;
+        const c = G.current, m = me.current.find((Re) => Re.id === t);
+        if (!c || !m) return !1;
+        const y = c.getBoundingClientRect();
+        if (y.width <= 0) return !1;
+        const f = window.getComputedStyle(c), v = Number.parseFloat(f.columnGap) || 0, C = Number.parseFloat(f.rowGap) || 0, D = (y.width - v * (s - 1)) / s;
+        le.current = {
+          kind: e,
+          id: t,
+          pointerId: n.pointerId,
+          startGridX: n.clientX - y.left,
+          startGridY: n.clientY - y.top,
+          lastClientX: n.clientX,
+          lastClientY: n.clientY,
+          origin: m,
+          colStride: D + v,
+          rowStride: l + C,
+          isRtl: f.direction === "rtl",
+          fromHandle: u,
+          pressX: n.clientX,
+          pressY: n.clientY,
+          travelled: !1
+        };
+        try {
+          (K = d.setPointerCapture) == null || K.call(d, n.pointerId);
+        } catch {
+        }
+        return Me(e, t, "pointer"), Qe(), !0;
+      },
+      [s, l, Me, Qe]
+    ), Ze = L(
+      (e, t, n) => {
+        var d, u;
+        T && (V.current || (n.preventDefault(), (u = (d = n.currentTarget).focus) == null || u.call(d), Ge(e, t, n, n.currentTarget, !0)));
+      },
+      [T, Ge]
+    ), ee = S(null), ie = L(() => {
+      const e = ee.current;
+      ee.current = null, e && (e.holdTimer && clearTimeout(e.holdTimer), e.cleanup());
+    }, []), et = L(
+      (e, t) => {
+        if (!T || V.current || ee.current || t.button !== 0 || !t.isPrimary) return;
+        const n = t.target;
+        if (!t.currentTarget.contains(n)) return;
+        const d = n.closest(cr);
+        if (d && t.currentTarget.contains(d)) return;
+        const u = t.currentTarget, c = t.pointerType === "touch";
+        c || t.preventDefault();
+        const m = (v, C) => {
+          const D = ee.current;
+          if (ie(), !(!D || V.current) && Ge(
+            "move",
+            D.id,
+            {
+              pointerId: D.pointerId,
+              clientX: D.startClientX,
+              clientY: D.startClientY
+            },
+            D.surface,
+            !1
+          )) {
+            Ee.current = c;
+            const K = le.current;
+            K && (K.lastClientX = v, K.lastClientY = C, K.travelled = !c), be();
+          }
+        }, y = (v) => {
+          const C = ee.current;
+          if (!C || v.pointerId !== C.pointerId) return;
+          const D = Math.hypot(
+            v.clientX - C.startClientX,
+            v.clientY - C.startClientY
+          );
+          c ? D > ur && ie() : D > wt && m(v.clientX, v.clientY);
+        }, f = (v) => {
+          var C;
+          v.pointerId === ((C = ee.current) == null ? void 0 : C.pointerId) && ie();
+        };
+        window.addEventListener("pointermove", y), window.addEventListener("pointerup", f), window.addEventListener("pointercancel", f), ee.current = {
+          id: e,
+          pointerId: t.pointerId,
+          pointerType: t.pointerType,
+          startClientX: t.clientX,
+          startClientY: t.clientY,
+          surface: u,
+          holdTimer: c ? setTimeout(() => {
+            const v = ee.current;
+            v && m(v.startClientX, v.startClientY);
+          }, lr) : null,
+          cleanup: () => {
+            window.removeEventListener("pointermove", y), window.removeEventListener("pointerup", f), window.removeEventListener("pointercancel", f);
+          }
+        };
+      },
+      [T, Ge, be, ie]
+    );
+    B(() => {
+      T || (ie(), V.current && We.current(!1));
+    }, [T, ie]), B(() => ie, [ie]), B(() => {
+      const e = G.current;
+      if (!T || !e) return;
+      const t = (d) => {
+        Ee.current && d.cancelable && d.preventDefault();
+      }, n = (d) => {
+        (ee.current || Ee.current) && d.preventDefault();
+      };
+      return e.addEventListener("touchmove", t, { passive: !1 }), e.addEventListener("contextmenu", n), () => {
+        e.removeEventListener("touchmove", t), e.removeEventListener("contextmenu", n);
+      };
+    }, [T]), B(() => {
+      if (!ae) return;
+      const e = (t) => {
+        t.key === "Escape" && O(!1);
+      };
+      return window.addEventListener("keydown", e), () => window.removeEventListener("keydown", e);
+    }, [ae, O]), B(() => {
+      if (!ae || ae.via !== "keyboard") return;
+      const e = (n) => {
+        var u;
+        const d = n.relatedTarget;
+        (!d || !((u = G.current) != null && u.contains(d))) && O(!1);
+      }, t = G.current;
+      return t == null || t.addEventListener("focusout", e), () => t == null ? void 0 : t.removeEventListener("focusout", e);
+    }, [ae, O]), re(() => {
+      M && (V.current && O(!1), a && ce(A("dashboardGrid.stackedReadOnly")));
+    }, [M, a, O, A]), re(() => {
+      var u;
+      const e = fe.current;
+      fe.current = null;
+      const t = $.current;
+      if (!e || !t) return;
+      const n = document.activeElement;
+      if (n === e.element || n !== null && n !== document.body) return;
+      if (t.contains(e.element)) {
+        e.element.focus();
+        return;
+      }
+      const d = e.widgetId ? Array.from(
+        t.querySelectorAll("[data-widget-id]")
+      ).find(
+        (c) => c.getAttribute("data-widget-id") === e.widgetId
+      ) : void 0;
+      if (d) {
+        d.setAttribute("tabindex", "-1"), d.focus();
+        return;
+      }
+      (u = G.current) == null || u.focus();
+    }, [M]);
+    const Te = S(o);
+    Te.current = o;
+    const tt = S(!1);
+    re(() => {
+      var e;
+      tt.current !== M && (tt.current = M, (e = Te.current) == null || e.call(Te, M));
+    }, [M]), re(() => {
+      const e = G.current;
+      e && (e.style.setProperty("--dg-cols", String(s)), e.style.setProperty("--dg-row", `${l}px`));
+    }, [s, l]);
+    const rt = kt(ve);
+    re(() => {
+      const e = G.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)) / ${s})), repeating-linear-gradient(to bottom, color-mix(in srgb, var(--border) 50%, transparent) 0 1px, transparent 1px calc(${l}px + var(--spacing-md)))`
+      ), e.style.setProperty(
+        "--dg-min-block",
+        `calc(${rt + 2} * (${l}px + var(--spacing-md)) - var(--spacing-md))`
+      ));
+    }, [s, l, rt]);
+    const nt = S(null), He = T && !!W, _e = se(
+      () => He ? mt(ve, s, 2, 2) : null,
+      [He, ve, s]
+    );
+    re(() => {
+      const e = nt.current;
+      !e || !_e || (e.style.setProperty("--dg-x", String(_e.x + 1)), e.style.setProperty("--dg-y", String(_e.y + 1)), e.style.setProperty("--dg-w", "2"), e.style.setProperty("--dg-h", "2"));
+    }, [_e]);
+    const it = L(
+      (e) => {
+        var u, c;
+        const t = Array.from(
+          ((u = G.current) == null ? void 0 : u.querySelectorAll("[data-widget-id]")) ?? []
+        ), n = t.findIndex(
+          (m) => m.getAttribute("data-widget-id") === e
+        ), d = (c = t[n + 1] ?? t[n - 1]) == null ? void 0 : c.getAttribute(
+          "data-widget-id"
+        );
+        Z(
+          oe(
+            me.current.filter((m) => m.id !== e),
+            he.current
+          )
+        ), ce(A("dashboardGrid.removed")), I == null || I(e), requestAnimationFrame(() => {
+          const m = G.current;
+          if (!m) return;
+          const y = Array.from(
+            m.querySelectorAll("[data-widget-id]")
+          ).find((v) => v.getAttribute("data-widget-id") === d), f = (y == null ? void 0 : y.querySelector("button")) ?? m.querySelector("button");
+          f ? f.focus() : m.focus();
+        });
+      },
+      [Z, I, A]
+    ), [st, ot] = J(null), F = S(null), we = S(null), Ae = S(0), Ce = L(() => {
+      var c;
+      const e = F.current, t = G.current;
+      if (!e || !t) return !1;
+      const n = Array.from(
+        t.querySelectorAll("[data-widget-id]")
+      ).find((m) => m.getAttribute("data-widget-id") === e.id), d = n == null ? void 0 : n.getBoundingClientRect();
+      if (!n || !d || d.height <= 0)
+        return performance.now() > e.deadline && (F.current = null, e.resolve(!1)), !1;
+      F.current = null;
+      const u = ((c = window.matchMedia) == null ? void 0 : c.call(window, "(prefers-reduced-motion: reduce)").matches) || window.getComputedStyle(t).getPropertyValue("--animation-duration").trim() === "0ms";
+      return n.scrollIntoView({
+        block: "nearest",
+        inline: "nearest",
+        behavior: u ? "auto" : "smooth"
+      }), ot(e.id), we.current && clearTimeout(we.current), we.current = setTimeout(
+        () => ot(null),
+        ar
+      ), e.resolve(!0), !0;
+    }, []), dt = L(
+      (e) => new Promise((t) => {
+        var c;
+        (c = F.current) == null || c.resolve(!1), cancelAnimationFrame(Ae.current);
+        const n = setTimeout(() => {
+          const m = F.current;
+          (m == null ? void 0 : m.resolve) === d && !Ce() && F.current === m && (F.current = null, d(!1));
+        }, vt), d = (m) => {
+          clearTimeout(n), t(m);
+        };
+        F.current = {
+          id: e,
+          deadline: performance.now() + vt,
+          resolve: d
+        };
+        const u = () => {
+          F.current && !Ce() && F.current && (Ae.current = requestAnimationFrame(u));
+        };
+        Ae.current = requestAnimationFrame(u);
+      }),
+      [Ce]
+    );
+    re(() => {
+      F.current && Ce();
+    }), B(
+      () => () => {
+        var e;
+        cancelAnimationFrame(Ae.current), we.current && clearTimeout(we.current), (e = F.current) == null || e.resolve(!1), F.current = null;
+      },
+      []
+    );
+    const ze = se(
+      () => ({
+        moveWidgetTo(e, t, n) {
+          if (!T || Q.current || !Number.isFinite(t) || !Number.isFinite(n) || !P.some((u) => u.id === e)) return !1;
+          const d = pe(
+            P,
+            "move",
+            e,
+            Math.round(t),
+            Math.round(n),
+            s,
+            !1
+          );
+          return d !== P && Z(oe(d, s)), !0;
+        },
+        resizeWidgetTo(e, t, n) {
+          if (!T || Q.current || !Number.isFinite(t) || !Number.isFinite(n) || !P.some((u) => u.id === e)) return !1;
+          const d = pe(
+            P,
+            "resize",
+            e,
+            Math.round(t),
+            Math.round(n),
+            s,
+            !1
+          );
+          return d !== P && Z(oe(d, s)), !0;
+        },
+        revealWidget: dt,
+        getGridState() {
+          return {
+            cols: s,
+            editing: a,
+            stacked: M,
+            layout: Se(P),
+            selectedId: x ?? null
+          };
+        }
+      }),
+      [
+        T,
+        a,
+        M,
+        P,
+        s,
+        Z,
+        Se,
+        dt,
+        x
+      ]
+    );
+    Pt(H, () => ze, [ze]), Ot(Jt, ze, i);
+    const Ct = se(
+      () => ({
+        editing: T,
+        stacked: M,
+        stackedHeight: w,
+        selectedId: x,
+        revealedId: st,
+        headingLevel: _,
+        layoutById: Ke,
+        grab: ae,
+        canRemove: !!I,
+        requestRemove: it,
+        startKeyboardGrab: Be,
+        keyboardStep: Je,
+        startPointerGrab: Ze,
+        startHeaderPress: et
+      }),
+      [
+        T,
+        M,
+        w,
+        x,
+        st,
+        _,
+        Ke,
+        ae,
+        I,
+        it,
+        Be,
+        Je,
+        Ze,
+        et
+      ]
+    ), Rt = se(() => {
+      if (b === void 0) return k;
+      const e = [], t = /* @__PURE__ */ new Map(), n = [];
+      return Le(k, (d) => {
+        const u = d.props.id;
+        if (u && !t.has(u)) {
+          const c = lt(d, {
+            key: `widget:${u}:${d.key ?? ""}`
+          });
+          t.set(u, c), e.push(c);
+        } else {
+          const c = lt(d, {
+            key: d.key === null ? `child:at:${n.length}` : `child:key:${d.key}`
+          });
+          n.push(c), e.push(c);
+        }
+      }), M ? [
+        ...tr([...t.keys()], P).map(
+          (d) => t.get(d)
+        ),
+        ...n
+      ] : e;
+    }, [b, k, M, P]);
+    return /* @__PURE__ */ ge(
+      "div",
+      {
+        ref: $,
+        "data-component": "dashboard-grid",
+        "data-component-id": i,
+        "data-editing": T || void 0,
+        "data-stacked": M || void 0,
+        className: `ds:block ds:w-full ${E ?? ""}`.trim(),
+        children: [
+          /* @__PURE__ */ R("div", { role: "status", "aria-live": "polite", className: "ds:sr-only", children: At }),
+          /* @__PURE__ */ ge(
+            "div",
+            {
+              ref: G,
+              role: "list",
+              "aria-label": r,
+              tabIndex: -1,
+              "data-editing": T || void 0,
+              "data-stacked": M || void 0,
+              className: rr({ stacked: M }),
+              children: [
+                /* @__PURE__ */ R(St.Provider, { value: Ct, children: Rt }),
+                He ? (
+                  // role="list" allows only listitem children — the tile wrapper
+                  // carries the grid placement, the button fills it.
+                  /* @__PURE__ */ R(
+                    "div",
+                    {
+                      ref: nt,
+                      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__ */ ge(
+                        "button",
+                        {
+                          type: "button",
+                          onClick: W,
+                          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__ */ R(jt, { "aria-hidden": "true", className: "ds:size-4" }),
+                            A("dashboardGrid.add")
+                          ]
+                        }
+                      )
+                    }
+                  )
+                ) : null
+              ]
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+Et.displayName = "DashboardGrid";
+const _r = Object.assign(Et, {
+  Widget: Mt
+});
+export {
+  _r as D,
+  Jt as d
+};
+//# sourceMappingURL=dashboard-grid-B2MB7SRS.js.map