@epilot/zenith-react 0.1.0-next.0 → 0.1.0

package/dist/vendor/.bun/@dnd-kit_sortable@10.0.0_1d291640e1250bbe/vendor/@dnd-kit/sortable/dist/sortable.esm.js

@@ -1,368 +1,483 @@
-import H, { useMemo as E, useRef as z, useEffect as L, useContext as le, useState as fe } from "react";
-import { useDndContext as ge, useDroppable as pe, useDraggable as ve, getClientRect as be, KeyboardCode as O } from "../../../../../@dnd-kit_core@6.3.1_6f4b9a1cfb20c0ae/vendor/@dnd-kit/core/dist/core.esm.js";
-import { useUniqueId as me, useIsomorphicLayoutEffect as K, useCombinedRefs as Ie, isKeyboardEvent as xe, CSS as U } from "../../../../../@dnd-kit_utilities@3.2.2_62547eec5a2188e3/vendor/@dnd-kit/utilities/dist/utilities.esm.js";
-function V(e, n, t) {
+import q, { useMemo as _, useRef as X, useEffect as k, useContext as pe, useState as be } from "react";
+import { useDndContext as ve, useDroppable as he, useDraggable as xe, KeyboardCode as m, closestCorners as Ie, getFirstCollision as me, getScrollableAncestors as we, getClientRect as ye } from "../../../../../@dnd-kit_core@6.3.1_6f4b9a1cfb20c0ae/vendor/@dnd-kit/core/dist/core.esm.js";
+import { useUniqueId as Re, useIsomorphicLayoutEffect as B, useCombinedRefs as Ce, isKeyboardEvent as Se, CSS as H, subtract as De } from "../../../../../@dnd-kit_utilities@3.2.2_62547eec5a2188e3/vendor/@dnd-kit/utilities/dist/utilities.esm.js";
+function V(e, t, o) {
   const r = e.slice();
-  return r.splice(t < 0 ? r.length + t : t, 0, r.splice(n, 1)[0]), r;
+  return r.splice(o < 0 ? r.length + o : o, 0, r.splice(t, 1)[0]), r;
 }
-function he(e, n) {
-  return e.reduce((t, r, o) => {
-    const s = n.get(r);
-    return s && (t[o] = s), t;
+function Ae(e, t) {
+  return e.reduce((o, r, n) => {
+    const s = t.get(r);
+    return s && (o[n] = s), o;
   }, Array(e.length));
 }
-function N(e) {
+function O(e) {
   return e !== null && e >= 0;
 }
-function ye(e, n) {
-  if (e === n)
+function Te(e, t) {
+  if (e === t)
     return !0;
-  if (e.length !== n.length)
+  if (e.length !== t.length)
     return !1;
-  for (let t = 0; t < e.length; t++)
-    if (e[t] !== n[t])
+  for (let o = 0; o < e.length; o++)
+    if (e[o] !== t[o])
       return !1;
   return !0;
 }
-function Re(e) {
+function Ne(e) {
   return typeof e == "boolean" ? {
     draggable: e,
     droppable: e
   } : e;
 }
-const j = (e) => {
+const E = {
+  scaleX: 1,
+  scaleY: 1
+}, je = (e) => {
+  var t;
+  let {
+    rects: o,
+    activeNodeRect: r,
+    activeIndex: n,
+    overIndex: s,
+    index: i
+  } = e;
+  const a = (t = o[n]) != null ? t : r;
+  if (!a)
+    return null;
+  const d = Oe(o, i, n);
+  if (i === n) {
+    const c = o[s];
+    return c ? {
+      x: n < s ? c.left + c.width - (a.left + a.width) : c.left - a.left,
+      y: 0,
+      ...E
+    } : null;
+  }
+  return i > n && i <= s ? {
+    x: -a.width - d,
+    y: 0,
+    ...E
+  } : i < n && i >= s ? {
+    x: a.width + d,
+    y: 0,
+    ...E
+  } : {
+    x: 0,
+    y: 0,
+    ...E
+  };
+};
+function Oe(e, t, o) {
+  const r = e[t], n = e[t - 1], s = e[t + 1];
+  return !r || !n && !s ? 0 : o < t ? n ? r.left - (n.left + n.width) : s.left - (r.left + r.width) : s ? s.left - (r.left + r.width) : r.left - (n.left + n.width);
+}
+const J = (e) => {
   let {
-    rects: n,
-    activeIndex: t,
+    rects: t,
+    activeIndex: o,
     overIndex: r,
-    index: o
+    index: n
   } = e;
-  const s = V(n, r, t), i = n[o], a = s[o];
+  const s = V(t, r, o), i = t[n], a = s[n];
   return !a || !i ? null : {
     x: a.left - i.left,
     y: a.top - i.top,
     scaleX: a.width / i.width,
     scaleY: a.height / i.height
   };
-}, A = {
+}, L = {
   scaleX: 1,
   scaleY: 1
-}, ze = (e) => {
-  var n;
+}, qe = (e) => {
+  var t;
   let {
-    activeIndex: t,
+    activeIndex: o,
     activeNodeRect: r,
-    index: o,
+    index: n,
     rects: s,
     overIndex: i
   } = e;
-  const a = (n = s[t]) != null ? n : r;
+  const a = (t = s[o]) != null ? t : r;
   if (!a)
     return null;
-  if (o === t) {
-    const u = s[i];
-    return u ? {
+  if (n === o) {
+    const c = s[i];
+    return c ? {
       x: 0,
-      y: t < i ? u.top + u.height - (a.top + a.height) : u.top - a.top,
-      ...A
+      y: o < i ? c.top + c.height - (a.top + a.height) : c.top - a.top,
+      ...L
     } : null;
   }
-  const l = De(s, o, t);
-  return o > t && o <= i ? {
+  const d = Ee(s, n, o);
+  return n > o && n <= i ? {
     x: 0,
-    y: -a.height - l,
-    ...A
-  } : o < t && o >= i ? {
+    y: -a.height - d,
+    ...L
+  } : n < o && n >= i ? {
     x: 0,
-    y: a.height + l,
-    ...A
+    y: a.height + d,
+    ...L
   } : {
     x: 0,
     y: 0,
-    ...A
+    ...L
   };
 };
-function De(e, n, t) {
-  const r = e[n], o = e[n - 1], s = e[n + 1];
-  return r ? t < n ? o ? r.top - (o.top + o.height) : s ? s.top - (r.top + r.height) : 0 : s ? s.top - (r.top + r.height) : o ? r.top - (o.top + o.height) : 0 : 0;
+function Ee(e, t, o) {
+  const r = e[t], n = e[t - 1], s = e[t + 1];
+  return r ? o < t ? n ? r.top - (n.top + n.height) : s ? s.top - (r.top + r.height) : 0 : s ? s.top - (r.top + r.height) : n ? r.top - (n.top + n.height) : 0 : 0;
 }
-const k = "Sortable", J = /* @__PURE__ */ H.createContext({
+const Q = "Sortable", W = /* @__PURE__ */ q.createContext({
   activeIndex: -1,
-  containerId: k,
+  containerId: Q,
   disableTransforms: !1,
   items: [],
   overIndex: -1,
   useDragOverlay: !1,
   sortedRects: [],
-  strategy: j,
+  strategy: J,
   disabled: {
     draggable: !1,
     droppable: !1
   }
 });
-function Pe(e) {
+function Be(e) {
   let {
-    children: n,
-    id: t,
+    children: t,
+    id: o,
     items: r,
-    strategy: o = j,
+    strategy: n = J,
     disabled: s = !1
   } = e;
   const {
     active: i,
     dragOverlay: a,
-    droppableRects: l,
-    over: u,
-    measureDroppableContainers: c
-  } = ge(), p = me(k, t), b = a.rect !== null, f = E(() => r.map((m) => typeof m == "object" && "id" in m ? m.id : m), [r]), w = i != null, h = i ? f.indexOf(i.id) : -1, v = u ? f.indexOf(u.id) : -1, T = z(f), y = !ye(f, T.current), R = v !== -1 && h === -1 || y, g = Re(s);
-  K(() => {
-    y && w && c(f);
-  }, [y, f, w, c]), L(() => {
-    T.current = f;
-  }, [f]);
-  const D = E(
+    droppableRects: d,
+    over: c,
+    measureDroppableContainers: l
+  } = ve(), u = Re(Q, o), f = a.rect !== null, g = _(() => r.map((I) => typeof I == "object" && "id" in I ? I.id : I), [r]), w = i != null, y = i ? g.indexOf(i.id) : -1, v = c ? g.indexOf(c.id) : -1, R = X(g), x = !Te(g, R.current), h = v !== -1 && y === -1 || x, b = Ne(s);
+  B(() => {
+    x && w && l(g);
+  }, [x, g, w, l]), k(() => {
+    R.current = g;
+  }, [g]);
+  const C = _(
     () => ({
-      activeIndex: h,
-      containerId: p,
-      disabled: g,
-      disableTransforms: R,
-      items: f,
+      activeIndex: y,
+      containerId: u,
+      disabled: b,
+      disableTransforms: h,
+      items: g,
       overIndex: v,
-      useDragOverlay: b,
-      sortedRects: he(f, l),
-      strategy: o
+      useDragOverlay: f,
+      sortedRects: Ae(g, d),
+      strategy: n
     }),
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [h, p, g.draggable, g.droppable, R, f, v, l, b, o]
+    [y, u, b.draggable, b.droppable, h, g, v, d, f, n]
   );
-  return H.createElement(J.Provider, {
-    value: D
-  }, n);
+  return q.createElement(W.Provider, {
+    value: C
+  }, t);
 }
-const Se = (e) => {
+const Le = (e) => {
   let {
-    id: n,
-    items: t,
+    id: t,
+    items: o,
     activeIndex: r,
-    overIndex: o
+    overIndex: n
   } = e;
-  return V(t, r, o).indexOf(n);
-}, Ce = (e) => {
+  return V(o, r, n).indexOf(t);
+}, _e = (e) => {
   let {
-    containerId: n,
-    isSorting: t,
+    containerId: t,
+    isSorting: o,
     wasDragging: r,
-    index: o,
+    index: n,
     items: s,
     newIndex: i,
     previousItems: a,
-    previousContainerId: l,
-    transition: u
+    previousContainerId: d,
+    transition: c
   } = e;
-  return !u || !r || a !== s && o === i ? !1 : t ? !0 : i !== o && n === l;
-}, we = {
+  return !c || !r || a !== s && n === i ? !1 : o ? !0 : i !== n && t === d;
+}, ke = {
   duration: 200,
   easing: "ease"
-}, Q = "transform", Te = /* @__PURE__ */ U.Transition.toString({
-  property: Q,
+}, Z = "transform", $e = /* @__PURE__ */ H.Transition.toString({
+  property: Z,
   duration: 0,
   easing: "linear"
-}), Oe = {
+}), ze = {
   roleDescription: "sortable"
 };
-function Ne(e) {
+function Ge(e) {
   let {
-    disabled: n,
-    index: t,
+    disabled: t,
+    index: o,
     node: r,
-    rect: o
+    rect: n
   } = e;
-  const [s, i] = fe(null), a = z(t);
-  return K(() => {
-    if (!n && t !== a.current && r.current) {
-      const l = o.current;
-      if (l) {
-        const u = be(r.current, {
+  const [s, i] = be(null), a = X(o);
+  return B(() => {
+    if (!t && o !== a.current && r.current) {
+      const d = n.current;
+      if (d) {
+        const c = ye(r.current, {
           ignoreTransform: !0
-        }), c = {
-          x: l.left - u.left,
-          y: l.top - u.top,
-          scaleX: l.width / u.width,
-          scaleY: l.height / u.height
+        }), l = {
+          x: d.left - c.left,
+          y: d.top - c.top,
+          scaleX: d.width / c.width,
+          scaleY: d.height / c.height
         };
-        (c.x || c.y) && i(c);
+        (l.x || l.y) && i(l);
       }
     }
-    t !== a.current && (a.current = t);
-  }, [n, t, r, o]), L(() => {
+    o !== a.current && (a.current = o);
+  }, [t, o, r, n]), k(() => {
     s && i(null);
   }, [s]), s;
 }
-function Xe(e) {
+function He(e) {
   let {
-    animateLayoutChanges: n = Ce,
-    attributes: t,
+    animateLayoutChanges: t = _e,
+    attributes: o,
     disabled: r,
-    data: o,
-    getNewIndex: s = Se,
+    data: n,
+    getNewIndex: s = Le,
     id: i,
     strategy: a,
-    resizeObserverConfig: l,
-    transition: u = we
+    resizeObserverConfig: d,
+    transition: c = ke
   } = e;
   const {
-    items: c,
-    containerId: p,
-    activeIndex: b,
-    disabled: f,
+    items: l,
+    containerId: u,
+    activeIndex: f,
+    disabled: g,
     disableTransforms: w,
-    sortedRects: h,
+    sortedRects: y,
     overIndex: v,
-    useDragOverlay: T,
-    strategy: y
-  } = le(J), R = Ae(r, f), g = c.indexOf(i), D = E(() => ({
+    useDragOverlay: R,
+    strategy: x
+  } = pe(W), h = Xe(r, g), b = l.indexOf(i), C = _(() => ({
     sortable: {
-      containerId: p,
-      index: g,
-      items: c
+      containerId: u,
+      index: b,
+      items: l
     },
-    ...o
-  }), [p, o, g, c]), m = E(() => c.slice(c.indexOf(i)), [c, i]), {
-    rect: P,
-    node: X,
-    isOver: W,
-    setNodeRef: G
-  } = pe({
+    ...n
+  }), [u, n, b, l]), I = _(() => l.slice(l.indexOf(i)), [l, i]), {
+    rect: N,
+    node: P,
+    isOver: te,
+    setNodeRef: Y
+  } = he({
     id: i,
-    data: D,
-    disabled: R.droppable,
+    data: C,
+    disabled: h.droppable,
     resizeObserverConfig: {
-      updateMeasurementsFor: m,
-      ...l
+      updateMeasurementsFor: I,
+      ...d
     }
   }), {
-    active: S,
-    activatorEvent: Z,
-    activeNodeRect: ee,
-    attributes: te,
-    setNodeRef: M,
-    listeners: re,
-    isDragging: _,
-    over: ne,
-    setActivatorNodeRef: oe,
-    transform: ie
-  } = ve({
+    active: A,
+    activatorEvent: re,
+    activeNodeRect: ne,
+    attributes: oe,
+    setNodeRef: F,
+    listeners: ie,
+    isDragging: z,
+    over: se,
+    setActivatorNodeRef: ae,
+    transform: ce
+  } = xe({
     id: i,
-    data: D,
+    data: C,
     attributes: {
-      ...Oe,
-      ...t
+      ...ze,
+      ...o
     },
-    disabled: R.draggable
-  }), se = Ie(G, M), I = !!S, Y = I && !w && N(b) && N(v), q = !T && _, B = q && Y ? ie : null, ae = Y ? B ?? (a ?? y)({
-    rects: h,
-    activeNodeRect: ee,
-    activeIndex: b,
+    disabled: h.draggable
+  }), le = Ce(Y, F), S = !!A, K = S && !w && O(f) && O(v), M = !R && z, U = M && K ? ce : null, de = K ? U ?? (a ?? x)({
+    rects: y,
+    activeNodeRect: ne,
+    activeIndex: f,
     overIndex: v,
-    index: g
-  }) : null, C = N(b) && N(v) ? s({
+    index: b
+  }) : null, T = O(f) && O(v) ? s({
     id: i,
-    items: c,
-    activeIndex: b,
+    items: l,
+    activeIndex: f,
     overIndex: v
-  }) : g, x = S == null ? void 0 : S.id, d = z({
-    activeId: x,
-    items: c,
-    newIndex: C,
-    containerId: p
-  }), ce = c !== d.current.items, F = n({
-    active: S,
-    containerId: p,
-    isDragging: _,
-    isSorting: I,
+  }) : b, D = A == null ? void 0 : A.id, p = X({
+    activeId: D,
+    items: l,
+    newIndex: T,
+    containerId: u
+  }), ue = l !== p.current.items, j = t({
+    active: A,
+    containerId: u,
+    isDragging: z,
+    isSorting: S,
     id: i,
-    index: g,
-    items: c,
-    newIndex: d.current.newIndex,
-    previousItems: d.current.items,
-    previousContainerId: d.current.containerId,
-    transition: u,
-    wasDragging: d.current.activeId != null
-  }), $ = Ne({
-    disabled: !F,
-    index: g,
-    node: X,
-    rect: P
+    index: b,
+    items: l,
+    newIndex: p.current.newIndex,
+    previousItems: p.current.items,
+    previousContainerId: p.current.containerId,
+    transition: c,
+    wasDragging: p.current.activeId != null
+  }), G = Ge({
+    disabled: !j,
+    index: b,
+    node: P,
+    rect: N
   });
-  return L(() => {
-    I && d.current.newIndex !== C && (d.current.newIndex = C), p !== d.current.containerId && (d.current.containerId = p), c !== d.current.items && (d.current.items = c);
-  }, [I, C, p, c]), L(() => {
-    if (x === d.current.activeId)
+  return k(() => {
+    S && p.current.newIndex !== T && (p.current.newIndex = T), u !== p.current.containerId && (p.current.containerId = u), l !== p.current.items && (p.current.items = l);
+  }, [S, T, u, l]), k(() => {
+    if (D === p.current.activeId)
       return;
-    if (x != null && d.current.activeId == null) {
-      d.current.activeId = x;
+    if (D != null && p.current.activeId == null) {
+      p.current.activeId = D;
       return;
     }
-    const de = setTimeout(() => {
-      d.current.activeId = x;
+    const ge = setTimeout(() => {
+      p.current.activeId = D;
     }, 50);
-    return () => clearTimeout(de);
-  }, [x]), {
-    active: S,
-    activeIndex: b,
-    attributes: te,
-    data: D,
-    rect: P,
-    index: g,
-    newIndex: C,
-    items: c,
-    isOver: W,
-    isSorting: I,
-    isDragging: _,
-    listeners: re,
-    node: X,
+    return () => clearTimeout(ge);
+  }, [D]), {
+    active: A,
+    activeIndex: f,
+    attributes: oe,
+    data: C,
+    rect: N,
+    index: b,
+    newIndex: T,
+    items: l,
+    isOver: te,
+    isSorting: S,
+    isDragging: z,
+    listeners: ie,
+    node: P,
     overIndex: v,
-    over: ne,
-    setNodeRef: se,
-    setActivatorNodeRef: oe,
-    setDroppableNodeRef: G,
-    setDraggableNodeRef: M,
-    transform: $ ?? ae,
-    transition: ue()
+    over: se,
+    setNodeRef: le,
+    setActivatorNodeRef: ae,
+    setDroppableNodeRef: Y,
+    setDraggableNodeRef: F,
+    transform: G ?? de,
+    transition: fe()
   };
-  function ue() {
+  function fe() {
     if (
       // Temporarily disable transitions for a single frame to set up derived transforms
-      $ || // Or to prevent items jumping to back to their "new" position when items change
-      ce && d.current.newIndex === g
+      G || // Or to prevent items jumping to back to their "new" position when items change
+      ue && p.current.newIndex === b
     )
-      return Te;
-    if (!(q && !xe(Z) || !u) && (I || F))
-      return U.Transition.toString({
-        ...u,
-        property: Q
+      return $e;
+    if (!(M && !Se(re) || !c) && (S || j))
+      return H.Transition.toString({
+        ...c,
+        property: Z
       });
   }
 }
-function Ae(e, n) {
-  var t, r;
+function Xe(e, t) {
+  var o, r;
   return typeof e == "boolean" ? {
     draggable: e,
     // Backwards compatibility
     droppable: !1
   } : {
-    draggable: (t = e == null ? void 0 : e.draggable) != null ? t : n.draggable,
-    droppable: (r = e == null ? void 0 : e.droppable) != null ? r : n.droppable
+    draggable: (o = e == null ? void 0 : e.draggable) != null ? o : t.draggable,
+    droppable: (r = e == null ? void 0 : e.droppable) != null ? r : t.droppable
   };
 }
-O.Down, O.Right, O.Up, O.Left;
+function $(e) {
+  if (!e)
+    return !1;
+  const t = e.data.current;
+  return !!(t && "sortable" in t && typeof t.sortable == "object" && "containerId" in t.sortable && "items" in t.sortable && "index" in t.sortable);
+}
+const Pe = [m.Down, m.Right, m.Up, m.Left], Ve = (e, t) => {
+  let {
+    context: {
+      active: o,
+      collisionRect: r,
+      droppableRects: n,
+      droppableContainers: s,
+      over: i,
+      scrollableAncestors: a
+    }
+  } = t;
+  if (Pe.includes(e.code)) {
+    if (e.preventDefault(), !o || !r)
+      return;
+    const d = [];
+    s.getEnabled().forEach((u) => {
+      if (!u || u != null && u.disabled)
+        return;
+      const f = n.get(u.id);
+      if (f)
+        switch (e.code) {
+          case m.Down:
+            r.top < f.top && d.push(u);
+            break;
+          case m.Up:
+            r.top > f.top && d.push(u);
+            break;
+          case m.Left:
+            r.left > f.left && d.push(u);
+            break;
+          case m.Right:
+            r.left < f.left && d.push(u);
+            break;
+        }
+    });
+    const c = Ie({
+      collisionRect: r,
+      droppableRects: n,
+      droppableContainers: d
+    });
+    let l = me(c, "id");
+    if (l === (i == null ? void 0 : i.id) && c.length > 1 && (l = c[1].id), l != null) {
+      const u = s.get(o.id), f = s.get(l), g = f ? n.get(f.id) : null, w = f == null ? void 0 : f.node.current;
+      if (w && g && u && f) {
+        const v = we(w).some((I, N) => a[N] !== I), R = ee(u, f), x = Ye(u, f), h = v || !R ? {
+          x: 0,
+          y: 0
+        } : {
+          x: x ? r.width - g.width : 0,
+          y: x ? r.height - g.height : 0
+        }, b = {
+          x: g.left,
+          y: g.top
+        };
+        return h.x && h.y ? b : De(b, h);
+      }
+    }
+  }
+};
+function ee(e, t) {
+  return !$(e) || !$(t) ? !1 : e.data.current.sortable.containerId === t.data.current.sortable.containerId;
+}
+function Ye(e, t) {
+  return !$(e) || !$(t) || !ee(e, t) ? !1 : e.data.current.sortable.index < t.data.current.sortable.index;
+}
 export {
-  Pe as SortableContext,
+  Be as SortableContext,
   V as arrayMove,
-  Ce as defaultAnimateLayoutChanges,
-  Se as defaultNewIndexGetter,
-  j as rectSortingStrategy,
-  Xe as useSortable,
-  ze as verticalListSortingStrategy
+  _e as defaultAnimateLayoutChanges,
+  Le as defaultNewIndexGetter,
+  $ as hasSortableData,
+  je as horizontalListSortingStrategy,
+  J as rectSortingStrategy,
+  Ve as sortableKeyboardCoordinates,
+  He as useSortable,
+  qe as verticalListSortingStrategy
 };
 //# sourceMappingURL=sortable.esm.js.map