@orioncactuscorp/ui 1.14.0 → 1.15.0

package/dist/components/Modal/useModalKeyboardAvoidance.js

@@ -0,0 +1,159 @@
+import { useReducer as F, useRef as _, useLayoutEffect as h, useEffect as L, useMemo as p, useState as B, useCallback as O } from "react";
+import { keyboardSessionReducer as C, getKeyboardInset as D, isSessionGeometryCompatible as y, isKeyboardEditable as g, isSessionGeometryRestored as x, supportsTransitionSettleDetection as V, recordMeasuredKeyboardInset as Y, getKeyboardRevealScrollDelta as W, getSessionStableViewportGeometry as q, getSeedKeyboardInset as P, hasRunningTransformTransition as k } from "./keyboardSession.js";
+const X = 150, j = 450, z = 500, H = 1e4;
+function J({
+  holdShrink: f,
+  keyboardInset: n
+}) {
+  const [m, s] = B(0), t = O((o) => {
+    s((e) => Math.max(e, o));
+  }, []);
+  return L(() => {
+    if (n > m) {
+      s(n);
+      return;
+    }
+    if (n === m || f)
+      return;
+    const o = window.setTimeout(() => {
+      s(n);
+    }, X);
+    return () => {
+      window.clearTimeout(o);
+    };
+  }, [f, n, m]), { seedSettledKeyboardInset: t, settledKeyboardInset: m };
+}
+function Z({
+  bodyNode: f,
+  enabled: n,
+  footerHeight: m,
+  surfaceNode: s,
+  viewportGeometry: t,
+  viewportNode: o
+}) {
+  const [e, E] = F(C, void 0), S = _(void 0), T = _(t);
+  h(() => {
+    T.current = t;
+  }, [t]);
+  const a = n ? D(e, t) : 0, R = y(
+    e,
+    t
+  ), M = !!e?.sawKeyboard && a === 0, { seedSettledKeyboardInset: A, settledKeyboardInset: v } = J({
+    holdShrink: !!(e && e.phase === "active" && R && !M),
+    keyboardInset: a
+  });
+  h(() => {
+    n || !e || E({ type: "release" });
+  }, [n, e]), h(() => {
+    if (!n || !s || typeof window > "u")
+      return;
+    const r = () => {
+      S.current !== void 0 && (window.cancelAnimationFrame(S.current), S.current = void 0);
+    }, c = (d) => {
+      r();
+      const l = window.visualViewport, I = T.current ?? {
+        height: l?.height ?? window.innerHeight,
+        offsetLeft: l?.offsetLeft ?? 0,
+        offsetTop: l?.offsetTop ?? 0,
+        width: l?.width ?? window.innerWidth
+      }, K = P(I.width);
+      K !== void 0 && A(K), E({ type: "focus", geometry: I, target: d });
+    }, i = (d) => {
+      const l = d.target;
+      g(l) && c(l);
+    }, u = () => {
+      r(), S.current = window.requestAnimationFrame(() => {
+        S.current = void 0;
+        const d = document.activeElement;
+        if (s.contains(d) && g(d)) {
+          E({ type: "retain", target: d });
+          return;
+        }
+        E({ type: "close" });
+      });
+    };
+    s.addEventListener("focusin", i), s.addEventListener("focusout", u);
+    const w = document.activeElement;
+    return s.contains(w) && g(w) && c(w), () => {
+      r(), s.removeEventListener("focusin", i), s.removeEventListener("focusout", u);
+    };
+  }, [n, A, s]), L(() => {
+    if (e?.phase !== "closing" || !t) return;
+    if (!y(e, t)) {
+      E({ type: "release" });
+      return;
+    }
+    if (!x(e, t))
+      return;
+    let r = !1;
+    const c = () => {
+      r || (r = !0, E({ type: "release" }));
+    };
+    if (!V(o)) {
+      const l = window.setTimeout(
+        c,
+        j
+      );
+      return () => {
+        window.clearTimeout(l);
+      };
+    }
+    const i = () => {
+      r || k(o) || c();
+    };
+    let u = window.requestAnimationFrame(
+      () => {
+        u = window.requestAnimationFrame(() => {
+          u = void 0, i();
+        });
+      }
+    );
+    const w = window.setInterval(
+      i,
+      z
+    ), d = window.setTimeout(
+      c,
+      H
+    );
+    return o.addEventListener("transitionend", i), o.addEventListener("transitioncancel", i), () => {
+      u !== void 0 && window.cancelAnimationFrame(u), window.clearInterval(w), window.clearTimeout(d), o.removeEventListener("transitionend", i), o.removeEventListener("transitioncancel", i);
+    };
+  }, [e, t, o]), L(() => {
+    a <= 0 || !t || (window.navigator.maxTouchPoints > 0 && Y(t.width, a), E({ type: "measure" }));
+  }, [a, t]), h(() => {
+    const r = e?.target, c = Math.max(a, v);
+    if (!f || !r || c <= 0) return;
+    const i = W({
+      bodyRect: f.getBoundingClientRect(),
+      clearanceInset: c,
+      footerHeight: m,
+      targetRect: r.getBoundingClientRect()
+    });
+    if (Math.abs(i) > 0.5) {
+      const u = a <= 0;
+      f.scrollTo({
+        behavior: u || window.matchMedia?.("(prefers-reduced-motion: reduce)").matches === !0 ? "auto" : "smooth",
+        top: f.scrollTop + i
+      });
+    }
+  }, [
+    f,
+    m,
+    a,
+    e?.target,
+    v
+  ]);
+  const b = p(
+    () => n ? q(e, t) : t,
+    [n, e, t]
+  );
+  return {
+    active: n && !!e && R,
+    keyboardInset: a,
+    settledKeyboardInset: v,
+    viewportGeometry: b
+  };
+}
+export {
+  Z as useModalKeyboardAvoidance
+};

package/dist/components/Modal/useModalViewportGeometry.js

@@ -0,0 +1,36 @@
+import { useState as w, useLayoutEffect as v } from "react";
+function a(e, t) {
+  return e?.height === t.height && e.offsetLeft === t.offsetLeft && e.offsetTop === t.offsetTop && e.width === t.width;
+}
+function m(e) {
+  const t = e.visualViewport;
+  return {
+    height: t?.height ?? e.innerHeight,
+    offsetLeft: t?.offsetLeft ?? 0,
+    offsetTop: t?.offsetTop ?? 0,
+    width: t?.width ?? e.innerWidth
+  };
+}
+function h(e) {
+  const [t, d] = w();
+  return v(() => {
+    if (!e || typeof window > "u") return;
+    const i = window.visualViewport;
+    let n;
+    const r = () => {
+      const s = m(window);
+      d((f) => a(f, s) ? f : s);
+    }, o = () => {
+      n === void 0 && (n = window.requestAnimationFrame(() => {
+        n = void 0, r();
+      }));
+    };
+    return r(), window.addEventListener("resize", o), i?.addEventListener("resize", o), i?.addEventListener("scroll", o), i?.addEventListener("scrollend", o), () => {
+      window.removeEventListener("resize", o), i?.removeEventListener("resize", o), i?.removeEventListener("scroll", o), i?.removeEventListener("scrollend", o), n !== void 0 && window.cancelAnimationFrame(n);
+    };
+  }, [e]), t;
+}
+export {
+  m as getModalViewportGeometry,
+  h as useModalViewportGeometry
+};

package/dist/components/PositionSnap/PositionSnap.css

@@ -0,0 +1 @@
+.oc-PositionSnap-module__positioner__-v2BM{--_-position-snap-x: 0px;--_-position-snap-y: 0px;--oc-position-snap-z-index: var(--oc-zindex-2);position:fixed;z-index:var(--oc-position-snap-z-index);inset-block-start:0;inset-inline-start:0;width:max-content;max-width:100%;max-height:100dvh;touch-action:none;transform:translate3d(var(--_-position-snap-x),var(--_-position-snap-y),0)}.oc-PositionSnap-module__positioner__-v2BM[data-oc-positioned=false]{visibility:hidden}.oc-PositionSnap-module__positioner__-v2BM[data-oc-dragging=true]{cursor:grabbing;-webkit-user-select:none;user-select:none}.oc-PositionSnap-module__positioner__-v2BM[data-oc-drag=handle]{touch-action:auto}.oc-PositionSnap-module__handle__iuv3c{cursor:grab;touch-action:none}

package/dist/components/PositionSnap/PositionSnap.js

@@ -0,0 +1,330 @@
+'use client';
+import { jsx as W } from "react/jsx-runtime";
+import { useMemo as J, useRef as h, useState as A, useCallback as g, useLayoutEffect as U } from "react";
+import { createSpringAnimator as j } from "../../utils/spring/animator.js";
+import { resolveOcMotion as it } from "../../utils/motion.js";
+import { mergeRefs as st } from "../../utils/mergeRefs.js";
+import { resolvePositionSnapTargets as at, getPositionSnapBoundaryRect as ct, uniformPositionSnapPadding as lt } from "./geometry.js";
+import { getPositionSnapPointDistance as ut, getReleasePositionSnapTarget as pt, resolvePositionSnapDragPoint as ft } from "./policy.js";
+import { POSITION_SNAP_DRAG_FOLLOWER_SPRING as dt } from "./gesture.js";
+import { usePositionSnapContext as Q, PositionSnapContext as Pt } from "./contexts.js";
+import Z from "./PositionSnap.module.scss.js";
+const mt = 2, gt = 10, tt = 90, k = 4e3, yt = 500;
+function et(...r) {
+  return r.filter(Boolean).join(" ");
+}
+function V() {
+  return Date.now();
+}
+function X(r, i, s) {
+  return Math.min(Math.max(r, i), s);
+}
+function $(r, i) {
+  const s = V();
+  r.push({ ...i, time: s });
+  const f = s - tt;
+  for (; r.length > 2 && (r[1]?.time ?? s) < f; )
+    r.shift();
+}
+function wt(r) {
+  const i = r[r.length - 1], s = r.find(
+    (w) => w.time >= (i?.time ?? 0) - tt
+  );
+  if (!s || !i || s === i) return { x: 0, y: 0 };
+  const f = Math.max(i.time - s.time, 1);
+  return {
+    x: X(
+      (i.x - s.x) / f * 1e3,
+      -k,
+      k
+    ),
+    y: X(
+      (i.y - s.y) / f * 1e3,
+      -k,
+      k
+    )
+  };
+}
+function q(r) {
+  const i = r.getBoundingClientRect();
+  return { width: i.width, height: i.height };
+}
+function St(r) {
+  return r instanceof Element && !!r.closest('[data-oc-part="position-snap-handle"]');
+}
+function K({
+  children: r,
+  positions: i,
+  position: s,
+  defaultPosition: f,
+  onPositionChange: w,
+  boundary: y = "viewport",
+  boundaryPadding: I = 16,
+  drag: x = "content",
+  disabled: R = !1
+}) {
+  const S = h(null), [a, M] = A(null), [o, nt] = A(
+    f ?? i[0] ?? "center"
+  ), [b, ot] = A(!1), C = h(!1), [B, F] = A(!1), E = s ?? o, D = h({ x: 0, y: 0 }), T = h(null), u = h(null), z = h(0), G = g((t) => {
+    S.current = t, M(t), t || (C.current = !1);
+  }, []), p = g((t) => {
+    const e = S.current;
+    e && (D.current = { x: t.x, y: t.y }, e.style.setProperty("--_-position-snap-x", `${t.x}px`), e.style.setProperty("--_-position-snap-y", `${t.y}px`));
+  }, []), m = g(() => {
+    u.current?.destroy(), u.current = null;
+  }, []), O = g(
+    (t, e = { x: 0, y: 0 }) => {
+      const n = S.current;
+      if (!n) return;
+      const c = u.current?.isRunning ? u.current : null, d = c?.sample(), P = d?.value ?? D.current, l = { x: t.x, y: t.y };
+      if (d && p(P), ut(P, l) < 0.5) {
+        m(), p(l);
+        return;
+      }
+      const L = it({
+        element: n,
+        intent: "gesture",
+        phase: "release",
+        property: "transform"
+      });
+      if (!L.animate) {
+        m(), p(l);
+        return;
+      }
+      if (c) {
+        c.setTarget(l, { spring: L.spring });
+        return;
+      }
+      m();
+      const H = j({
+        value: P,
+        target: l,
+        velocity: e,
+        spring: L.spring,
+        epsilon: 0.5,
+        velocityEpsilon: 50,
+        stabilityWindow: 0.02,
+        onUpdate: p,
+        onComplete: () => {
+          u.current === H && (u.current = null), p(H.target);
+        }
+      });
+      u.current = H;
+    },
+    [p, m]
+  ), Y = g(
+    (t) => {
+      let e = u.current;
+      if (!e) {
+        const n = D.current, c = j({
+          value: n,
+          target: n,
+          spring: dt,
+          autoplay: !1,
+          epsilon: 0.5,
+          velocityEpsilon: 50,
+          stabilityWindow: 0.02,
+          onUpdate: p,
+          onComplete: () => {
+            u.current === c && (u.current = null), p(c.target);
+          }
+        });
+        u.current = c, e = c;
+      }
+      e.setTarget(t), p(e.sample().value);
+    },
+    [p]
+  ), v = g(() => !a || i.length === 0 ? [] : at({
+    boundary: ct(y),
+    direction: window.getComputedStyle(a).direction === "rtl" ? "rtl" : "ltr",
+    padding: lt(I),
+    positions: i,
+    size: q(a)
+  }), [y, I, a, i]), N = g(
+    (t) => {
+      const e = v();
+      if (!e.length) return;
+      const n = e.find((c) => c.key === E) ?? e[0];
+      n && (t && C.current ? O(n) : p(n), C.current || (C.current = !0, ot(!0)));
+    },
+    [p, E, v, O]
+  );
+  U(() => {
+    N(C.current);
+  }, [N]), U(() => {
+    if (!a) return;
+    const t = () => {
+      T.current || N(!!u.current?.isRunning);
+    };
+    let e = null;
+    const n = () => {
+      e === null && (e = window.requestAnimationFrame(() => {
+        e = null, t();
+      }));
+    }, c = typeof ResizeObserver > "u" ? void 0 : new ResizeObserver(n);
+    return c?.observe(a), y !== "viewport" && c?.observe(y), window.addEventListener("resize", n), window.addEventListener("scroll", n, !0), window.visualViewport?.addEventListener("resize", n), window.visualViewport?.addEventListener("scroll", n), () => {
+      e !== null && window.cancelAnimationFrame(e), c?.disconnect(), window.removeEventListener("resize", n), window.removeEventListener("scroll", n, !0), window.visualViewport?.removeEventListener("resize", n), window.visualViewport?.removeEventListener("scroll", n);
+    };
+  }, [y, a, N]), U(() => () => m(), [m]);
+  const _ = g(
+    (t, e) => {
+      const n = T.current;
+      if (!n || n.pointerId !== t.pointerId || (T.current = null, t.currentTarget.hasPointerCapture(n.pointerId) && t.currentTarget.releasePointerCapture(n.pointerId), !n.started)) return;
+      F(!1), z.current = V() + yt, $(n.samples, n.targetPoint);
+      const c = wt(n.samples), d = v(), P = d.find((L) => L.key === E) ?? d[0];
+      if (!P) return;
+      const l = e ? P : pt({
+        currentPoint: n.targetPoint,
+        velocity: c,
+        targets: d
+      });
+      !e && l.key !== E && (s === void 0 && nt(l.key), w?.(l.key)), O(l, e ? void 0 : c);
+    },
+    [E, w, s, v, O]
+  ), rt = J(
+    () => ({
+      drag: x,
+      dragging: B,
+      positioned: b,
+      setPositionerNode: G,
+      onClickCapture: (t) => {
+        V() > z.current || (z.current = 0, t.preventDefault(), t.stopPropagation());
+      },
+      onLostPointerCapture: (t) => {
+        _(t, !1);
+      },
+      onPointerCancel: (t) => {
+        _(t, !0);
+      },
+      onPointerDown: (t) => {
+        if (R || !t.isPrimary || t.button !== 0 || x === "handle" && !St(t.target))
+          return;
+        m();
+        const e = D.current;
+        T.current = {
+          pointerId: t.pointerId,
+          pointerType: t.pointerType,
+          started: !1,
+          startPointer: { x: t.clientX, y: t.clientY },
+          startPoint: e,
+          targetPoint: e,
+          samples: []
+        };
+      },
+      onPointerMove: (t) => {
+        const e = T.current;
+        if (!e || e.pointerId !== t.pointerId) return;
+        const n = {
+          x: t.clientX - e.startPointer.x,
+          y: t.clientY - e.startPointer.y
+        }, c = e.pointerType === "touch" ? gt : mt;
+        if (!e.started && Math.hypot(n.x, n.y) < c)
+          return;
+        e.started || (e.started = !0, t.currentTarget.setPointerCapture(t.pointerId), F(!0)), t.preventDefault();
+        const d = v(), P = S.current;
+        if (!d.length || !P) return;
+        const l = ft({
+          point: {
+            x: e.startPoint.x + n.x,
+            y: e.startPoint.y + n.y
+          },
+          size: q(P),
+          targets: d
+        });
+        e.targetPoint = l, Y(l), $(e.samples, l);
+      },
+      onPointerUp: (t) => {
+        _(t, !1);
+      }
+    }),
+    [
+      R,
+      x,
+      B,
+      _,
+      Y,
+      b,
+      v,
+      G,
+      m
+    ]
+  );
+  return /* @__PURE__ */ W(Pt.Provider, { value: rt, children: r });
+}
+function vt({
+  children: r,
+  className: i = "",
+  onClickCapture: s,
+  onLostPointerCapture: f,
+  onPointerCancel: w,
+  onPointerDown: y,
+  onPointerMove: I,
+  onPointerUp: x,
+  ref: R,
+  ...S
+}) {
+  const a = Q("PositionSnapPositioner"), M = J(
+    () => st(a.setPositionerNode, R),
+    [a.setPositionerNode, R]
+  );
+  return /* @__PURE__ */ W(
+    "div",
+    {
+      ...S,
+      ref: M,
+      className: et(Z.positioner, i),
+      "data-oc-component": "position-snap",
+      "data-oc-part": "positioner",
+      "data-oc-drag": a.drag,
+      "data-oc-dragging": a.dragging ? "true" : void 0,
+      "data-oc-positioned": a.positioned ? "true" : "false",
+      onClickCapture: (o) => {
+        s?.(o), o.defaultPrevented || a.onClickCapture(o);
+      },
+      onLostPointerCapture: (o) => {
+        f?.(o), o.defaultPrevented || a.onLostPointerCapture(o);
+      },
+      onPointerCancel: (o) => {
+        w?.(o), o.defaultPrevented || a.onPointerCancel(o);
+      },
+      onPointerDown: (o) => {
+        y?.(o), o.defaultPrevented || a.onPointerDown(o);
+      },
+      onPointerMove: (o) => {
+        I?.(o), o.defaultPrevented || a.onPointerMove(o);
+      },
+      onPointerUp: (o) => {
+        x?.(o), o.defaultPrevented || a.onPointerUp(o);
+      },
+      children: r
+    }
+  );
+}
+function ht({
+  children: r,
+  className: i = "",
+  ref: s,
+  ...f
+}) {
+  return Q("PositionSnapHandle"), /* @__PURE__ */ W(
+    "div",
+    {
+      ...f,
+      ref: s,
+      className: et(Z.handle, i),
+      "data-oc-part": "position-snap-handle",
+      children: r
+    }
+  );
+}
+const _t = Object.assign(K, {
+  Root: K,
+  Positioner: vt,
+  Handle: ht
+});
+export {
+  ht as PositionSnapHandle,
+  vt as PositionSnapPositioner,
+  K as PositionSnapRoot,
+  _t as default
+};

package/dist/components/PositionSnap/PositionSnap.module.scss.js

@@ -0,0 +1,9 @@
+import './PositionSnap.css';const o = "oc-PositionSnap-module__positioner__-v2BM", n = "oc-PositionSnap-module__handle__iuv3c", e = {
+  positioner: o,
+  handle: n
+};
+export {
+  e as default,
+  n as handle,
+  o as positioner
+};

package/dist/components/PositionSnap/contexts.js

@@ -0,0 +1,12 @@
+import { useContext as n, createContext as e } from "react";
+const i = e(null);
+function s(o) {
+  const t = n(i);
+  if (!t)
+    throw new Error(`${o} must be used inside PositionSnapRoot.`);
+  return t;
+}
+export {
+  i as PositionSnapContext,
+  s as usePositionSnapContext
+};

package/dist/components/PositionSnap/geometry.js

@@ -0,0 +1,75 @@
+function g(t = "viewport") {
+  if (t !== "viewport") {
+    const n = t.getBoundingClientRect();
+    return {
+      x: n.left,
+      y: n.top,
+      width: n.width,
+      height: n.height
+    };
+  }
+  const e = window.visualViewport;
+  return {
+    x: e?.offsetLeft ?? 0,
+    y: e?.offsetTop ?? 0,
+    width: e?.width ?? document.documentElement.clientWidth,
+    height: e?.height ?? document.documentElement.clientHeight
+  };
+}
+function x({
+  boundary: t,
+  direction: e,
+  padding: n,
+  position: c,
+  size: i
+}) {
+  const o = t.x + n.left, u = t.x + t.width - n.right - i.width, r = e === "rtl" ? u : o, s = e === "rtl" ? o : u, h = t.y + n.top, l = t.y + t.height - n.bottom - i.height, a = t.x + (t.width - i.width) / 2, f = t.y + (t.height - i.height) / 2;
+  switch (c) {
+    case "inline-start":
+      return { x: r, y: f };
+    case "inline-end":
+      return { x: s, y: f };
+    case "block-start":
+      return { x: a, y: h };
+    case "block-end":
+      return { x: a, y: l };
+    case "block-start-inline-start":
+      return { x: r, y: h };
+    case "block-start-inline-end":
+      return { x: s, y: h };
+    case "block-end-inline-start":
+      return { x: r, y: l };
+    case "block-end-inline-end":
+      return { x: s, y: l };
+    default:
+      return { x: a, y: f };
+  }
+}
+function w({
+  boundary: t,
+  direction: e,
+  padding: n,
+  positions: c,
+  size: i
+}) {
+  return c.map((o) => ({
+    key: o,
+    ...x({
+      boundary: t,
+      direction: e,
+      padding: n,
+      position: o,
+      size: i
+    })
+  }));
+}
+function p(t) {
+  const e = Math.max(0, t);
+  return { top: e, right: e, bottom: e, left: e };
+}
+export {
+  g as getPositionSnapBoundaryRect,
+  x as resolvePositionSnapPoint,
+  w as resolvePositionSnapTargets,
+  p as uniformPositionSnapPadding
+};

package/dist/components/PositionSnap/gesture.js

@@ -0,0 +1,7 @@
+import { ocSpring as o } from "../../utils/spring.js";
+const r = o.snappy({
+  duration: 1 / 12
+});
+export {
+  r as POSITION_SNAP_DRAG_FOLLOWER_SPRING
+};

package/dist/components/PositionSnap/policy.js

@@ -0,0 +1,60 @@
+function a(n, t, _) {
+  return Math.min(Math.max(n, t), _);
+}
+function c(n, t) {
+  return Math.hypot(n.x - t.x, n.y - t.y);
+}
+function R(n, t) {
+  return n.reduce(
+    (_, S) => c(S, t) < c(_, t) ? S : _
+  );
+}
+function C({
+  currentPoint: n,
+  velocity: t,
+  targets: _
+}) {
+  const S = {
+    x: n.x + a(
+      t.x * 0.16,
+      -24,
+      24
+    ),
+    y: n.y + a(
+      t.y * 0.16,
+      -24,
+      24
+    )
+  };
+  if (!(Math.hypot(t.x, t.y) / 1e3 > 0.55)) return R(_, n);
+  const o = _.filter((s) => {
+    const A = s.x - n.x, E = s.y - n.y;
+    return A * t.x + E * t.y > 0;
+  });
+  return R(
+    o.length ? o : _,
+    S
+  );
+}
+function x(n, t, _, S) {
+  if (n >= t && n <= _) return n;
+  const N = n < t ? t : _, o = Math.abs(n - N), s = o * 0.55 * S / (S + 0.55 * o);
+  return n < t ? N - s : N + s;
+}
+function O({
+  point: n,
+  size: t,
+  targets: _
+}) {
+  const S = _.map((P) => P.x), N = _.map((P) => P.y), o = Math.min(...S), s = Math.max(...S), A = Math.min(...N), E = Math.max(...N);
+  return {
+    x: x(n.x, o, s, Math.max(t.width, 1)),
+    y: x(n.y, A, E, Math.max(t.height, 1))
+  };
+}
+export {
+  R as getNearestPositionSnapTarget,
+  c as getPositionSnapPointDistance,
+  C as getReleasePositionSnapTarget,
+  O as resolvePositionSnapDragPoint
+};

package/dist/components/PositionSnap.d.ts

@@ -0,0 +1,6 @@
+export * from '../ui/src/components/PositionSnap/index'
+export {}
+import _default from '../ui/src/components/PositionSnap/index'
+export default _default
+export * from '../ui/src/components/PositionSnap/index'
+export {}