@alfadocs/ui-kit-debug 1.67.0 → 1.68.0

package/dist/_chunks/dashboard-grid-7JzaiKnk.js

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