@alfadocs/ui-kit 1.59.0 → 1.61.0

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

@@ -0,0 +1,1404 @@
+import { jsxs as pe, jsx as R } from "react/jsx-runtime";
+import { forwardRef as Nt, useRef as k, useState as B, useCallback as A, useMemo as se, useEffect as q, useImperativeHandle as Pt, useContext as Wt, Children as Dt, isValidElement as Ht, Fragment as zt, createContext as Xt, cloneElement as ct } from "react";
+import { c as le } from "./index-D2ZczOXr.js";
+import { useTranslation as wt } from "react-i18next";
+import { I as Xe } from "./icon-button-dNE6ENLn.js";
+import { D as Re } from "./dropdown-menu-D1we7oAY.js";
+import { T as Ft } from "./tooltip-Cp-PLePW.js";
+import { u as te } from "./use-isomorphic-layout-effect-BGfaCOP1.js";
+import { u as Yt } from "./registry-DvAUVLHh.js";
+import { P as Ot } from "./plus-DzMQ_c6b.js";
+import { X as jt } from "./x-B5YnXwCz.js";
+import { G as Vt } from "./grip-vertical-onSb1JXO.js";
+import { E as $t } 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" }]
+], qt = Kt("move-diagonal-2", Ut), Bt = {
+  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, s) => r.revealWidget(s.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, s) => r.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, 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, s) => r.resizeWidgetTo(s.id, s.w, s.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 H(r, s) {
+  return r.x < s.x + s.w && s.x < r.x + r.w && r.y < s.y + s.h && s.y < r.y + r.h;
+}
+function Ie(r, s) {
+  const i = Math.max(1, r.minW ?? 1), l = Math.max(1, r.minH ?? 1), g = Math.min(s, r.maxW ?? s), N = r.maxH ?? Number.POSITIVE_INFINITY, m = Math.min(Math.max(r.w, i), g), a = Math.min(Math.max(r.h, l), N), L = Math.min(Math.max(0, r.x), s - m), w = Math.max(0, r.y);
+  return { ...r, x: L, y: w, w: m, h: a };
+}
+function lt(r, s) {
+  if (s.some((i) => H(i, r))) return !1;
+  for (let i = r.y; i < r.y + r.h; i += 1)
+    if (!s.some(
+      (g) => g.x >= r.x + r.w && i >= g.y && i < g.y + g.h
+    )) return !1;
+  return !0;
+}
+function ut(r, s, i) {
+  return Math.abs(r.y * i + r.x - (s.y * i + s.x));
+}
+function ie(r, s, i, l) {
+  const g = r.map((o) => Ie(o, s)), N = [...g].sort((o, h) => o.id === i ? -1 : h.id === i ? 1 : o.y - h.y || o.x - h.x), m = [], a = i ? g.find((o) => o.id === i) : void 0, L = /* @__PURE__ */ new Set();
+  for (const o of N) {
+    if (o.id !== i) {
+      if (a && H(a, o)) {
+        const h = { ...o, y: Math.max(0, a.y - o.h) };
+        !H(a, h) && !m.some((M) => M.id !== i && H(M, h)) && (o.y = h.y);
+      }
+      if (m.some((h) => H(h, o))) {
+        L.add(o.id);
+        const h = g.filter((y) => y.id !== o.id);
+        let M = o.y;
+        for (; m.some((y) => H(y, { ...o, y: M })); )
+          M += 1;
+        let _ = null;
+        for (let y = Math.max(0, o.y - o.h); y <= M; y += 1)
+          for (let S = 0; S <= s - o.w; S += 1) {
+            const D = { ...o, x: S, y };
+            (lt(D, h) || l !== void 0 && H(l, D) && !h.some((z) => H(z, D))) && (!_ || ut({ x: S, y }, o, s) < ut(_, o, s)) && (_ = { x: S, y });
+          }
+        if (_)
+          o.x = _.x, o.y = _.y;
+        else {
+          o.y = M;
+          const y = a !== void 0 && a.x < o.x && o.x < a.x + a.w, S = a ? a.x : o.x;
+          for (; y && o.x > S && !h.some((D) => H(D, { ...o, x: o.x - 1 })); )
+            o.x -= 1;
+        }
+      }
+      for (; m.some((h) => H(h, o)); )
+        o.y += 1;
+      for (; o.y > 0; ) {
+        const h = { ...o, y: o.y - 1 };
+        if (m.some((M) => H(M, h))) break;
+        o.y -= 1;
+      }
+    }
+    m.push(o);
+  }
+  const w = a ? [...m].sort((o, h) => o.y - h.y || o.x - h.x) : [];
+  for (const o of w) {
+    if (o.id === i || L.has(o.id)) continue;
+    const h = m.filter((_) => _.id !== o.id);
+    let M = null;
+    for (let _ = 0; _ < o.y && !M; _ += 1) {
+      const y = Array.from(
+        { length: 2 * o.w + 1 },
+        (S, D) => o.x - o.w + D
+      ).filter((S) => S >= 0 && S <= s - o.w).sort((S, D) => Math.abs(S - o.x) - Math.abs(D - o.x) || S - D);
+      for (const S of y)
+        if (lt({ ...o, x: S, y: _ }, h)) {
+          M = { x: S, y: _ };
+          break;
+        }
+    }
+    if (M)
+      for (o.x = M.x, o.y = M.y; o.y > 0; ) {
+        const _ = { ...o, y: o.y - 1 };
+        if (h.some((y) => H(y, _))) break;
+        o.y -= 1;
+      }
+  }
+  const T = new Map(m.map((o) => [o.id, o]));
+  return r.map((o) => T.get(o.id));
+}
+function Jt(r, s, i, l, g) {
+  const N = r.map(
+    (m) => m.id === s ? Ie({ ...m, x: i, y: l }, g) : m
+  );
+  return ie(
+    N,
+    g,
+    s,
+    r.find((m) => m.id === s)
+  );
+}
+function Qt(r, s, i, l, g) {
+  const N = r.map(
+    (m) => m.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.
+      Ie(
+        {
+          ...m,
+          w: Math.max(m.minW ?? 1, Math.min(i, g - m.x)),
+          h: l
+        },
+        g
+      )
+    ) : m
+  );
+  return ie(N, g, s);
+}
+function ft(r, s, i, l) {
+  const g = Math.min(Math.max(1, i), s), N = r.reduce((m, a) => Math.max(m, a.y + a.h), 0);
+  for (let m = 0; m <= N; m += 1)
+    for (let a = 0; a <= s - g; a += 1) {
+      const L = {
+        x: a,
+        y: m,
+        w: g,
+        h: l
+      };
+      if (!r.some((w) => H(w, L)))
+        return { x: a, y: m };
+    }
+  return { x: 0, y: N };
+}
+function yt(r) {
+  return r.reduce((s, i) => Math.max(s, i.y + i.h), 0);
+}
+const Zt = 24;
+function mt(r, s, i) {
+  return s === void 0 || !Number.isFinite(s) || s <= 0 ? !1 : !Number.isFinite(r) || r <= 0 ? i : i ? r < s + Zt : r < s;
+}
+function er(r, s) {
+  const i = new Map(s.map((l) => [l.id, l]));
+  return r.map((l, g) => ({ id: l, index: g, entry: i.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 tr = le(
+  [
+    "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 }
+  }
+), rr = le(
+  [
+    "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" }
+  }
+), nr = le(
+  "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 = le(
+  [
+    "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(" ")
+), pt = le(
+  "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" }
+  }
+), Fe = "ds:bg-[var(--card)] ds:data-[component=icon-button]:sm:before:block", ir = le(
+  "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 }
+  }
+), or = le(
+  [
+    "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(" ")
+), xt = Xt(
+  null
+);
+function gt(r) {
+  return r !== void 0 && Number.isFinite(r) && r >= 1 ? Math.floor(r) : void 0;
+}
+function Le(r, s) {
+  Dt.forEach(r, (i) => {
+    if (Ht(i)) {
+      if (i.type === zt) {
+        Le(
+          i.props.children,
+          s
+        );
+        return;
+      }
+      s(i);
+    }
+  });
+}
+function kt({
+  id: r,
+  title: s,
+  minStackedHeight: i,
+  actions: l,
+  actionsSlot: g,
+  children: N
+}) {
+  var V, ue, oe;
+  const { t: m } = wt("ui"), a = Wt(xt), L = k(null), w = a == null ? void 0 : a.layoutById.get(r), [T, o] = B(null), [h, M] = B(!1), [_, y] = B(!1), [S, D] = B(!1);
+  if (q(() => {
+    if (!T) return;
+    const u = () => M(T.scrollWidth > T.clientWidth);
+    u();
+    const J = typeof document < "u" ? document.fonts : void 0;
+    J == null || J.addEventListener("loadingdone", u);
+    const $ = typeof ResizeObserver > "u" ? void 0 : new ResizeObserver(u);
+    return $ == null || $.observe(T), () => {
+      J == null || J.removeEventListener("loadingdone", u), $ == null || $.disconnect();
+    };
+  }, [T, s]), q(() => {
+    h || D(!1);
+  }, [h]), te(() => {
+    const u = L.current;
+    !u || !w || (u.style.setProperty("--dg-x", String(w.x + 1)), u.style.setProperty("--dg-y", String(w.y + 1)), u.style.setProperty("--dg-w", String(w.w)), u.style.setProperty("--dg-h", String(w.h)), u.style.setProperty(
+      "--dg-min-stacked",
+      i !== void 0 && Number.isFinite(i) && i > 0 ? `${i}px` : "auto"
+    ));
+  }, [w == null ? void 0 : w.x, w == null ? void 0 : w.y, w == null ? void 0 : w.w, w == null ? void 0 : w.h, w, i]), !a || !w) return null;
+  const G = ((V = a.grab) == null ? void 0 : V.id) === r, z = a.editing, I = [
+    ...l ?? [],
+    ...z && a.canRemove ? [
+      {
+        id: "__remove__",
+        label: m("dashboardGrid.remove", { title: s }),
+        icon: /* @__PURE__ */ R(jt, {}),
+        onSelect: () => a.requestRemove(r)
+      }
+    ] : []
+  ], E = I.length > 1, Ae = a.headingLevel ? `h${a.headingLevel}` : "span";
+  return /* @__PURE__ */ pe(
+    "div",
+    {
+      ref: L,
+      role: "listitem",
+      "aria-label": s,
+      "data-component": "dashboard-grid-widget",
+      "data-widget-id": r,
+      "data-grabbed": G || 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: rr({
+        stacked: a.stacked,
+        stackedHeight: a.stackedHeight
+      }),
+      children: [
+        /* @__PURE__ */ pe(
+          "div",
+          {
+            className: ir({ editing: z }),
+            onPointerDown: z ? (u) => a.startHeaderPress(r, u) : void 0,
+            children: [
+              z ? /* @__PURE__ */ R(
+                Xe,
+                {
+                  size: "sm",
+                  intent: "outline",
+                  type: "button",
+                  icon: /* @__PURE__ */ R(Vt, {}),
+                  "aria-label": m("dashboardGrid.move", { title: s }),
+                  "aria-pressed": G && ((ue = a.grab) == null ? void 0 : ue.kind) === "move",
+                  className: `ds:cursor-grab ds:touch-none ${Fe}`,
+                  onPointerDown: (u) => a.startPointerGrab("move", r, u),
+                  onKeyDown: (u) => a.keyboardStep(u, r),
+                  onClick: () => a.startKeyboardGrab("move", r)
+                }
+              ) : null,
+              /* @__PURE__ */ R(
+                Ft,
+                {
+                  label: s,
+                  open: h && S,
+                  onOpenChange: (u) => D(u && h),
+                  children: /* @__PURE__ */ R(
+                    Ae,
+                    {
+                      ref: o,
+                      tabIndex: h || _ ? 0 : void 0,
+                      "data-dashboard-grid-title": "",
+                      onFocus: () => y(!0),
+                      onBlur: () => y(!1),
+                      className: or(),
+                      children: s
+                    }
+                  )
+                }
+              ),
+              g,
+              I.length > 0 ? /* @__PURE__ */ R(
+                "div",
+                {
+                  className: pt({
+                    when: E ? "wide" : "always"
+                  }),
+                  children: I.map((u) => /* @__PURE__ */ R(
+                    Xe,
+                    {
+                      size: "sm",
+                      intent: "outline",
+                      type: "button",
+                      icon: u.icon,
+                      className: Fe,
+                      "aria-label": u.label,
+                      onClick: u.onSelect
+                    },
+                    u.id
+                  ))
+                }
+              ) : null,
+              E ? /* @__PURE__ */ R("div", { className: pt({ when: "narrow" }), children: /* @__PURE__ */ pe(Re.Root, { modal: !1, children: [
+                /* @__PURE__ */ R(Re.Trigger, { asChild: !0, children: /* @__PURE__ */ R(
+                  Xe,
+                  {
+                    size: "sm",
+                    intent: "outline",
+                    type: "button",
+                    icon: /* @__PURE__ */ R($t, {}),
+                    className: Fe,
+                    "aria-label": m("dashboardGrid.moreActions", { title: s })
+                  }
+                ) }),
+                /* @__PURE__ */ R(Re.Content, { align: "end", children: I.map((u) => /* @__PURE__ */ R(
+                  Re.Item,
+                  {
+                    startIcon: u.icon,
+                    onSelect: u.onSelect,
+                    children: u.label
+                  },
+                  u.id
+                )) })
+              ] }) }) : null
+            ]
+          }
+        ),
+        /* @__PURE__ */ R(
+          "div",
+          {
+            className: nr({
+              fit: a.stacked && a.stackedHeight === "content" ? "content" : "box",
+              editing: z
+            }),
+            children: N
+          }
+        ),
+        z ? /* @__PURE__ */ R(
+          "button",
+          {
+            type: "button",
+            "aria-label": m("dashboardGrid.resize", { title: s }),
+            "aria-pressed": G && ((oe = a.grab) == null ? void 0 : oe.kind) === "resize",
+            className: sr(),
+            onPointerDown: (u) => a.startPointerGrab("resize", r, u),
+            onKeyDown: (u) => a.keyboardStep(u, r),
+            onClick: () => a.startKeyboardGrab("resize", r),
+            children: /* @__PURE__ */ R(qt, { "aria-hidden": "true" })
+          }
+        ) : null
+      ]
+    }
+  );
+}
+kt.displayName = "DashboardGrid.Widget";
+const ht = 1e3, dr = 1600, ar = [
+  "button",
+  "a",
+  "input",
+  "select",
+  "textarea",
+  "label",
+  "summary",
+  '[contenteditable]:not([contenteditable="false"])',
+  '[role="button"]',
+  '[role="menuitem"]',
+  "[tabindex]:not([data-dashboard-grid-title])"
+].join(", "), vt = 4, cr = 400, lr = 8, Ye = 48, ur = 18;
+function fr(r) {
+  const s = {
+    x: null,
+    y: null
+  }, i = (l) => l === "auto" || l === "scroll" || l === "overlay";
+  for (let l = r.parentElement; l && l !== document.body && l !== document.documentElement && !(s.x && s.y); l = l.parentElement) {
+    const g = window.getComputedStyle(l);
+    !s.y && i(g.overflowY) && l.scrollHeight > l.clientHeight && (s.y = l), !s.x && i(g.overflowX) && l.scrollWidth > l.clientWidth && (s.x = l);
+  }
+  return s;
+}
+function me(r, s, i, l, g, N, m = !0) {
+  const a = r.find((h) => h.id === i);
+  if (!a) return r;
+  const L = m ? yt(r) + 2 : Number.POSITIVE_INFINITY, w = s === "move" ? Jt(r, i, l, Math.min(g, L - a.h), N) : Qt(r, i, l, Math.min(g, L - a.y), N), T = w.find((h) => h.id === i);
+  return T !== void 0 && T.x === a.x && T.y === a.y && T.w === a.w && T.h === a.h ? r : w;
+}
+function bt(r) {
+  if (r >= Ye) return 0;
+  const s = (Ye - Math.max(0, r)) / Ye;
+  return Math.ceil(s * ur);
+}
+const Mt = Nt(
+  ({
+    "aria-label": r,
+    id: s,
+    cols: i = 12,
+    rowHeight: l = 96,
+    layout: g,
+    defaultLayout: N,
+    onLayoutChange: m,
+    editing: a = !1,
+    onRemoveWidget: L,
+    onRequestAdd: w,
+    stackBelow: T,
+    onStackedChange: o,
+    stackedHeight: h = "grid",
+    selectedId: M,
+    widgetHeadingLevel: _,
+    children: y,
+    className: S
+  }, D) => {
+    const { t: G } = wt("ui"), z = k(null), I = k(null), [E, Ae] = B(!1), V = k(!1);
+    V.current = E;
+    const ue = k(null), oe = A((e) => {
+      var d;
+      if (e === V.current) return;
+      const t = z.current, n = typeof document < "u" ? document.activeElement : null;
+      ue.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, V.current = e, Ae(e);
+    }, []);
+    te(() => {
+      const e = z.current;
+      if (!e) return;
+      if (T === void 0) {
+        oe(!1);
+        return;
+      }
+      if (oe(
+        mt(e.offsetWidth, T, V.current)
+      ), typeof ResizeObserver > "u") return;
+      const t = new ResizeObserver((n) => {
+        var c, v;
+        const d = n[n.length - 1];
+        if (!d) return;
+        const f = ((v = (c = d.borderBoxSize) == null ? void 0 : c[0]) == null ? void 0 : v.inlineSize) ?? d.contentRect.width;
+        oe(mt(f, T, V.current));
+      });
+      return t.observe(e), () => t.disconnect();
+    }, [T, oe]);
+    const u = a && !E, J = se(() => {
+      const e = [];
+      return Le(y, (t) => {
+        t.props.id && e.push(t.props.id);
+      }), e;
+    }, [y]), $ = se(() => {
+      const e = /* @__PURE__ */ new Map();
+      return Le(y, (t) => {
+        t.props.id && e.set(t.props.id, {
+          defaultW: t.props.defaultW ?? 4,
+          defaultH: t.props.defaultH ?? 2,
+          minW: gt(t.props.minW),
+          minH: gt(t.props.minH)
+        });
+      }), e;
+    }, [y]), [St, Gt] = B(() => N ?? []), ye = g ?? St, Oe = k(ye);
+    Oe.current = ye;
+    const xe = A(
+      (e) => e.map((t) => {
+        const n = Oe.current.find((v) => v.id === t.id), { minW: d, minH: f, ...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 } : {}
+        };
+      }),
+      []
+    ), Q = A(
+      (e) => {
+        const t = xe(e);
+        g === void 0 && Gt(t), m == null || m(t);
+      },
+      [g, m, xe]
+    ), { resolved: W, autoPlaced: je } = se(() => {
+      const e = (f) => {
+        const c = $.get(f.id);
+        return Ie(
+          {
+            ...f,
+            ...(c == null ? void 0 : c.minW) !== void 0 ? { minW: Math.max(f.minW ?? 1, c.minW) } : {},
+            ...(c == null ? void 0 : c.minH) !== void 0 ? { minH: Math.max(f.minH ?? 1, c.minH) } : {}
+          },
+          i
+        );
+      }, t = ye.map(e), n = J.filter(
+        (f) => !t.some((c) => c.id === f)
+      );
+      if (n.length === 0)
+        return {
+          resolved: t.some(
+            (c, v) => t.some((x, p) => p > v && H(c, x))
+          ) ? ie(t, i) : t,
+          autoPlaced: !1
+        };
+      const d = [...t];
+      for (const f of n) {
+        const c = $.get(f) ?? { defaultW: 4, defaultH: 2 }, v = Math.min(Math.max(c.defaultW, c.minW ?? 1), i), x = Math.max(c.defaultH, c.minH ?? 1), p = ft(d, i, v, x);
+        d.push(e({ id: f, x: p.x, y: p.y, w: v, h: x }));
+      }
+      return { resolved: ie(d, i), autoPlaced: !0 };
+    }, [ye, J, $, i]), Ve = k("");
+    q(() => {
+      if (!je) return;
+      const e = W.map(
+        (t) => `${t.id}:${t.x},${t.y},${t.w},${t.h}`
+      ).join("|");
+      Ve.current !== e && (Ve.current = e, Q(W));
+    }, [je, W, Q]);
+    const [Et, Tt] = B(null), [de, $e] = B(null), [_t, ae] = B(""), Ne = k(null), j = k(null), ce = k(null), Pe = k(!1), ge = k(i);
+    ge.current = i;
+    const fe = k(W);
+    fe.current = W;
+    const re = A((e) => {
+      Ne.current = e, Tt(e);
+    }, []), ke = A(
+      (e, t, n) => {
+        const d = { kind: e, id: t, via: n };
+        j.current = { ...d, baseLayout: fe.current }, $e(d), re(fe.current);
+      },
+      [re]
+    ), he = Et ?? W, Ke = se(
+      () => new Map(he.map((e) => [e.id, e])),
+      [he]
+    ), Ue = A(
+      (e, t) => {
+        ae(
+          e === "move" ? G("dashboardGrid.movedTo", { col: t.x + 1, row: t.y + 1 }) : G("dashboardGrid.resizedTo", { cols: t.w, rows: t.h })
+        );
+      },
+      [G]
+    ), F = k(null), Y = A(
+      (e) => {
+        var v;
+        (v = F.current) == null || v.call(F), F.current = null;
+        const t = Ne.current, n = j.current;
+        if (j.current = null, ce.current = null, $e(null), re(null), !e || !t || !n) {
+          ae(G("dashboardGrid.cancelled"));
+          return;
+        }
+        const d = ie(t, ge.current), f = (x) => x.map((p) => `${p.id}:${p.x},${p.y},${p.w},${p.h}`).join("|");
+        if (f(d) === f(fe.current)) {
+          ae(G("dashboardGrid.cancelled"));
+          return;
+        }
+        Q(d);
+        const c = d.find((x) => x.id === n.id);
+        ae(
+          c ? G("dashboardGrid.droppedAt", {
+            col: c.x + 1,
+            row: c.y + 1
+          }) : G("dashboardGrid.cancelled")
+        );
+      },
+      [re, Q, G]
+    ), We = k(Y);
+    We.current = Y;
+    const qe = A(
+      (e, t) => {
+        if (!u) return;
+        if (Pe.current) {
+          Pe.current = !1;
+          return;
+        }
+        const n = j.current;
+        if ((n == null ? void 0 : n.via) !== "pointer") {
+          if (n && n.id === t && n.kind === e) {
+            Y(!0);
+            return;
+          }
+          ke(e, t, "keyboard"), ae(
+            G(e === "move" ? "dashboardGrid.grabbed" : "dashboardGrid.resizeGrabbed")
+          );
+        }
+      },
+      [u, ke, Y, G]
+    ), Be = A(
+      (e, t) => {
+        const n = j.current;
+        if (!n || n.id !== t || n.via !== "keyboard")
+          return;
+        if (e.key === "Escape") {
+          e.preventDefault(), Y(!1);
+          return;
+        }
+        if (!["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(e.key)) return;
+        e.preventDefault();
+        const f = typeof window < "u" && I.current ? window.getComputedStyle(I.current).direction === "rtl" : !1, c = e.key === "ArrowRight" ? f ? -1 : 1 : e.key === "ArrowLeft" ? f ? 1 : -1 : 0, v = e.key === "ArrowDown" ? 1 : e.key === "ArrowUp" ? -1 : 0, p = (Ne.current ?? n.baseLayout).find((P) => P.id === t);
+        if (!p) return;
+        const b = n.kind === "move" ? me(
+          n.baseLayout,
+          "move",
+          t,
+          p.x + c,
+          p.y + v,
+          i
+        ) : me(
+          n.baseLayout,
+          "resize",
+          t,
+          p.w + c,
+          p.h + v,
+          i
+        );
+        re(b);
+        const C = b.find((P) => P.id === t);
+        C && Ue(n.kind, C);
+      },
+      [i, Y, re, Ue]
+    ), ve = A(() => {
+      const e = ce.current, t = j.current, n = I.current;
+      if (!e || !t || !n) return;
+      const d = n.getBoundingClientRect(), f = e.lastClientX - d.left - e.startGridX, c = e.lastClientY - d.top - e.startGridY, v = Math.round(f / e.colStride) * (e.isRtl ? -1 : 1), x = Math.round(c / e.rowStride), { origin: p } = e;
+      re(
+        e.kind === "move" ? me(
+          t.baseLayout,
+          "move",
+          e.id,
+          p.x + v,
+          p.y + x,
+          ge.current
+        ) : me(
+          t.baseLayout,
+          "resize",
+          e.id,
+          p.w + v,
+          p.h + x,
+          ge.current
+        )
+      );
+    }, [re]), Me = k(!1), Je = A(() => {
+      var x;
+      (x = F.current) == null || x.call(F);
+      const e = (p) => {
+        const b = ce.current;
+        !b || p.pointerId !== b.pointerId || (b.lastClientX = p.clientX, b.lastClientY = p.clientY, b.travelled || (b.travelled = Math.hypot(
+          p.clientX - b.pressX,
+          p.clientY - b.pressY
+        ) > vt), ve());
+      }, t = (p) => (b) => {
+        const C = ce.current;
+        !C || b.pointerId !== C.pointerId || (Pe.current = C.fromHandle, We.current(p));
+      }, n = t(!0), d = t(!1), f = () => ve();
+      let c = 0;
+      const v = () => {
+        c = requestAnimationFrame(v);
+        const p = ce.current;
+        if (!(p != null && p.travelled)) return;
+        const b = I.current;
+        if (!b) return;
+        const { lastClientX: C, lastClientY: P } = p, K = fr(b), Ce = (U, dt, ee) => {
+          const ze = ee ? window.innerHeight : window.innerWidth, O = U == null ? void 0 : U.getBoundingClientRect(), Lt = Math.max(
+            ee ? (O == null ? void 0 : O.top) ?? 0 : (O == null ? void 0 : O.left) ?? 0,
+            0
+          ), It = Math.min(
+            ee ? (O == null ? void 0 : O.bottom) ?? ze : (O == null ? void 0 : O.right) ?? ze,
+            ze
+          ), we = bt(It - dt) - bt(dt - Lt);
+          if (we === 0) return;
+          const at = () => U ? ee ? U.scrollTop : U.scrollLeft : ee ? window.scrollY : window.scrollX, At = at();
+          U == null || U.scrollBy(ee ? 0 : we, ee ? we : 0), (!U || at() === At) && window.scrollBy(ee ? 0 : we, ee ? we : 0);
+        };
+        Ce(K.y, P, !0), Ce(K.x, C, !1);
+      };
+      c = requestAnimationFrame(v), window.addEventListener("pointermove", e), window.addEventListener("pointerup", n), window.addEventListener("pointercancel", d), window.addEventListener("scroll", f, {
+        capture: !0,
+        passive: !0
+      }), F.current = () => {
+        cancelAnimationFrame(c), Me.current = !1, window.removeEventListener("pointermove", e), window.removeEventListener("pointerup", n), window.removeEventListener("pointercancel", d), window.removeEventListener("scroll", f, { capture: !0 });
+      };
+    }, [ve]);
+    q(
+      () => () => {
+        var e;
+        (e = F.current) == null || e.call(F), F.current = null;
+      },
+      []
+    );
+    const Se = A(
+      (e, t, n, d, f) => {
+        var K;
+        const c = I.current, v = fe.current.find((Ce) => Ce.id === t);
+        if (!c || !v) return !1;
+        const x = c.getBoundingClientRect();
+        if (x.width <= 0) return !1;
+        const p = window.getComputedStyle(c), b = Number.parseFloat(p.columnGap) || 0, C = Number.parseFloat(p.rowGap) || 0, P = (x.width - b * (i - 1)) / i;
+        ce.current = {
+          kind: e,
+          id: t,
+          pointerId: n.pointerId,
+          startGridX: n.clientX - x.left,
+          startGridY: n.clientY - x.top,
+          lastClientX: n.clientX,
+          lastClientY: n.clientY,
+          origin: v,
+          colStride: P + b,
+          rowStride: l + C,
+          isRtl: p.direction === "rtl",
+          fromHandle: f,
+          pressX: n.clientX,
+          pressY: n.clientY,
+          travelled: !1
+        };
+        try {
+          (K = d.setPointerCapture) == null || K.call(d, n.pointerId);
+        } catch {
+        }
+        return ke(e, t, "pointer"), Je(), !0;
+      },
+      [i, l, ke, Je]
+    ), Qe = A(
+      (e, t, n) => {
+        var d, f;
+        u && (j.current || (n.preventDefault(), (f = (d = n.currentTarget).focus) == null || f.call(d), Se(e, t, n, n.currentTarget, !0)));
+      },
+      [u, Se]
+    ), Z = k(null), ne = A(() => {
+      const e = Z.current;
+      Z.current = null, e && (e.holdTimer && clearTimeout(e.holdTimer), e.cleanup());
+    }, []), Ze = A(
+      (e, t) => {
+        if (!u || j.current || Z.current || t.button !== 0 || !t.isPrimary) return;
+        const n = t.target;
+        if (!t.currentTarget.contains(n)) return;
+        const d = n.closest(ar);
+        if (d && t.currentTarget.contains(d)) return;
+        const f = t.currentTarget, c = t.pointerType === "touch";
+        c || t.preventDefault();
+        const v = (b, C) => {
+          const P = Z.current;
+          if (ne(), !(!P || j.current) && Se(
+            "move",
+            P.id,
+            {
+              pointerId: P.pointerId,
+              clientX: P.startClientX,
+              clientY: P.startClientY
+            },
+            P.surface,
+            !1
+          )) {
+            Me.current = c;
+            const K = ce.current;
+            K && (K.lastClientX = b, K.lastClientY = C, K.travelled = !c), ve();
+          }
+        }, x = (b) => {
+          const C = Z.current;
+          if (!C || b.pointerId !== C.pointerId) return;
+          const P = Math.hypot(
+            b.clientX - C.startClientX,
+            b.clientY - C.startClientY
+          );
+          c ? P > lr && ne() : P > vt && v(b.clientX, b.clientY);
+        }, p = (b) => {
+          var C;
+          b.pointerId === ((C = Z.current) == null ? void 0 : C.pointerId) && ne();
+        };
+        window.addEventListener("pointermove", x), window.addEventListener("pointerup", p), window.addEventListener("pointercancel", p), Z.current = {
+          id: e,
+          pointerId: t.pointerId,
+          pointerType: t.pointerType,
+          startClientX: t.clientX,
+          startClientY: t.clientY,
+          surface: f,
+          holdTimer: c ? setTimeout(() => {
+            const b = Z.current;
+            b && v(b.startClientX, b.startClientY);
+          }, cr) : null,
+          cleanup: () => {
+            window.removeEventListener("pointermove", x), window.removeEventListener("pointerup", p), window.removeEventListener("pointercancel", p);
+          }
+        };
+      },
+      [u, Se, ve, ne]
+    );
+    q(() => {
+      u || (ne(), j.current && We.current(!1));
+    }, [u, ne]), q(() => ne, [ne]), q(() => {
+      const e = I.current;
+      if (!u || !e) return;
+      const t = (d) => {
+        Me.current && d.cancelable && d.preventDefault();
+      }, n = (d) => {
+        (Z.current || Me.current) && d.preventDefault();
+      };
+      return e.addEventListener("touchmove", t, { passive: !1 }), e.addEventListener("contextmenu", n), () => {
+        e.removeEventListener("touchmove", t), e.removeEventListener("contextmenu", n);
+      };
+    }, [u]), q(() => {
+      if (!de) return;
+      const e = (t) => {
+        t.key === "Escape" && Y(!1);
+      };
+      return window.addEventListener("keydown", e), () => window.removeEventListener("keydown", e);
+    }, [de, Y]), q(() => {
+      if (!de || de.via !== "keyboard") return;
+      const e = (n) => {
+        var f;
+        const d = n.relatedTarget;
+        (!d || !((f = I.current) != null && f.contains(d))) && Y(!1);
+      }, t = I.current;
+      return t == null || t.addEventListener("focusout", e), () => t == null ? void 0 : t.removeEventListener("focusout", e);
+    }, [de, Y]), te(() => {
+      E && (j.current && Y(!1), a && ae(G("dashboardGrid.stackedReadOnly")));
+    }, [E, a, Y, G]), te(() => {
+      var f;
+      const e = ue.current;
+      ue.current = null;
+      const t = z.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;
+      }
+      (f = I.current) == null || f.focus();
+    }, [E]);
+    const Ge = k(o);
+    Ge.current = o;
+    const et = k(!1);
+    te(() => {
+      var e;
+      et.current !== E && (et.current = E, (e = Ge.current) == null || e.call(Ge, E));
+    }, [E]), te(() => {
+      const e = I.current;
+      e && (e.style.setProperty("--dg-cols", String(i)), e.style.setProperty("--dg-row", `${l}px`));
+    }, [i, l]);
+    const tt = yt(he);
+    te(() => {
+      const e = I.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)) / ${i})), 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(${tt + 2} * (${l}px + var(--spacing-md)) - var(--spacing-md))`
+      ));
+    }, [i, l, tt]);
+    const rt = k(null), De = u && !!w, Ee = se(
+      () => De ? ft(he, i, 2, 2) : null,
+      [De, he, i]
+    );
+    te(() => {
+      const e = rt.current;
+      !e || !Ee || (e.style.setProperty("--dg-x", String(Ee.x + 1)), e.style.setProperty("--dg-y", String(Ee.y + 1)), e.style.setProperty("--dg-w", "2"), e.style.setProperty("--dg-h", "2"));
+    }, [Ee]);
+    const nt = A(
+      (e) => {
+        Q(
+          ie(
+            fe.current.filter((t) => t.id !== e),
+            ge.current
+          )
+        ), ae(G("dashboardGrid.removed")), L == null || L(e), requestAnimationFrame(() => {
+          const t = I.current;
+          if (!t) return;
+          const n = t.querySelector("button");
+          n ? n.focus() : t.focus();
+        });
+      },
+      [Q, L, G]
+    ), [st, it] = B(null), X = k(null), be = k(null), Te = k(0), _e = A(() => {
+      var c;
+      const e = X.current, t = I.current;
+      if (!e || !t) return !1;
+      const n = Array.from(
+        t.querySelectorAll("[data-widget-id]")
+      ).find((v) => v.getAttribute("data-widget-id") === e.id), d = n == null ? void 0 : n.getBoundingClientRect();
+      if (!n || !d || d.height <= 0)
+        return performance.now() > e.deadline && (X.current = null, e.resolve(!1)), !1;
+      X.current = null;
+      const f = ((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: f ? "auto" : "smooth"
+      }), it(e.id), be.current && clearTimeout(be.current), be.current = setTimeout(
+        () => it(null),
+        dr
+      ), e.resolve(!0), !0;
+    }, []), ot = A(
+      (e) => new Promise((t) => {
+        var c;
+        (c = X.current) == null || c.resolve(!1), cancelAnimationFrame(Te.current);
+        const n = setTimeout(() => {
+          const v = X.current;
+          (v == null ? void 0 : v.resolve) === d && !_e() && X.current === v && (X.current = null, d(!1));
+        }, ht), d = (v) => {
+          clearTimeout(n), t(v);
+        };
+        X.current = {
+          id: e,
+          deadline: performance.now() + ht,
+          resolve: d
+        };
+        const f = () => {
+          X.current && !_e() && X.current && (Te.current = requestAnimationFrame(f));
+        };
+        Te.current = requestAnimationFrame(f);
+      }),
+      [_e]
+    );
+    te(() => {
+      X.current && _e();
+    }), q(
+      () => () => {
+        var e;
+        cancelAnimationFrame(Te.current), be.current && clearTimeout(be.current), (e = X.current) == null || e.resolve(!1), X.current = null;
+      },
+      []
+    );
+    const He = se(
+      () => ({
+        moveWidgetTo(e, t, n) {
+          if (!u || V.current || !Number.isFinite(t) || !Number.isFinite(n) || !W.some((f) => f.id === e)) return !1;
+          const d = me(
+            W,
+            "move",
+            e,
+            Math.round(t),
+            Math.round(n),
+            i,
+            !1
+          );
+          return d !== W && Q(ie(d, i)), !0;
+        },
+        resizeWidgetTo(e, t, n) {
+          if (!u || V.current || !Number.isFinite(t) || !Number.isFinite(n) || !W.some((f) => f.id === e)) return !1;
+          const d = me(
+            W,
+            "resize",
+            e,
+            Math.round(t),
+            Math.round(n),
+            i,
+            !1
+          );
+          return d !== W && Q(ie(d, i)), !0;
+        },
+        revealWidget: ot,
+        getGridState() {
+          return {
+            cols: i,
+            editing: a,
+            stacked: E,
+            layout: xe(W),
+            selectedId: M ?? null
+          };
+        }
+      }),
+      [
+        u,
+        a,
+        E,
+        W,
+        i,
+        Q,
+        xe,
+        ot,
+        M
+      ]
+    );
+    Pt(D, () => He, [He]), Yt(Bt, He, s);
+    const Ct = se(
+      () => ({
+        editing: u,
+        stacked: E,
+        stackedHeight: h,
+        selectedId: M,
+        revealedId: st,
+        headingLevel: _,
+        layoutById: Ke,
+        grab: de,
+        canRemove: !!L,
+        requestRemove: nt,
+        startKeyboardGrab: qe,
+        keyboardStep: Be,
+        startPointerGrab: Qe,
+        startHeaderPress: Ze
+      }),
+      [
+        u,
+        E,
+        h,
+        M,
+        st,
+        _,
+        Ke,
+        de,
+        L,
+        nt,
+        qe,
+        Be,
+        Qe,
+        Ze
+      ]
+    ), Rt = se(() => {
+      if (T === void 0) return y;
+      const e = [], t = /* @__PURE__ */ new Map(), n = [];
+      return Le(y, (d) => {
+        const f = d.props.id;
+        if (f && !t.has(f)) {
+          const c = ct(d, {
+            key: `widget:${f}:${d.key ?? ""}`
+          });
+          t.set(f, c), e.push(c);
+        } else {
+          const c = ct(d, {
+            key: d.key === null ? `child:at:${n.length}` : `child:key:${d.key}`
+          });
+          n.push(c), e.push(c);
+        }
+      }), E ? [
+        ...er([...t.keys()], W).map(
+          (d) => t.get(d)
+        ),
+        ...n
+      ] : e;
+    }, [T, y, E, W]);
+    return /* @__PURE__ */ pe(
+      "div",
+      {
+        ref: z,
+        "data-component": "dashboard-grid",
+        "data-component-id": s,
+        "data-editing": u || void 0,
+        "data-stacked": E || void 0,
+        className: `ds:block ds:w-full ${S ?? ""}`.trim(),
+        children: [
+          /* @__PURE__ */ R("div", { role: "status", "aria-live": "polite", className: "ds:sr-only", children: _t }),
+          /* @__PURE__ */ pe(
+            "div",
+            {
+              ref: I,
+              role: "list",
+              "aria-label": r,
+              tabIndex: -1,
+              "data-editing": u || void 0,
+              "data-stacked": E || void 0,
+              className: tr({ stacked: E }),
+              children: [
+                /* @__PURE__ */ R(xt.Provider, { value: Ct, children: Rt }),
+                De ? (
+                  // role="list" allows only listitem children — the tile wrapper
+                  // carries the grid placement, the button fills it.
+                  /* @__PURE__ */ R(
+                    "div",
+                    {
+                      ref: rt,
+                      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__ */ pe(
+                        "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(Ot, { "aria-hidden": "true", className: "ds:size-4" }),
+                            G("dashboardGrid.add")
+                          ]
+                        }
+                      )
+                    }
+                  )
+                ) : null
+              ]
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+Mt.displayName = "DashboardGrid";
+const Tr = Object.assign(Mt, {
+  Widget: kt
+});
+export {
+  Tr as D,
+  Bt as d
+};
+//# sourceMappingURL=dashboard-grid-DRnhIlT-.js.map