@lodev09/react-native-true-sheet 4.0.0-beta.0 → 4.0.0-beta.2

package/lib/module/web/vaul/use-prevent-scroll.js

@@ -0,0 +1,258 @@
+"use strict";
+
+// This code comes from https://github.com/adobe/react-spectrum/blob/main/packages/%40react-aria/overlays/src/usePreventScroll.ts
+
+import { useEffect, useLayoutEffect } from 'react';
+import { isIOS } from "./browser.js";
+const KEYBOARD_BUFFER = 24;
+export const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
+function chain(...callbacks) {
+  return (...args) => {
+    for (let callback of callbacks) {
+      if (typeof callback === 'function') {
+        callback(...args);
+      }
+    }
+  };
+}
+
+// @ts-ignore
+const visualViewport = typeof document !== 'undefined' && window.visualViewport;
+export function isScrollable(node) {
+  let style = window.getComputedStyle(node);
+  return /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+}
+export function getScrollParent(node) {
+  if (isScrollable(node)) {
+    node = node.parentElement;
+  }
+  while (node && !isScrollable(node)) {
+    node = node.parentElement;
+  }
+  return node || document.scrollingElement || document.documentElement;
+}
+
+// HTML input types that do not cause the software keyboard to appear.
+const nonTextInputTypes = new Set(['checkbox', 'radio', 'range', 'color', 'file', 'image', 'button', 'submit', 'reset']);
+
+// The number of active usePreventScroll calls. Used to determine whether to revert back to the original page style/scroll position
+let preventScrollCount = 0;
+let restore;
+
+/**
+ * Prevents scrolling on the document body on mount, and
+ * restores it on unmount. Also ensures that content does not
+ * shift due to the scrollbars disappearing.
+ */
+export function usePreventScroll(options = {}) {
+  let {
+    isDisabled
+  } = options;
+  useIsomorphicLayoutEffect(() => {
+    if (isDisabled) {
+      return;
+    }
+    preventScrollCount++;
+    if (preventScrollCount === 1) {
+      if (isIOS()) {
+        restore = preventScrollMobileSafari();
+      }
+    }
+    return () => {
+      preventScrollCount--;
+      if (preventScrollCount === 0) {
+        restore?.();
+      }
+    };
+  }, [isDisabled]);
+}
+
+// Mobile Safari is a whole different beast. Even with overflow: hidden,
+// it still scrolls the page in many situations:
+//
+// 1. When the bottom toolbar and address bar are collapsed, page scrolling is always allowed.
+// 2. When the keyboard is visible, the viewport does not resize. Instead, the keyboard covers part of
+//    it, so it becomes scrollable.
+// 3. When tapping on an input, the page always scrolls so that the input is centered in the visual viewport.
+//    This may cause even fixed position elements to scroll off the screen.
+// 4. When using the next/previous buttons in the keyboard to navigate between inputs, the whole page always
+//    scrolls, even if the input is inside a nested scrollable element that could be scrolled instead.
+//
+// In order to work around these cases, and prevent scrolling without jankiness, we do a few things:
+//
+// 1. Prevent default on `touchmove` events that are not in a scrollable element. This prevents touch scrolling
+//    on the window.
+// 2. Prevent default on `touchmove` events inside a scrollable element when the scroll position is at the
+//    top or bottom. This avoids the whole page scrolling instead, but does prevent overscrolling.
+// 3. Prevent default on `touchend` events on input elements and handle focusing the element ourselves.
+// 4. When focusing an input, apply a transform to trick Safari into thinking the input is at the top
+//    of the page, which prevents it from scrolling the page. After the input is focused, scroll the element
+//    into view ourselves, without scrolling the whole page.
+// 5. Offset the body by the scroll position using a negative margin and scroll to the top. This should appear the
+//    same visually, but makes the actual scroll position always zero. This is required to make all of the
+//    above work or Safari will still try to scroll the page when focusing an input.
+// 6. As a last resort, handle window scroll events, and scroll back to the top. This can happen when attempting
+//    to navigate to an input with the next/previous buttons that's outside a modal.
+function preventScrollMobileSafari() {
+  let scrollable;
+  let lastY = 0;
+  let onTouchStart = e => {
+    // Store the nearest scrollable parent element from the element that the user touched.
+    scrollable = getScrollParent(e.target);
+    if (scrollable === document.documentElement && scrollable === document.body) {
+      return;
+    }
+    lastY = e.changedTouches[0]?.pageY ?? 0;
+  };
+  let onTouchMove = e => {
+    // Prevent scrolling the window.
+    if (!scrollable || scrollable === document.documentElement || scrollable === document.body) {
+      e.preventDefault();
+      return;
+    }
+
+    // Prevent scrolling up when at the top and scrolling down when at the bottom
+    // of a nested scrollable area, otherwise mobile Safari will start scrolling
+    // the window instead. Unfortunately, this disables bounce scrolling when at
+    // the top but it's the best we can do.
+    let y = e.changedTouches[0]?.pageY ?? 0;
+    let scrollTop = scrollable.scrollTop;
+    let bottom = scrollable.scrollHeight - scrollable.clientHeight;
+    if (bottom === 0) {
+      return;
+    }
+    if (scrollTop <= 0 && y > lastY || scrollTop >= bottom && y < lastY) {
+      e.preventDefault();
+    }
+    lastY = y;
+  };
+  let onTouchEnd = e => {
+    let target = e.target;
+
+    // Apply this change if we're not already focused on the target element
+    if (isInput(target) && target !== document.activeElement) {
+      e.preventDefault();
+
+      // Apply a transform to trick Safari into thinking the input is at the top of the page
+      // so it doesn't try to scroll it into view. When tapping on an input, this needs to
+      // be done before the "focus" event, so we have to focus the element ourselves.
+      target.style.transform = 'translateY(-2000px)';
+      target.focus();
+      requestAnimationFrame(() => {
+        target.style.transform = '';
+      });
+    }
+  };
+  let onFocus = e => {
+    let target = e.target;
+    if (isInput(target)) {
+      // Transform also needs to be applied in the focus event in cases where focus moves
+      // other than tapping on an input directly, e.g. the next/previous buttons in the
+      // software keyboard. In these cases, it seems applying the transform in the focus event
+      // is good enough, whereas when tapping an input, it must be done before the focus event. 🤷‍♂️
+      target.style.transform = 'translateY(-2000px)';
+      requestAnimationFrame(() => {
+        target.style.transform = '';
+
+        // This will have prevented the browser from scrolling the focused element into view,
+        // so we need to do this ourselves in a way that doesn't cause the whole page to scroll.
+        if (visualViewport) {
+          if (visualViewport.height < window.innerHeight) {
+            // If the keyboard is already visible, do this after one additional frame
+            // to wait for the transform to be removed.
+            requestAnimationFrame(() => {
+              scrollIntoView(target);
+            });
+          } else {
+            // Otherwise, wait for the visual viewport to resize before scrolling so we can
+            // measure the correct position to scroll to.
+            visualViewport.addEventListener('resize', () => scrollIntoView(target), {
+              once: true
+            });
+          }
+        }
+      });
+    }
+  };
+  let onWindowScroll = () => {
+    // Last resort. If the window scrolled, scroll it back to the top.
+    // It should always be at the top because the body will have a negative margin (see below).
+    window.scrollTo(0, 0);
+  };
+
+  // Record the original scroll position so we can restore it.
+  // Then apply a negative margin to the body to offset it by the scroll position. This will
+  // enable us to scroll the window to the top, which is required for the rest of this to work.
+  let scrollX = window.pageXOffset;
+  let scrollY = window.pageYOffset;
+  let restoreStyles = chain(setStyle(document.documentElement, 'paddingRight', `${window.innerWidth - document.documentElement.clientWidth}px`)
+  // setStyle(document.documentElement, 'overflow', 'hidden'),
+  // setStyle(document.body, 'marginTop', `-${scrollY}px`),
+  );
+
+  // Scroll to the top. The negative margin on the body will make this appear the same.
+  window.scrollTo(0, 0);
+  let removeEvents = chain(addEvent(document, 'touchstart', onTouchStart, {
+    passive: false,
+    capture: true
+  }), addEvent(document, 'touchmove', onTouchMove, {
+    passive: false,
+    capture: true
+  }), addEvent(document, 'touchend', onTouchEnd, {
+    passive: false,
+    capture: true
+  }), addEvent(document, 'focus', onFocus, true), addEvent(window, 'scroll', onWindowScroll));
+  return () => {
+    // Restore styles and scroll the page back to where it was.
+    restoreStyles();
+    removeEvents();
+    window.scrollTo(scrollX, scrollY);
+  };
+}
+
+// Sets a CSS property on an element, and returns a function to revert it to the previous value.
+function setStyle(element, style, value) {
+  // https://github.com/microsoft/TypeScript/issues/17827#issuecomment-391663310
+  // @ts-ignore
+  let cur = element.style[style];
+  // @ts-ignore
+  element.style[style] = value;
+  return () => {
+    // @ts-ignore
+    element.style[style] = cur;
+  };
+}
+
+// Adds an event listener to an element, and returns a function to remove it.
+function addEvent(target, event, handler, options) {
+  // @ts-ignore
+  target.addEventListener(event, handler, options);
+  return () => {
+    // @ts-ignore
+    target.removeEventListener(event, handler, options);
+  };
+}
+function scrollIntoView(target) {
+  let root = document.scrollingElement || document.documentElement;
+  while (target && target !== root) {
+    // Find the parent scrollable element and adjust the scroll position if the target is not already in view.
+    let scrollable = getScrollParent(target);
+    if (scrollable !== document.documentElement && scrollable !== document.body && scrollable !== target) {
+      let scrollableTop = scrollable.getBoundingClientRect().top;
+      let targetTop = target.getBoundingClientRect().top;
+      let targetBottom = target.getBoundingClientRect().bottom;
+      // Buffer is needed for some edge cases
+      const keyboardHeight = scrollable.getBoundingClientRect().bottom + KEYBOARD_BUFFER;
+      if (targetBottom > keyboardHeight) {
+        scrollable.scrollTop += targetTop - scrollableTop;
+      }
+    }
+
+    // @ts-ignore
+    target = scrollable.parentElement;
+  }
+}
+export function isInput(target) {
+  return target instanceof HTMLInputElement && !nonTextInputTypes.has(target.type) || target instanceof HTMLTextAreaElement || target instanceof HTMLElement && target.isContentEditable;
+}
+//# sourceMappingURL=use-prevent-scroll.js.map

package/lib/module/web/vaul/use-prevent-scroll.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useLayoutEffect","isIOS","KEYBOARD_BUFFER","useIsomorphicLayoutEffect","window","chain","callbacks","args","callback","visualViewport","document","isScrollable","node","style","getComputedStyle","test","overflow","overflowX","overflowY","getScrollParent","parentElement","scrollingElement","documentElement","nonTextInputTypes","Set","preventScrollCount","restore","usePreventScroll","options","isDisabled","preventScrollMobileSafari","scrollable","lastY","onTouchStart","e","target","body","changedTouches","pageY","onTouchMove","preventDefault","y","scrollTop","bottom","scrollHeight","clientHeight","onTouchEnd","isInput","activeElement","transform","focus","requestAnimationFrame","onFocus","height","innerHeight","scrollIntoView","addEventListener","once","onWindowScroll","scrollTo","scrollX","pageXOffset","scrollY","pageYOffset","restoreStyles","setStyle","innerWidth","clientWidth","removeEvents","addEvent","passive","capture","element","value","cur","event","handler","removeEventListener","root","scrollableTop","getBoundingClientRect","top","targetTop","targetBottom","keyboardHeight","HTMLInputElement","has","type","HTMLTextAreaElement","HTMLElement","isContentEditable"],"sourceRoot":"../../../../src","sources":["web/vaul/use-prevent-scroll.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/web/vaul/use-scale-background.js

@@ -0,0 +1,57 @@
+"use strict";
+
+// @ts-nocheck — vendored upstream, incompatible with noImplicitReturns
+import React, { useMemo } from 'react';
+import { useDrawerContext } from "./context.js";
+import { assignStyle, chain, isVertical } from "./helpers.js";
+import { BORDER_RADIUS, TRANSITIONS, WINDOW_TOP_OFFSET } from "./constants.js";
+const noop = () => () => {};
+export function useScaleBackground() {
+  const {
+    direction,
+    isOpen,
+    shouldScaleBackground,
+    setBackgroundColorOnScale,
+    noBodyStyles
+  } = useDrawerContext();
+  const timeoutIdRef = React.useRef(null);
+  const initialBackgroundColor = useMemo(() => document.body.style.backgroundColor, []);
+  function getScale() {
+    return (window.innerWidth - WINDOW_TOP_OFFSET) / window.innerWidth;
+  }
+  React.useEffect(() => {
+    if (isOpen && shouldScaleBackground) {
+      if (timeoutIdRef.current) clearTimeout(timeoutIdRef.current);
+      const wrapper = document.querySelector('[data-vaul-drawer-wrapper]') || document.querySelector('[vaul-drawer-wrapper]');
+      if (!wrapper) return;
+      chain(setBackgroundColorOnScale && !noBodyStyles ? assignStyle(document.body, {
+        background: 'black'
+      }) : noop, assignStyle(wrapper, {
+        transformOrigin: isVertical(direction) ? 'top' : 'left',
+        transitionProperty: 'transform, border-radius',
+        transitionDuration: `${TRANSITIONS.DURATION}s`,
+        transitionTimingFunction: `cubic-bezier(${TRANSITIONS.EASE.join(',')})`
+      }));
+      const wrapperStylesCleanup = assignStyle(wrapper, {
+        borderRadius: `${BORDER_RADIUS}px`,
+        overflow: 'hidden',
+        ...(isVertical(direction) ? {
+          transform: `scale(${getScale()}) translate3d(0, calc(env(safe-area-inset-top) + 14px), 0)`
+        } : {
+          transform: `scale(${getScale()}) translate3d(calc(env(safe-area-inset-top) + 14px), 0, 0)`
+        })
+      });
+      return () => {
+        wrapperStylesCleanup();
+        timeoutIdRef.current = window.setTimeout(() => {
+          if (initialBackgroundColor) {
+            document.body.style.background = initialBackgroundColor;
+          } else {
+            document.body.style.removeProperty('background');
+          }
+        }, TRANSITIONS.DURATION * 1000);
+      };
+    }
+  }, [isOpen, shouldScaleBackground, initialBackgroundColor]);
+}
+//# sourceMappingURL=use-scale-background.js.map

package/lib/module/web/vaul/use-scale-background.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useMemo","useDrawerContext","assignStyle","chain","isVertical","BORDER_RADIUS","TRANSITIONS","WINDOW_TOP_OFFSET","noop","useScaleBackground","direction","isOpen","shouldScaleBackground","setBackgroundColorOnScale","noBodyStyles","timeoutIdRef","useRef","initialBackgroundColor","document","body","style","backgroundColor","getScale","window","innerWidth","useEffect","current","clearTimeout","wrapper","querySelector","background","transformOrigin","transitionProperty","transitionDuration","DURATION","transitionTimingFunction","EASE","join","wrapperStylesCleanup","borderRadius","overflow","transform","setTimeout","removeProperty"],"sourceRoot":"../../../../src","sources":["web/vaul/use-scale-background.ts"],"mappings":";;AAAA;AACA,OAAOA,KAAK,IAAIC,OAAO,QAAQ,OAAO;AACtC,SAASC,gBAAgB,QAAQ,cAAW;AAC5C,SAASC,WAAW,EAAEC,KAAK,EAAEC,UAAU,QAAQ,cAAW;AAC1D,SAASC,aAAa,EAAEC,WAAW,EAAEC,iBAAiB,QAAQ,gBAAa;AAE3E,MAAMC,IAAI,GAAGA,CAAA,KAAM,MAAM,CAAC,CAAC;AAE3B,OAAO,SAASC,kBAAkBA,CAAA,EAAG;EACnC,MAAM;IAAEC,SAAS;IAAEC,MAAM;IAAEC,qBAAqB;IAAEC,yBAAyB;IAAEC;EAAa,CAAC,GACzFb,gBAAgB,CAAC,CAAC;EACpB,MAAMc,YAAY,GAAGhB,KAAK,CAACiB,MAAM,CAAgB,IAAI,CAAC;EACtD,MAAMC,sBAAsB,GAAGjB,OAAO,CAAC,MAAMkB,QAAQ,CAACC,IAAI,CAACC,KAAK,CAACC,eAAe,EAAE,EAAE,CAAC;EAErF,SAASC,QAAQA,CAAA,EAAG;IAClB,OAAO,CAACC,MAAM,CAACC,UAAU,GAAGjB,iBAAiB,IAAIgB,MAAM,CAACC,UAAU;EACpE;EAEAzB,KAAK,CAAC0B,SAAS,CAAC,MAAM;IACpB,IAAId,MAAM,IAAIC,qBAAqB,EAAE;MACnC,IAAIG,YAAY,CAACW,OAAO,EAAEC,YAAY,CAACZ,YAAY,CAACW,OAAO,CAAC;MAC5D,MAAME,OAAO,GACVV,QAAQ,CAACW,aAAa,CAAC,4BAA4B,CAAC,IACpDX,QAAQ,CAACW,aAAa,CAAC,uBAAuB,CAAiB;MAElE,IAAI,CAACD,OAAO,EAAE;MAEdzB,KAAK,CACHU,yBAAyB,IAAI,CAACC,YAAY,GACtCZ,WAAW,CAACgB,QAAQ,CAACC,IAAI,EAAE;QAAEW,UAAU,EAAE;MAAQ,CAAC,CAAC,GACnDtB,IAAI,EACRN,WAAW,CAAC0B,OAAO,EAAE;QACnBG,eAAe,EAAE3B,UAAU,CAACM,SAAS,CAAC,GAAG,KAAK,GAAG,MAAM;QACvDsB,kBAAkB,EAAE,0BAA0B;QAC9CC,kBAAkB,EAAE,GAAG3B,WAAW,CAAC4B,QAAQ,GAAG;QAC9CC,wBAAwB,EAAE,gBAAgB7B,WAAW,CAAC8B,IAAI,CAACC,IAAI,CAAC,GAAG,CAAC;MACtE,CAAC,CACH,CAAC;MAED,MAAMC,oBAAoB,GAAGpC,WAAW,CAAC0B,OAAO,EAAE;QAChDW,YAAY,EAAE,GAAGlC,aAAa,IAAI;QAClCmC,QAAQ,EAAE,QAAQ;QAClB,IAAIpC,UAAU,CAACM,SAAS,CAAC,GACrB;UACE+B,SAAS,EAAE,SAASnB,QAAQ,CAAC,CAAC;QAChC,CAAC,GACD;UACEmB,SAAS,EAAE,SAASnB,QAAQ,CAAC,CAAC;QAChC,CAAC;MACP,CAAC,CAAC;MAEF,OAAO,MAAM;QACXgB,oBAAoB,CAAC,CAAC;QACtBvB,YAAY,CAACW,OAAO,GAAGH,MAAM,CAACmB,UAAU,CAAC,MAAM;UAC7C,IAAIzB,sBAAsB,EAAE;YAC1BC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAACU,UAAU,GAAGb,sBAAsB;UACzD,CAAC,MAAM;YACLC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAACuB,cAAc,CAAC,YAAY,CAAC;UAClD;QACF,CAAC,EAAErC,WAAW,CAAC4B,QAAQ,GAAG,IAAI,CAAC;MACjC,CAAC;IACH;EACF,CAAC,EAAE,CAACvB,MAAM,EAAEC,qBAAqB,EAAEK,sBAAsB,CAAC,CAAC;AAC7D","ignoreList":[]}

package/lib/module/web/vaul/use-snap-points.js

@@ -0,0 +1,305 @@
+"use strict";
+
+// @ts-nocheck — vendored upstream, incompatible with noUncheckedIndexedAccess
+import React from 'react';
+import { set, isVertical } from "./helpers.js";
+import { DEFAULT_PEEK_HEIGHT, TRANSITIONS, VELOCITY_THRESHOLD } from "./constants.js";
+import { useControllableState } from "./use-controllable-state.js";
+export function useSnapPoints({
+  activeSnapPointProp,
+  setActiveSnapPointProp,
+  snapPoints,
+  drawerRef,
+  overlayRef,
+  fadeFromIndex,
+  onSnapPointChange,
+  direction = 'bottom',
+  container,
+  snapToSequentialPoint,
+  isOpen,
+  contentHeight,
+  detachedOffset = 0,
+  maxContentHeight,
+  peekHeight,
+  initialAnimated = true
+}) {
+  const [activeSnapPoint, setActiveSnapPoint] = useControllableState({
+    prop: activeSnapPointProp,
+    defaultProp: snapPoints?.[0],
+    onChange: setActiveSnapPointProp
+  });
+  const [windowDimensions, setWindowDimensions] = React.useState(typeof window !== 'undefined' ? {
+    innerWidth: window.innerWidth,
+    innerHeight: window.innerHeight
+  } : undefined);
+  React.useEffect(() => {
+    function onResize() {
+      setWindowDimensions({
+        innerWidth: window.innerWidth,
+        innerHeight: window.innerHeight
+      });
+    }
+    window.addEventListener('resize', onResize);
+    return () => window.removeEventListener('resize', onResize);
+  }, []);
+  const isLastSnapPoint = React.useMemo(() => activeSnapPoint === snapPoints?.[snapPoints.length - 1] || null, [snapPoints, activeSnapPoint]);
+  const activeSnapPointIndex = React.useMemo(() => snapPoints?.findIndex(snapPoint => snapPoint === activeSnapPoint) ?? null, [snapPoints, activeSnapPoint]);
+  const shouldFade = snapPoints && snapPoints.length > 0 && (fadeFromIndex || fadeFromIndex === 0) && !Number.isNaN(fadeFromIndex) && snapPoints[fadeFromIndex] === activeSnapPoint || !snapPoints;
+  const snapPointsOffset = React.useMemo(() => {
+    const containerSize = container ? {
+      width: container.getBoundingClientRect().width,
+      height: container.getBoundingClientRect().height
+    } : typeof window !== 'undefined' ? {
+      width: window.innerWidth,
+      height: window.innerHeight
+    } : {
+      width: 0,
+      height: 0
+    };
+
+    // Shrink the effective vertical area by detachedOffset so snap math
+    // reserves a fixed gap at the bottom — the floating card stays offset
+    // from the viewport edge through drag, snap and resize.
+    const effectiveHeight = Math.max(0, containerSize.height - (detachedOffset || 0));
+    return snapPoints?.map(snapPoint => {
+      // 'auto' resolves to measured content height. Falls back to half the
+      // container so the initial snap is close to final before ResizeObserver
+      // reports a real measurement. 'peek' resolves to the caller-measured
+      // header + footer height.
+      const resolved = snapPoint === 'auto' ? `${contentHeight && contentHeight > 0 ? contentHeight : effectiveHeight / 2}px` : snapPoint === 'peek' ? `${peekHeight && peekHeight > 0 ? peekHeight : DEFAULT_PEEK_HEIGHT}px` : snapPoint;
+      const isPx = typeof resolved === 'string';
+      let snapPointAsNumber = 0;
+      if (isPx) {
+        snapPointAsNumber = parseInt(resolved, 10);
+      }
+      if (isVertical(direction)) {
+        const rawHeight = isPx ? snapPointAsNumber : windowDimensions ? resolved * effectiveHeight : 0;
+        // Cap px/'auto' snap points so a content taller than the viewport
+        // doesn't push the drawer past the top edge (offset would go
+        // negative). Fractional detents are already ≤ effectiveHeight.
+        // `maxContentHeight`, when set, caps the visible sheet further so
+        // full/'auto' detents respect the user's ceiling.
+        const ceiling = maxContentHeight !== undefined ? Math.min(effectiveHeight, maxContentHeight) : effectiveHeight;
+        const height = Math.min(rawHeight, ceiling);
+        if (windowDimensions) {
+          return direction === 'bottom' ? effectiveHeight - height : -effectiveHeight + height;
+        }
+        return height;
+      }
+      const rawWidth = isPx ? snapPointAsNumber : windowDimensions ? resolved * containerSize.width : 0;
+      const width = Math.min(rawWidth, containerSize.width);
+      if (windowDimensions) {
+        return direction === 'right' ? containerSize.width - width : -containerSize.width + width;
+      }
+      return width;
+    }) ?? [];
+  }, [snapPoints, windowDimensions, container, contentHeight, detachedOffset, maxContentHeight, peekHeight]);
+  const activeSnapPointOffset = React.useMemo(() => activeSnapPointIndex !== null ? snapPointsOffset?.[activeSnapPointIndex] : null, [snapPointsOffset, activeSnapPointIndex]);
+
+  // Detached-only: the drawer sits inside a clip wrapper. When drag overshoots
+  // below the lowest detent we translate the wrapper by the excess so the
+  // whole floating card follows the pointer instead of the drawer sliding
+  // behind the wrapper's rounded-bottom clip.
+  const setDetachedWrapperTransform = (y, animated) => {
+    if (!drawerRef.current || !isVertical(direction)) return;
+    const wrapper = drawerRef.current.closest('[data-vaul-detached-wrapper]');
+    if (!wrapper) return;
+    set(wrapper, {
+      transition: animated ? `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})` : 'none',
+      transform: `translate3d(0, ${y}px, 0)`
+    });
+  };
+
+  // Skip the transition on the very first snap when the consumer opts out of
+  // the initial presentation animation. All subsequent snaps still animate.
+  const hasSnappedRef = React.useRef(false);
+  const snapToPoint = React.useCallback(dimension => {
+    const newSnapPointIndex = snapPointsOffset?.findIndex(snapPointDim => snapPointDim === dimension) ?? null;
+    onSnapPointChange(newSnapPointIndex);
+    const animateThisSnap = hasSnappedRef.current || initialAnimated;
+    hasSnappedRef.current = true;
+    // `--snap-point-height` transitions alongside `transform` (registered via
+    // @property) so layouts derived from it (e.g. the scrollable fill) resize
+    // in sync with the drawer's slide instead of jumping to the target.
+    set(drawerRef.current, {
+      'transition': animateThisSnap ? `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')}), --snap-point-height ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})` : 'none',
+      'transform': isVertical(direction) ? `translate3d(0, ${dimension}px, 0)` : `translate3d(${dimension}px, 0, 0)`,
+      '--snap-point-height': `${dimension}px`
+    });
+
+    // Snapping implies drag overshoot (if any) should be undone.
+    setDetachedWrapperTransform(0, animateThisSnap);
+    if (snapPointsOffset && newSnapPointIndex !== snapPointsOffset.length - 1 && fadeFromIndex !== undefined && newSnapPointIndex !== fadeFromIndex && newSnapPointIndex < fadeFromIndex) {
+      set(overlayRef.current, {
+        transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,
+        opacity: '0',
+        pointerEvents: 'none'
+      });
+    } else {
+      set(overlayRef.current, {
+        transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,
+        opacity: '1',
+        pointerEvents: 'auto'
+      });
+    }
+    setActiveSnapPoint(snapPoints?.[Math.max(newSnapPointIndex, 0)]);
+  }, [drawerRef.current, snapPoints, snapPointsOffset, fadeFromIndex, overlayRef, setActiveSnapPoint]);
+  React.useEffect(() => {
+    if (!isOpen) return;
+    if (activeSnapPoint || activeSnapPointProp) {
+      const newIndex = snapPoints?.findIndex(snapPoint => snapPoint === activeSnapPointProp || snapPoint === activeSnapPoint) ?? -1;
+      if (snapPointsOffset && newIndex !== -1 && typeof snapPointsOffset[newIndex] === 'number') {
+        snapToPoint(snapPointsOffset[newIndex]);
+      }
+    }
+  }, [isOpen, activeSnapPoint, activeSnapPointProp, snapPoints, snapPointsOffset, snapToPoint]);
+  function onRelease({
+    draggedDistance,
+    closeDrawer,
+    velocity,
+    dismissible
+  }) {
+    if (fadeFromIndex === undefined) return;
+    const currentPosition = direction === 'bottom' || direction === 'right' ? (activeSnapPointOffset ?? 0) - draggedDistance : (activeSnapPointOffset ?? 0) + draggedDistance;
+    const isOverlaySnapPoint = activeSnapPointIndex === fadeFromIndex - 1;
+    const isFirst = activeSnapPointIndex === 0;
+    const hasDraggedUp = draggedDistance > 0;
+    if (isOverlaySnapPoint) {
+      set(overlayRef.current, {
+        transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`
+      });
+    }
+
+    // Distance-based dismiss: when overshooting past the lowest detent by more
+    // than half of its visible height, commit to dismiss regardless of
+    // velocity — lets a slow drag-down still close the sheet.
+    if (dismissible && (direction === 'bottom' || direction === 'right') && currentPosition > snapPointsOffset[0]) {
+      const viewportDim = isVertical(direction) ? window.innerHeight : window.innerWidth;
+      const effectiveDim = Math.max(0, viewportDim - (detachedOffset || 0));
+      const visibleAtLowest = Math.max(0, effectiveDim - snapPointsOffset[0]);
+      const overshoot = currentPosition - snapPointsOffset[0];
+      if (overshoot > visibleAtLowest * 0.5) {
+        closeDrawer();
+        return;
+      }
+    }
+    if (!snapToSequentialPoint && velocity > 2 && !hasDraggedUp) {
+      if (dismissible) closeDrawer();else snapToPoint(snapPointsOffset[0]); // snap to initial point
+      return;
+    }
+    if (!snapToSequentialPoint && velocity > 2 && hasDraggedUp && snapPointsOffset && snapPoints) {
+      snapToPoint(snapPointsOffset[snapPoints.length - 1]);
+      return;
+    }
+
+    // Find the closest snap point to the current position
+    const closestSnapPoint = snapPointsOffset?.reduce((prev, curr) => {
+      if (typeof prev !== 'number' || typeof curr !== 'number') return prev;
+      return Math.abs(curr - currentPosition) < Math.abs(prev - currentPosition) ? curr : prev;
+    });
+    const dim = isVertical(direction) ? window.innerHeight : window.innerWidth;
+    if (velocity > VELOCITY_THRESHOLD && Math.abs(draggedDistance) < dim * 0.4) {
+      const dragDirection = hasDraggedUp ? 1 : -1; // 1 = up, -1 = down
+
+      // Don't do anything if we swipe upwards while being on the last snap point
+      if (dragDirection > 0 && isLastSnapPoint && snapPoints) {
+        snapToPoint(snapPointsOffset[snapPoints.length - 1]);
+        return;
+      }
+      if (isFirst && dragDirection < 0 && dismissible) {
+        closeDrawer();
+      }
+      if (activeSnapPointIndex === null) return;
+      snapToPoint(snapPointsOffset[activeSnapPointIndex + dragDirection]);
+      return;
+    }
+    snapToPoint(closestSnapPoint);
+  }
+  function onDrag({
+    draggedDistance
+  }) {
+    if (activeSnapPointOffset === null) return;
+    const newValue = direction === 'bottom' || direction === 'right' ? activeSnapPointOffset - draggedDistance : activeSnapPointOffset + draggedDistance;
+
+    // Don't do anything if we exceed the last(biggest) snap point
+    if ((direction === 'bottom' || direction === 'right') && newValue < snapPointsOffset[snapPointsOffset.length - 1]) {
+      return;
+    }
+    if ((direction === 'top' || direction === 'left') && newValue > snapPointsOffset[snapPointsOffset.length - 1]) {
+      return;
+    }
+
+    // Past the lowest detent: cap the drawer and translate the detached
+    // wrapper by the excess so the floating card follows the pointer.
+    if ((direction === 'bottom' || direction === 'right') && newValue > snapPointsOffset[0]) {
+      const excess = newValue - snapPointsOffset[0];
+      set(drawerRef.current, {
+        'transform': isVertical(direction) ? `translate3d(0, ${snapPointsOffset[0]}px, 0)` : `translate3d(${snapPointsOffset[0]}px, 0, 0)`,
+        '--snap-point-height': `${snapPointsOffset[0]}px`
+      });
+      setDetachedWrapperTransform(excess, false);
+      return;
+    }
+    setDetachedWrapperTransform(0, false);
+    // Keep `--snap-point-height` tracking the live drag position so layouts
+    // derived from it (e.g. the scrollable fill) resize with the drawer
+    // instead of staying cut off at the last detent's visible height.
+    set(drawerRef.current, {
+      'transform': isVertical(direction) ? `translate3d(0, ${newValue}px, 0)` : `translate3d(${newValue}px, 0, 0)`,
+      '--snap-point-height': `${newValue}px`
+    });
+  }
+  function getPercentageDragged(absDraggedDistance, isDraggingDown) {
+    if (!snapPoints || typeof activeSnapPointIndex !== 'number' || !snapPointsOffset || fadeFromIndex === undefined) return null;
+
+    // fadeFromIndex === 0 means every snap point is fully dimmed. Only the dismiss drag
+    // (toward close from the smallest detent) should fade the overlay out, interpolating
+    // opacity by distance from the smallest snap to the fully-dismissed position.
+    if (fadeFromIndex === 0) {
+      if (activeSnapPointIndex === 0 && !isDraggingDown) {
+        const activeOffset = snapPointsOffset[activeSnapPointIndex];
+        if (activeOffset === undefined) return 0;
+        const windowDim = isVertical(direction) ? window.innerHeight : window.innerWidth;
+        const dismissOffset = direction === 'bottom' || direction === 'right' ? windowDim : -windowDim;
+        const dismissRange = Math.abs(dismissOffset - activeOffset);
+        return dismissRange > 0 ? Math.min(1, absDraggedDistance / dismissRange) : 0;
+      }
+      return 0;
+    }
+
+    // If this is true we are dragging to a snap point that is supposed to have an overlay
+    const isOverlaySnapPoint = activeSnapPointIndex === fadeFromIndex - 1;
+    const isOverlaySnapPointOrHigher = activeSnapPointIndex >= fadeFromIndex;
+    if (isOverlaySnapPointOrHigher && isDraggingDown) {
+      return 0;
+    }
+
+    // Don't animate, but still use this one if we are dragging away from the overlaySnapPoint
+    if (isOverlaySnapPoint && !isDraggingDown) return 1;
+    if (!shouldFade && !isOverlaySnapPoint) return null;
+
+    // Either fadeFrom index or the one before
+    const targetSnapPointIndex = isOverlaySnapPoint ? activeSnapPointIndex + 1 : activeSnapPointIndex - 1;
+
+    // Get the distance from overlaySnapPoint to the one before or vice-versa to calculate the opacity percentage accordingly
+    const snapPointDistance = isOverlaySnapPoint ? snapPointsOffset[targetSnapPointIndex] - snapPointsOffset[targetSnapPointIndex - 1] : snapPointsOffset[targetSnapPointIndex + 1] - snapPointsOffset[targetSnapPointIndex];
+    const percentageDragged = absDraggedDistance / Math.abs(snapPointDistance);
+    if (isOverlaySnapPoint) {
+      return 1 - percentageDragged;
+    } else {
+      return percentageDragged;
+    }
+  }
+  return {
+    isLastSnapPoint,
+    activeSnapPoint,
+    shouldFade,
+    getPercentageDragged,
+    setActiveSnapPoint,
+    activeSnapPointIndex,
+    onRelease,
+    onDrag,
+    snapPointsOffset
+  };
+}
+//# sourceMappingURL=use-snap-points.js.map