@daisforge/ui 1.10.3

package/chunks/GridDND-DCBTab4L.mjs

@@ -0,0 +1,1082 @@
+import { j as P } from "./vendor-BG4P-329.mjs";
+import "react-grid-layout/css/styles.css";
+import { iconButtonFilterClassNames as wt } from "../components/IconButton/index.mjs";
+import { useRef as q, useState as z, useLayoutEffect as Dt, useEffect as te, forwardRef as ht, useCallback as A, useMemo as De, useImperativeHandle as yt } from "react";
+import { b as Ke } from "./AnalyticalWidget-C7Eg_BvO.mjs";
+import { Responsive as Nt } from "react-grid-layout";
+import { c as bt } from "./utils-Ch8gMTzR.mjs";
+import { surfaceTransparentAccent as gt, outlineAccent as kt, outlineAccentMinor as vt, shadowDownHardS as Gt, outlineTransparentAccent as Ot, shadowDownSoftS as Mt } from "@salutejs/sdds-themes/tokens/sdds_finai";
+import Fe from "styled-components";
+const U = {
+  gridItemWrapper: "grid-dnd__item-wrapper",
+  gridItem: "grid-dnd__item",
+  dragHandle: "grid-dnd__drag-handle",
+  noDrag: "grid-dnd__no-drag"
+}, Ve = 248, Y = 6, Rt = ({
+  item: t,
+  actionsSlot: n,
+  actionsSlotStyle: r,
+  children: a
+}) => /* @__PURE__ */ P.jsxDEV(
+  "div",
+  {
+    style: { height: "100%", position: "relative" },
+    id: t.id,
+    className: U.gridItemWrapper,
+    children: [
+      n && /* @__PURE__ */ P.jsxDEV(
+        "div",
+        {
+          style: {
+            position: "absolute",
+            right: 16,
+            top: 16,
+            ...r
+          },
+          className: U.noDrag,
+          children: n
+        },
+        void 0,
+        !1,
+        {
+          fileName: "/home/runner/work/dais-ui/dais-ui/packages/ui-kit/src/components/GridDND/GridDND.ItemWrapper.tsx",
+          lineNumber: 25,
+          columnNumber: 3
+        },
+        void 0
+      ),
+      a
+    ]
+  },
+  void 0,
+  !0,
+  {
+    fileName: "/home/runner/work/dais-ui/dais-ui/packages/ui-kit/src/components/GridDND/GridDND.ItemWrapper.tsx",
+    lineNumber: 19,
+    columnNumber: 1
+  },
+  void 0
+);
+function At() {
+  const t = q(null), [n, r] = z(0);
+  return Dt(() => {
+    const a = t.current;
+    if (!a)
+      return;
+    let l = 0;
+    const o = bt((s) => {
+      var D;
+      const f = ((D = s[0]) == null ? void 0 : D.contentRect.width) ?? 0;
+      cancelAnimationFrame(l), l = requestAnimationFrame(() => r(f));
+    });
+    return o.observe(a), () => {
+      cancelAnimationFrame(l), o.disconnect();
+    };
+  }, []), { ref: t, width: n };
+}
+function Et(t) {
+  const { onWidthChange: n, margin: r, cols: a, containerPadding: l } = t, { ref: o, width: s } = At(), f = q(0);
+  return te(() => {
+    s > 0 && s !== f.current && (n == null || n(
+      s,
+      r,
+      a,
+      l
+    ), f.current = s);
+  }, [s, n, r, a, l]), /* @__PURE__ */ P.jsxDEV("div", { ref: o, style: { width: "100%" }, children: s > 0 && /* @__PURE__ */ P.jsxDEV(Nt, { ...t, width: s }, void 0, !1, {
+    fileName: "/home/runner/work/dais-ui/dais-ui/packages/ui-kit/src/components/GridDND/GridDND.MeasuredContainer.tsx",
+    lineNumber: 35,
+    columnNumber: 21
+  }, this) }, void 0, !1, {
+    fileName: "/home/runner/work/dais-ui/dais-ui/packages/ui-kit/src/components/GridDND/GridDND.MeasuredContainer.tsx",
+    lineNumber: 33,
+    columnNumber: 5
+  }, this);
+}
+const Ft = Fe.div.withConfig({ displayName: "GridDNDstyled__GridDNDContainer" })(
+  ["width:100%;min-height:400px;max-width:1890px;&:has(.react-grid-placeholder){& .react-grid-item.react-grid-placeholder{background-color:", ";border-radius:16px;outline:1px solid ", ";opacity:1;}}"],
+  () => gt,
+  () => kt
+), Ht = Fe.div.attrs(() => ({
+  className: U.gridItem
+})).withConfig({ displayName: "GridDNDstyled__GridItem" })(
+  ["&.react-draggable-dragging{outline:2px solid ", ";box-shadow:", ";cursor:grabbing;}& .", "{cursor:default;}height:100%;width:100%;cursor:", ";background-color:white;border-radius:16px;outline:", ";box-shadow:", ";overflow:hidden;"],
+  () => vt,
+  () => Gt,
+  Ke.topSlot,
+  (t) => t.$isDraggable ? "grab" : "default",
+  (t) => t.$isDraggable ? `2px solid ${Ot}` : "none",
+  () => Mt
+), Tt = Fe.div.withConfig({ displayName: "GridDNDstyled__GridItemContent" })(["height:100%;width:100%;"]), Wt = (t) => !t || t === "." || t === "-" || t === " ";
+function Zt(t, n, r, a) {
+  var f, D;
+  const l = [], o = r[n], s = /* @__PURE__ */ new Set();
+  for (let G = 0; G < t.length; G++) {
+    const O = t[G];
+    if (!O)
+      return l;
+    for (let i = 0; i < O.length; i++) {
+      const m = O[i];
+      if (!m || Wt(m) || s.has(`${m}`))
+        continue;
+      let p = 0;
+      for (let d = i; d < O.length && O[d] === m; d++)
+        p++;
+      let w = 0;
+      for (let d = G; d < t.length; d++) {
+        let N = !0;
+        for (let g = i; g < i + p; g++)
+          if (!((f = t[d]) != null && f[g]) || ((D = t[d]) == null ? void 0 : D[g]) !== m) {
+            N = !1;
+            break;
+          }
+        if (!N)
+          break;
+        w++;
+      }
+      for (let d = G; d < G + w; d++)
+        for (let N = i; N < i + p; N++)
+          s.add(`${m}`);
+      l.push({
+        i: m,
+        // ID элемента (имя из grid-template-areas)
+        x: i,
+        // X координата
+        y: G,
+        // Y координата
+        w: p,
+        // Ширина в колонках
+        h: w,
+        // Высота в строках
+        minW: 1,
+        // Минимальная ширина
+        maxW: o,
+        // Максимальная ширина (ограничена количеством колонок)
+        minH: 1,
+        // Минимальная высота
+        isResizable: a,
+        // Можно ли изменять размер
+        static: !1
+        // Элемент не статичный (можно перемещать)
+      });
+    }
+  }
+  return l;
+}
+function Lt(t) {
+  return Object.keys(t).sort((n, r) => (t[r] || 0) - (t[n] || 0));
+}
+function Ct(t, n) {
+  const r = Object.keys(t).sort((a, l) => {
+    const o = t[a] || 0;
+    return (t[l] || 0) - o;
+  });
+  for (const a of r) {
+    const l = t[a];
+    if (l !== void 0 && n >= l)
+      return a;
+  }
+  return r[r.length - 1];
+}
+function er(t, n, r) {
+  var l, o;
+  const a = r.indexOf(t);
+  if (a === -1)
+    return null;
+  for (let s = a - 1; s >= 0; s--) {
+    const f = r[s];
+    if (f && ((l = n[f]) != null && l.length))
+      return f;
+  }
+  for (let s = a + 1; s < r.length; s++) {
+    const f = r[s];
+    if (f && ((o = n[f]) != null && o.length))
+      return f;
+  }
+  return null;
+}
+function tr(t, n) {
+  const r = [...t].map((i) => ({
+    ...i,
+    // Ограничиваем ширину элемента количеством колонок
+    w: Math.max(1, Math.min(i.w, n))
+    // Старые координаты не важны - будем раскладывать заново
+  })).sort((i, m) => i.y - m.y || i.x - m.x), a = [], l = (i) => {
+    for (; a.length < i; )
+      a.push(Array(n).fill(!1));
+  }, o = (i, m, p, w) => {
+    l(m + w);
+    for (let d = m; d < m + w; d++) {
+      const N = a[d];
+      if (!N)
+        return !1;
+      for (let g = i; g < i + p; g++)
+        if (g >= n || N[g])
+          return !1;
+    }
+    return !0;
+  }, s = (i, m, p, w) => {
+    l(m + w);
+    for (let d = m; d < m + w; d++) {
+      const N = a[d];
+      if (N)
+        for (let g = i; g < i + p; g++)
+          g < N.length && (N[g] = !0);
+    }
+  }, f = (i) => {
+    let m = i;
+    for (; ; ) {
+      l(m + 1);
+      const p = a[m];
+      if (p && p.some((w) => !w))
+        return m;
+      m++;
+    }
+  };
+  let D = 0, G = 0;
+  const O = [];
+  for (const i of r) {
+    let m = !1;
+    for (let w = G; w <= n - i.w; w++)
+      if (o(w, D, i.w, i.h)) {
+        s(w, D, i.w, i.h), O.push({
+          ...i,
+          x: w,
+          y: D
+        }), G = w + i.w, G > n - 1 && (D = f(D), G = 0), m = !0;
+        break;
+      }
+    if (m)
+      continue;
+    D = f(D), G = 0;
+    let p = D;
+    for (; ; ) {
+      let w = !1;
+      for (let d = 0; d <= n - i.w; d++)
+        if (o(d, p, i.w, i.h)) {
+          s(d, p, i.w, i.h), O.push({
+            ...i,
+            x: d,
+            y: p
+          }), p === D && (G = d + i.w, G > n - 1 && (D = f(D), G = 0)), w = !0;
+          break;
+        }
+      if (w)
+        break;
+      p++;
+    }
+  }
+  return O;
+}
+const ee = (t) => t === "l" ? {
+  w: 2,
+  h: 2
+} : t === "m" ? {
+  w: 2,
+  h: 1
+} : {
+  w: 1,
+  h: 1
+};
+function Ee(t, n) {
+  if (!t || !n || t.length !== n.length)
+    return !1;
+  const r = [...t].sort((l, o) => l.i > o.i ? 1 : -1), a = [...n].sort((l, o) => l.i > o.i ? 1 : -1);
+  for (let l = 0; l < r.length; l += 1) {
+    const o = r[l], s = a[l];
+    if (!o || !s || o.i !== s.i || o.x !== s.x || o.y !== s.y || o.w !== s.w || o.h !== s.h)
+      return !1;
+  }
+  return !0;
+}
+function ye(t, n, r) {
+  for (; t.length < n; )
+    t.push(Array(r).fill(!1));
+}
+function jt(t, n, r) {
+  ye(t, n + 1, r);
+  const a = t[n];
+  return a ? a.some((l) => !l) : !1;
+}
+function he(t, n, r, a = 0) {
+  ye(t, n + 1, r);
+  const l = t[n];
+  if (!l)
+    return -1;
+  for (let o = Math.max(0, a); o < r; o++) {
+    if (o >= l.length)
+      return -1;
+    if (!l[o])
+      return o;
+  }
+  return -1;
+}
+function Xe(t, n, r, a, l, o) {
+  ye(t, r + l, o);
+  for (let s = r; s < r + l; s++) {
+    const f = t[s];
+    if (!f)
+      return !1;
+    for (let D = n; D < n + a; D++)
+      if (D >= o || f[D])
+        return !1;
+  }
+  return !0;
+}
+function St(t, n, r, a, l, o) {
+  ye(t, r + l, o);
+  for (let s = r; s < r + l; s++) {
+    const f = t[s];
+    if (f)
+      for (let D = n; D < n + a; D++)
+        D < o && (f[D] = !0);
+  }
+}
+function Ye(t, n, r) {
+  let a = Math.max(0, n);
+  for (; ; ) {
+    if (jt(t, a, r))
+      return a;
+    a++;
+  }
+}
+function _t(t, n, r, a) {
+  const l = [], o = [];
+  let s = 0, f = 0;
+  for (const D of t) {
+    const G = n[D];
+    if (!G)
+      continue;
+    const O = G, i = Math.max(1, Math.min(O.w, r)), m = Math.max(1, O.h);
+    let p = null;
+    for (let N = f; N <= r - i; N++)
+      if (Xe(o, N, s, i, m, r)) {
+        p = {
+          x: N,
+          y: s
+        };
+        break;
+      }
+    if (!p) {
+      let N = s + 1;
+      for (; ; ) {
+        for (let g = 0; g <= r - i; g++)
+          if (Xe(o, g, N, i, m, r)) {
+            p = {
+              x: g,
+              y: N
+            };
+            break;
+          }
+        if (p)
+          break;
+        N++;
+      }
+    }
+    const {
+      x: w,
+      y: d
+    } = p;
+    if (St(o, w, d, i, m, r), l.push({
+      i: D,
+      x: w,
+      y: d,
+      w: i,
+      h: m,
+      minW: 1,
+      maxW: r,
+      minH: 1,
+      isResizable: a,
+      static: !1
+    }), d > s)
+      s = d, f = Math.max(0, he(o, s, r, 0)), f === -1 && (s = Ye(o, s, r), f = he(o, s, r, 0));
+    else {
+      const N = he(o, s, r, w + i);
+      N === -1 ? (s = Ye(o, s, r), f = he(o, s, r, 0)) : f = N;
+    }
+  }
+  return l;
+}
+function ze(t) {
+  return [...t].sort((n, r) => n.y - r.y || n.x - r.x).map((n) => n.i);
+}
+const rr = (t) => Object.keys(t).sort((n, r) => (t[r] || 0) - (t[n] || 0))[0] ?? "lg";
+function qt(t, n, r, a, l = 0, o = 0) {
+  const s = t.reduce((i, m) => Math.max(i, m.y + m.h), 0), f = Array.from({
+    length: Math.max(s, o) + a + 1
+  }, () => Array(n).fill(!1));
+  for (const {
+    x: i,
+    y: m,
+    w: p,
+    h: w
+  } of t)
+    for (let d = m; d < m + w; d++) {
+      f[d] || (f[d] = Array(n).fill(!1));
+      const N = f[d];
+      for (let g = i; g < i + p; g++)
+        d >= 0 && g >= 0 && g < n && N && (N[g] = !0);
+    }
+  const D = (i, m) => {
+    for (let p = m; p < m + a; p++) {
+      f[p] || (f[p] = Array(n).fill(!1));
+      const w = f[p];
+      for (let d = i; d < i + r; d++)
+        if (d >= n || w && w[d])
+          return !1;
+    }
+    return !0;
+  }, G = (i, m) => {
+    for (let p = m; p < m + a; p++) {
+      f[p] || (f[p] = Array(n).fill(!1));
+      const w = f[p];
+      for (let d = i; d < i + r; d++)
+        d < n && w && (w[d] = !0);
+    }
+  };
+  let O = o;
+  for (; ; ) {
+    f[O] || (f[O] = Array(n).fill(!1));
+    for (let i = O === o ? l : 0; i <= n - r; i++)
+      if (D(i, O))
+        return G(i, O), {
+          x: i,
+          y: O
+        };
+    O++;
+  }
+}
+const nr = (t) => {
+  typeof requestAnimationFrame == "function" ? requestAnimationFrame(() => t(!1)) : setTimeout(() => t(!1), 0);
+}, Bt = ({ children: t, className: n }) => /* @__PURE__ */ P.jsxDEV(Tt, { className: n, children: t }, void 0, !1, {
+  fileName: "/home/runner/work/dais-ui/dais-ui/packages/ui-kit/src/components/GridDND/GridDND.tsx",
+  lineNumber: 47,
+  columnNumber: 1
+}, void 0), Pe = (...t) => (
+  // eslint-disable-next-line no-console
+  console.log("%c[GridDND]", "color:#6b5b95;font-weight:600", ...t)
+), It = ht(
+  ({
+    // Источник истины — последовательность
+    items: t,
+    // Адаптивность
+    breakpoints: n = { lg: 1375, md: 1143, sm: 911, xs: 679, xxs: 0 },
+    cols: r = { lg: 6, md: 5, sm: 4, xs: 3, xxs: 2 },
+    rowHeights: a = { lg: 248, md: 248, sm: 248, xs: 248, xxs: 248 },
+    // RGL поведение
+    isDraggable: l = !0,
+    isResizable: o = !1,
+    margin: s = [16, 16],
+    containerPadding: f = [0, 0],
+    preventCollision: D = !1,
+    allowOverlap: G = !1,
+    isBounded: O = !0,
+    autoSize: i = !0,
+    useCSSTransforms: m = !0,
+    compactType: p = "horizontal",
+    smartCompact: w = !0,
+    resizeHandles: d = ["se", "sw", "ne", "nw", "s", "w", "e", "n"],
+    draggableHandle: N = `.${U.dragHandle}`,
+    draggableCancel: g = `button, input, select, textarea, .${U.noDrag}, .${Ke.topSlot}, .${wt.root}`,
+    maxRows: Qe,
+    transformScale: Ue,
+    // Колбеки
+    onLayoutChange: M,
+    onBreakpointChange: re,
+    onItemsChange: E,
+    onWidthChange: ne,
+    onDrag: ie,
+    onDragStart: se,
+    onDragStop: oe,
+    // Контент
+    children: Ne,
+    // Задержка активации D&D
+    dragActivationDelay: be = 0,
+    // Стилизация
+    gridItemComponent: He,
+    containerStyle: Je,
+    gridStyle: Ze,
+    enableLogs: Te = !1
+  }, Le) => {
+    const [R, ce] = z(
+      () => t.map((e) => e.id)
+    ), J = q(
+      Object.fromEntries(t.map((e) => [e.id, ee(e.type)]))
+    ), ge = q(!1), Z = q({
+      lg: [],
+      md: [],
+      sm: [],
+      xs: [],
+      xxs: []
+    }), K = q("lg"), Q = q(
+      []
+    ), $ = be > 0, [ke, We] = z(!1), [Ce, ve] = z(null), le = q(
+      null
+    ), Ge = q(!1), Oe = q(null), ue = q(null), C = A(() => {
+      le.current && (clearTimeout(le.current), le.current = null);
+    }, []), ae = A(() => {
+      We(!1), ve(null), Ge.current = !1;
+    }, []), et = 64;
+    te(
+      () => {
+        if (!$ || !Oe.current)
+          return;
+        const e = Oe.current;
+        let u = null;
+        const c = (y, k) => {
+          const F = (T) => {
+            const W = T.clientX - y, V = T.clientY - k;
+            W * W + V * V > et && (C(), ve(null), ue.current = null, x());
+          };
+          document.addEventListener("pointermove", F), u = () => {
+            document.removeEventListener("pointermove", F), u = null;
+          };
+        }, x = () => {
+          u == null || u();
+        }, h = (y) => {
+          const k = y.target;
+          return y.offsetX > k.clientWidth || y.offsetY > k.clientHeight;
+        }, b = (y) => {
+          if (y._synthetic || y.button !== 0 || h(y))
+            return;
+          C(), x();
+          const F = y.target.closest(`.${U.gridItem}`), T = F == null ? void 0 : F.querySelector(`.${U.gridItemWrapper}`), W = (T == null ? void 0 : T.id) ?? null, V = F == null ? void 0 : F.querySelector(
+            `.${U.dragHandle}`
+          );
+          ve(W), ue.current = {
+            clientX: y.clientX,
+            clientY: y.clientY,
+            handleEl: V
+          }, c(y.clientX, y.clientY), le.current = setTimeout(() => {
+            x(), We(!0), requestAnimationFrame(() => {
+              requestAnimationFrame(() => {
+                const X = ue.current;
+                if (!(X != null && X.handleEl))
+                  return;
+                const xe = new MouseEvent("mousedown", {
+                  bubbles: !0,
+                  cancelable: !0,
+                  clientX: X.clientX,
+                  clientY: X.clientY,
+                  button: 0,
+                  buttons: 1
+                });
+                xe._synthetic = !0, X.handleEl.dispatchEvent(xe);
+              });
+            });
+          }, be);
+        }, v = () => {
+          C(), x(), ue.current = null, Ge.current || requestAnimationFrame(() => {
+            ae();
+          });
+        };
+        return e.addEventListener("pointerdown", b), document.addEventListener("pointerup", v), () => {
+          e.removeEventListener("pointerdown", b), document.removeEventListener("pointerup", v), C(), x();
+        };
+      },
+      [
+        $,
+        be,
+        C,
+        ae
+      ]
+    );
+    const je = $ ? l && ke : l, [B, Se] = z({
+      lg: [],
+      md: [],
+      sm: [],
+      xs: [],
+      xxs: []
+    }), [_e, tt] = z("lg"), [j, rt] = z(
+      a.lg ?? Ve
+    ), [nt, de] = z(p), [it, qe] = z(!1), st = De(
+      () => N.split(".").join(" "),
+      [N]
+    ), ot = De(
+      () => He ?? Bt,
+      [He]
+    ), fe = De(
+      () => new Map(t.map((e) => [e.id, e.type])),
+      [t]
+    ), L = q(/* @__PURE__ */ new Map()), me = A(
+      (e) => L.current.get(e) ?? fe.get(e) ?? "s",
+      [fe]
+    ), I = A(
+      (e) => e.map((u) => ({ id: u, type: me(u) })),
+      [me]
+    ), Me = A(
+      (e) => a[e] ?? a.md ?? Ve,
+      [a]
+    ), H = A(
+      (e, u, c) => {
+        const x = c ?? R, h = u[e] ?? [], b = Z.current[e] ?? [], v = new Map(h.map((k) => [k.i, k])), y = new Map(b.map((k) => [k.i, k]));
+        return x.map((k) => {
+          const F = me(k), T = v.get(k) ?? y.get(k) ?? null, W = J.current[k] ?? ee(F), V = T ? { x: T.x, y: T.y, w: T.w, h: T.h } : { x: 0, y: 0, w: W.w, h: W.h };
+          return { id: k, type: F, position: V };
+        });
+      },
+      [R, me]
+    ), Be = A(
+      (e) => {
+        const u = Z.current[e] ?? [];
+        return u.length ? u : B[e] ?? [];
+      },
+      [B]
+    ), S = A(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (...e) => {
+        Te && Pe(...e);
+      },
+      [Te]
+    ), pe = A((e) => {
+      Z.current = e, ge.current = !0, qe(!0), Se(e), requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          ge.current = !1, qe(!1), Pe("[GridDND] reflow window closed");
+        });
+      });
+    }, []), _ = A(
+      (e) => {
+        const u = {};
+        for (const c of Object.keys(r)) {
+          const x = r[c] ?? Y;
+          u[c] = _t(
+            e,
+            J.current,
+            x,
+            o
+          );
+        }
+        return S("reflowAllByOrder", { order: e, out: u }), pe(u), u;
+      },
+      [r, o, pe, S]
+    ), Ie = A(
+      (e, u) => {
+        if (!w)
+          return;
+        const c = Date.now();
+        if (Q.current.push({ x: e, y: u, timestamp: c }), Q.current = Q.current.filter(
+          (b) => c - b.timestamp <= 300
+        ), Q.current.length < 2)
+          return;
+        let x = 0, h = 0;
+        for (let b = 1; b < Q.current.length; b += 1) {
+          const v = Q.current[b - 1], y = Q.current[b];
+          !v || !y || (x += Math.abs(y.x - v.x), h += Math.abs(y.y - v.y));
+        }
+        x + h < 10 || (x > h * 1.5 ? de("horizontal") : h > x * 1.5 && de("vertical"));
+      },
+      [w]
+    ), $e = A(() => {
+      requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          const e = Z.current, u = {};
+          for (const [c, x] of Object.entries(e))
+            u[c] = x.map((h) => ({ ...h }));
+          S("[GridDND] forceSyncWithRgl → re-push target layouts"), pe(u);
+        });
+      });
+    }, [pe, S]);
+    te(() => {
+      _(t.map((e) => e.id));
+    }, []), te(() => {
+      const e = /* @__PURE__ */ new Set([...fe.keys(), ...R]);
+      L.current.forEach((u, c) => {
+        e.has(c) || L.current.delete(c);
+      });
+    }, [fe, R]), te(() => {
+      t.forEach((e) => {
+        J.current[e.id] || (J.current[e.id] = ee(e.type));
+      });
+    }, [t]);
+    const ct = A(
+      (e, u, c, x, h, b) => {
+        Q.current = [], de(p), $ && (Ge.current = !0), se == null || se(e, u, c, x, h, b);
+      },
+      [p, se, $]
+    ), lt = A(
+      (e, u, c, x, h, b) => {
+        Ie(h.clientX, h.clientY), ie == null || ie(e, u, c, x, h, b);
+      },
+      [Ie, ie]
+    ), ut = A(
+      (e, u, c, x, h, b) => {
+        oe == null || oe(e, u, c, x, h, b), $ && ae();
+        const v = ze(e);
+        S("[GridDND] dragStop: nextOrder(readingOrder)", v), ce(v);
+        const y = _(v), k = K.current, F = H(k, y, v);
+        E == null || E(F), M == null || M(
+          {
+            breakpoint: k,
+            cols: r[k] ?? Y,
+            rowHeight: j,
+            items: F
+          },
+          y,
+          { itemsOrder: v, itemsOrderTyped: I(v) }
+        ), de(p);
+        const T = e, W = y[k];
+        Ee(T, W) ? S("[GridDND] dragStop: live layout == target (OK)") : (S(
+          "[GridDND] dragStop: live layout != target → forceSyncWithRgl()"
+        ), $e());
+      },
+      [
+        oe,
+        $,
+        ae,
+        _,
+        H,
+        E,
+        M,
+        r,
+        j,
+        p,
+        $e,
+        S,
+        I
+      ]
+    ), at = A(
+      (e, u) => {
+        S("RGL onLayoutChange", { cur: e, all: u });
+        const c = K.current, x = (Z.current[c] ?? []).length;
+        if (e.length === x && Ee(e, Z.current[c])) {
+          S("[GridDND] onLayoutChange[IGNORED: equals-target]", { bp: c });
+          return;
+        }
+        if (ge.current) {
+          S("[GridDND] onLayoutChange[IGNORED: reflow-window]", {
+            bp: c,
+            cur: e
+          });
+          return;
+        }
+        const h = r[c] ?? Y;
+        if (e.some(
+          (y) => typeof y.maxW == "number" && y.maxW !== h
+        ))
+          return;
+        if (Ee(e, Z.current[c])) {
+          S("[GridDND] onLayoutChange[IGNORED: equals-target]", { bp: c });
+          return;
+        }
+        Se((y) => ({ ...y, [c]: e.map((k) => ({ ...k })) }));
+        const v = H(c, { ...B, [c]: e });
+        M == null || M(
+          {
+            breakpoint: c,
+            cols: h,
+            rowHeight: j,
+            items: v
+          },
+          { ...B, [c]: e },
+          { itemsOrder: R }
+        );
+      },
+      [
+        M,
+        H,
+        B,
+        r,
+        j,
+        R,
+        S
+      ]
+    ), dt = A(
+      (e) => {
+        K.current = e, tt(e), rt(Me(e));
+        const u = _(R), c = H(e, u, R);
+        re == null || re(e, {
+          breakpoint: e,
+          cols: r[e] ?? Y,
+          rowHeight: Me(e),
+          items: c
+        });
+      },
+      [
+        Me,
+        _,
+        R,
+        H,
+        re,
+        r
+      ]
+    ), ft = A(
+      (e, u, c, x) => {
+        ne == null || ne(e, u, c, x);
+      },
+      [ne]
+    ), Re = A(
+      (e) => {
+        L.current.delete(e), delete J.current[e], ce((u) => {
+          const c = u.filter((v) => v !== e), x = _(c), h = K.current, b = H(h, x, c);
+          return E == null || E(b), M == null || M(
+            {
+              breakpoint: h,
+              cols: r[h] ?? Y,
+              rowHeight: j,
+              items: b
+            },
+            x,
+            { itemsOrder: c, itemsOrderTyped: I(c) }
+          ), c;
+        });
+      },
+      [
+        _,
+        H,
+        E,
+        M,
+        r,
+        j,
+        I
+      ]
+    ), Ae = A(
+      (e, u) => {
+        if (!R.includes(e))
+          return;
+        L.current.set(e, u);
+        const c = K.current, x = r[c] ?? Y, h = ee(u);
+        J.current[e] = {
+          w: Math.max(1, Math.min(h.w, x)),
+          h: Math.max(1, h.h)
+        };
+        const b = _(R), v = H(c, b, R);
+        E == null || E(v), M == null || M(
+          {
+            breakpoint: c,
+            cols: x,
+            rowHeight: j,
+            items: v
+          },
+          b,
+          { itemsOrder: R, itemsOrderTyped: I(R) }
+        );
+      },
+      [
+        R,
+        r,
+        _,
+        H,
+        E,
+        M,
+        j,
+        I
+      ]
+    );
+    yt(
+      Le,
+      () => ({
+        api: {
+          getOrder: () => R,
+          getOrderDetailed: () => I(R),
+          setOrder: (e) => {
+            ce(e);
+            const u = _(e), c = K.current, x = H(c, u, e);
+            E == null || E(x), M == null || M(
+              {
+                breakpoint: c,
+                cols: r[c] ?? Y,
+                rowHeight: j,
+                items: x
+              },
+              u,
+              { itemsOrder: e, itemsOrderTyped: I(e) }
+            );
+          },
+          addItem: (e, u) => {
+            L.current.set(
+              e.id,
+              e.type
+            );
+            const c = ee(e.type), x = K.current, h = r[x] ?? Y, b = {
+              w: Math.max(1, Math.min(c.w, h)),
+              h: Math.max(1, c.h)
+            };
+            J.current[e.id] = b;
+            const v = Be(x);
+            let y = 0, k = 0;
+            if (u != null) {
+              const xe = Math.max(
+                0,
+                Math.min(u - 1, R.length - 1)
+              ), pt = R[xe], we = v.find((xt) => xt.i === pt);
+              we && (k = we.y, y = we.x + we.w);
+            }
+            const F = qt(
+              v,
+              h,
+              b.w,
+              b.h,
+              y,
+              k
+            ), T = v.concat(
+              [
+                { i: e.id, x: F.x, y: F.y, w: b.w, h: b.h }
+              ]
+            ), W = ze(T);
+            ce(W);
+            const V = _(W), X = H(x, V, W);
+            E == null || E(X), M == null || M(
+              {
+                breakpoint: x,
+                cols: h,
+                rowHeight: j,
+                items: X
+              },
+              V,
+              {
+                itemsOrder: W,
+                itemsOrderTyped: I(W)
+              }
+            );
+          },
+          removeItem: Re,
+          setItemType: Ae,
+          getAllLayouts: () => B,
+          getCurrentLayout: () => {
+            const e = K.current, u = H(e, B, R);
+            return {
+              breakpoint: e,
+              cols: r[e] ?? Y,
+              rowHeight: j,
+              items: u
+            };
+          }
+        }
+      }),
+      [
+        Re,
+        Ae,
+        R,
+        I,
+        _,
+        H,
+        E,
+        M,
+        r,
+        j,
+        Be,
+        B
+      ]
+    );
+    const mt = De(
+      () => H(_e, B, R),
+      [_e, B, R, H]
+    );
+    return /* @__PURE__ */ P.jsxDEV(
+      Ft,
+      {
+        ref: Oe,
+        style: {
+          ...Je,
+          ...$ && ke ? { userSelect: "none", touchAction: "none" } : {}
+        },
+        children: /* @__PURE__ */ P.jsxDEV(
+          Et,
+          {
+            className: "layout",
+            layouts: B,
+            breakpoints: n,
+            cols: r,
+            rowHeight: j,
+            margin: s,
+            containerPadding: f,
+            isDraggable: je,
+            isResizable: o,
+            onLayoutChange: at,
+            onBreakpointChange: dt,
+            autoSize: i,
+            useCSSTransforms: m,
+            preventCollision: D,
+            compactType: it ? null : w ? nt : p,
+            allowOverlap: G,
+            isBounded: O,
+            draggableHandle: N,
+            draggableCancel: g,
+            resizeHandles: o ? d : [],
+            maxRows: Qe,
+            transformScale: Ue,
+            onWidthChange: ft,
+            onDrag: lt,
+            onDragStart: ct,
+            onDragStop: ut,
+            style: { background: "transparent", ...Ze },
+            children: mt.map(
+              (e) => /* @__PURE__ */ P.jsxDEV(
+                Ht,
+                {
+                  $isDraggable: $ ? ke && Ce === e.id : l,
+                  children: /* @__PURE__ */ P.jsxDEV(
+                    ot,
+                    {
+                      isDraggable: je,
+                      className: st,
+                      children: typeof Ne == "function" ? Ne(
+                        e,
+                        () => Re(e.id),
+                        (u) => Ae(e.id, u)
+                      ) : Ne
+                    },
+                    void 0,
+                    !1,
+                    {
+                      fileName: "/home/runner/work/dais-ui/dais-ui/packages/ui-kit/src/components/GridDND/GridDND.tsx",
+                      lineNumber: 1088,
+                      columnNumber: 15
+                    },
+                    void 0
+                  )
+                },
+                e.id,
+                !1,
+                {
+                  fileName: "/home/runner/work/dais-ui/dais-ui/packages/ui-kit/src/components/GridDND/GridDND.tsx",
+                  lineNumber: 1080,
+                  columnNumber: 11
+                },
+                void 0
+              )
+            )
+          },
+          void 0,
+          !1,
+          {
+            fileName: "/home/runner/work/dais-ui/dais-ui/packages/ui-kit/src/components/GridDND/GridDND.tsx",
+            lineNumber: 1044,
+            columnNumber: 9
+          },
+          void 0
+        )
+      },
+      void 0,
+      !1,
+      {
+        fileName: "/home/runner/work/dais-ui/dais-ui/packages/ui-kit/src/components/GridDND/GridDND.tsx",
+        lineNumber: 1035,
+        columnNumber: 7
+      },
+      void 0
+    );
+  }
+), $t = Object.assign(It, {
+  ItemWrapper: Rt
+});
+$t.displayName = "GridDND";
+export {
+  $t as G,
+  U as a,
+  Ve as b,
+  Zt as c,
+  er as d,
+  tr as e,
+  Y as f,
+  Ct as g,
+  Wt as h,
+  ee as i,
+  rr as j,
+  qt as k,
+  Ee as l,
+  Lt as o,
+  _t as p,
+  ze as r,
+  nr as u
+};