@spacego/fe-components 0.1.1 → 0.2.0

package/lib/node_modules/.pnpm/@dnd-kit_modifiers@9.0.0_55ztycxty3xzw7t4rzpvix55vq/node_modules/@dnd-kit/modifiers/dist/modifiers.esm.js

@@ -0,0 +1,13 @@
+import "react";
+const o = (r) => {
+  let {
+    transform: t
+  } = r;
+  return {
+    ...t,
+    x: 0
+  };
+};
+export {
+  o as restrictToVerticalAxis
+};

package/lib/node_modules/.pnpm/@dnd-kit_sortable@10.0.0_55ztycxty3xzw7t4rzpvix55vq/node_modules/@dnd-kit/sortable/dist/sortable.esm.js

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

package/lib/node_modules/.pnpm/@dnd-kit_utilities@3.2.2_react@18.3.1/node_modules/@dnd-kit/utilities/dist/utilities.esm.js

@@ -0,0 +1,235 @@
+import { useRef as o, useMemo as l, useLayoutEffect as R, useEffect as g, useCallback as i } from "react";
+function Y() {
+  for (var n = arguments.length, t = new Array(n), e = 0; e < n; e++)
+    t[e] = arguments[e];
+  return l(
+    () => (u) => {
+      t.forEach((r) => r(u));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+}
+const D = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
+function a(n) {
+  const t = Object.prototype.toString.call(n);
+  return t === "[object Window]" || // In Electron context the Window object serializes to [object global]
+  t === "[object global]";
+}
+function b(n) {
+  return "nodeType" in n;
+}
+function c(n) {
+  var t, e;
+  return n ? a(n) ? n : b(n) && (t = (e = n.ownerDocument) == null ? void 0 : e.defaultView) != null ? t : window : window;
+}
+function j(n) {
+  const {
+    Document: t
+  } = c(n);
+  return n instanceof t;
+}
+function C(n) {
+  return a(n) ? !1 : n instanceof c(n).HTMLElement;
+}
+function L(n) {
+  return n instanceof c(n).SVGElement;
+}
+function x(n) {
+  return n ? a(n) ? n.document : b(n) ? j(n) ? n : C(n) || L(n) ? n.ownerDocument : document : document : document;
+}
+const E = D ? R : g;
+function M(n) {
+  const t = o(n);
+  return E(() => {
+    t.current = n;
+  }), i(function() {
+    for (var e = arguments.length, u = new Array(e), r = 0; r < e; r++)
+      u[r] = arguments[r];
+    return t.current == null ? void 0 : t.current(...u);
+  }, []);
+}
+function A() {
+  const n = o(null), t = i((u, r) => {
+    n.current = setInterval(u, r);
+  }, []), e = i(() => {
+    n.current !== null && (clearInterval(n.current), n.current = null);
+  }, []);
+  return [t, e];
+}
+function I(n, t) {
+  t === void 0 && (t = [n]);
+  const e = o(n);
+  return E(() => {
+    e.current !== n && (e.current = n);
+  }, t), e;
+}
+function v(n, t) {
+  const e = o();
+  return l(
+    () => {
+      const u = n(e.current);
+      return e.current = u, u;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+function N(n) {
+  const t = M(n), e = o(null), u = i(
+    (r) => {
+      r !== e.current && (t == null || t(r, e.current)), e.current = r;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [e, u];
+}
+function F(n) {
+  const t = o();
+  return g(() => {
+    t.current = n;
+  }, [n]), t.current;
+}
+let f = {};
+function H(n, t) {
+  return l(() => {
+    if (t)
+      return t;
+    const e = f[n] == null ? 0 : f[n] + 1;
+    return f[n] = e, n + "-" + e;
+  }, [n, t]);
+}
+function S(n) {
+  return function(t) {
+    for (var e = arguments.length, u = new Array(e > 1 ? e - 1 : 0), r = 1; r < e; r++)
+      u[r - 1] = arguments[r];
+    return u.reduce((s, T) => {
+      const y = Object.entries(T);
+      for (const [d, p] of y) {
+        const m = s[d];
+        m != null && (s[d] = m + n * p);
+      }
+      return s;
+    }, {
+      ...t
+    });
+  };
+}
+const W = /* @__PURE__ */ S(1), q = /* @__PURE__ */ S(-1);
+function O(n) {
+  return "clientX" in n && "clientY" in n;
+}
+function z(n) {
+  if (!n)
+    return !1;
+  const {
+    KeyboardEvent: t
+  } = c(n.target);
+  return t && n instanceof t;
+}
+function V(n) {
+  if (!n)
+    return !1;
+  const {
+    TouchEvent: t
+  } = c(n.target);
+  return t && n instanceof t;
+}
+function G(n) {
+  if (V(n)) {
+    if (n.touches && n.touches.length) {
+      const {
+        clientX: t,
+        clientY: e
+      } = n.touches[0];
+      return {
+        x: t,
+        y: e
+      };
+    } else if (n.changedTouches && n.changedTouches.length) {
+      const {
+        clientX: t,
+        clientY: e
+      } = n.changedTouches[0];
+      return {
+        x: t,
+        y: e
+      };
+    }
+  }
+  return O(n) ? {
+    x: n.clientX,
+    y: n.clientY
+  } : null;
+}
+const w = /* @__PURE__ */ Object.freeze({
+  Translate: {
+    toString(n) {
+      if (!n)
+        return;
+      const {
+        x: t,
+        y: e
+      } = n;
+      return "translate3d(" + (t ? Math.round(t) : 0) + "px, " + (e ? Math.round(e) : 0) + "px, 0)";
+    }
+  },
+  Scale: {
+    toString(n) {
+      if (!n)
+        return;
+      const {
+        scaleX: t,
+        scaleY: e
+      } = n;
+      return "scaleX(" + t + ") scaleY(" + e + ")";
+    }
+  },
+  Transform: {
+    toString(n) {
+      if (n)
+        return [w.Translate.toString(n), w.Scale.toString(n)].join(" ");
+    }
+  },
+  Transition: {
+    toString(n) {
+      let {
+        property: t,
+        duration: e,
+        easing: u
+      } = n;
+      return t + " " + e + "ms " + u;
+    }
+  }
+}), h = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function K(n) {
+  return n.matches(h) ? n : n.querySelector(h);
+}
+export {
+  w as CSS,
+  W as add,
+  D as canUseDOM,
+  K as findFirstFocusableNode,
+  G as getEventCoordinates,
+  x as getOwnerDocument,
+  c as getWindow,
+  O as hasViewportRelativeCoordinates,
+  j as isDocument,
+  C as isHTMLElement,
+  z as isKeyboardEvent,
+  b as isNode,
+  L as isSVGElement,
+  V as isTouchEvent,
+  a as isWindow,
+  q as subtract,
+  Y as useCombinedRefs,
+  M as useEvent,
+  A as useInterval,
+  E as useIsomorphicLayoutEffect,
+  I as useLatestValue,
+  v as useLazyMemo,
+  N as useNodeRef,
+  F as usePrevious,
+  H as useUniqueId
+};