@hanzogui/sheet 7.0.0 → 7.3.0

package/dist/esm/SheetContext.native.js

@@ -0,0 +1,6 @@
+import { createContextScope } from "@hanzogui/create-context";
+import { SHEET_NAME } from "./constants.native.js";
+var [createSheetContext, createSheetScope] = createContextScope(SHEET_NAME);
+var [SheetProvider, useSheetContext] = createSheetContext(SHEET_NAME, {});
+export { SheetProvider, createSheetContext, createSheetScope, useSheetContext };
+//# sourceMappingURL=SheetContext.native.js.map

package/dist/esm/SheetContext.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createContextScope","SHEET_NAME","createSheetContext","createSheetScope","SheetProvider","useSheetContext"],"sources":["../../src/SheetContext.tsx"],"sourcesContent":[null],"mappings":"AAAA,SAASA,kBAAA,QAA0B;AAEnC,SAASC,UAAA,QAAkB;AAGpB,KAAAC,kBAAO,EAAAC,gBAAoB,IAAgBH,kBAAI,CAAAC,UAAmB;AAElE,KAAAG,aAAO,EAAAC,eAAe,IAAeH,kBAAI,CAAAD,UAAA;AAAA,SAE9CG,aAAC,EACHF,kBAAA,E","ignoreList":[]}

package/dist/esm/SheetController.mjs

@@ -0,0 +1,37 @@
+import React, { useId, useRef } from "react";
+import { useEvent } from "@hanzogui/core";
+import { SheetControllerContext } from "./useSheetController.mjs";
+import { jsx } from "react/jsx-runtime";
+const SheetController = ({
+  children,
+  onOpenChange: onOpenChangeProp,
+  onAnimationComplete: onAnimationCompleteProp,
+  open,
+  hidden,
+  disableDrag
+}) => {
+  const onOpenChange = useEvent(onOpenChangeProp);
+  const onAnimationComplete = useEvent(onAnimationCompleteProp);
+  const id = useId();
+  const wasHiddenRef = useRef(hidden);
+  let skipNextAnimation = false;
+  if (wasHiddenRef.current && !hidden && open) {
+    skipNextAnimation = true;
+  }
+  wasHiddenRef.current = hidden;
+  const memoValue = React.useMemo(() => ({
+    id,
+    open,
+    hidden,
+    disableDrag,
+    onOpenChange,
+    onAnimationComplete,
+    skipNextAnimation
+  }), [id, onOpenChange, onAnimationComplete, open, hidden, disableDrag, skipNextAnimation]);
+  return /* @__PURE__ */jsx(SheetControllerContext.Provider, {
+    value: memoValue,
+    children
+  });
+};
+export { SheetController };
+//# sourceMappingURL=SheetController.mjs.map

package/dist/esm/SheetController.mjs.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useId","useRef","useEvent","SheetControllerContext","jsx","SheetController","children","onOpenChange","onOpenChangeProp","onAnimationComplete","onAnimationCompleteProp","open","hidden","disableDrag","id","wasHiddenRef","skipNextAnimation","current","memoValue","useMemo","Provider","value"],"sources":["../../src/SheetController.tsx"],"sourcesContent":[null],"mappings":"AAAA,OAAOA,KAAA,IAASC,KAAA,EAAOC,MAAA,QAAc;AACrC,SAASC,QAAA,QAAgB;AAIzB,SAASC,sBAAA,QAA8B;AAqCnC,SAAAC,GAAA;AAnCG,MAAMC,eAAA,GAAkBA,CAAC;EAC9BC,QAAA;EACAC,YAAA,EAAcC,gBAAA;EACdC,mBAAA,EAAqBC,uBAAA;EACrBC,IAAA;EACAC,MAAA;EACAC;AACF,MAAuE;EACrE,MAAMN,YAAA,GAAeL,QAAA,CAASM,gBAAgB;EAC9C,MAAMC,mBAAA,GAAsBP,QAAA,CAASQ,uBAAuB;EAC5D,MAAMI,EAAA,GAAKd,KAAA,CAAM;EAIjB,MAAMe,YAAA,GAAed,MAAA,CAAOW,MAAM;EAClC,IAAII,iBAAA,GAAoB;EACxB,IAAID,YAAA,CAAaE,OAAA,IAAW,CAACL,MAAA,IAAUD,IAAA,EAAM;IAC3CK,iBAAA,GAAoB;EACtB;EACAD,YAAA,CAAaE,OAAA,GAAUL,MAAA;EAEvB,MAAMM,SAAA,GAAYnB,KAAA,CAAMoB,OAAA,CACtB,OAAO;IACLL,EAAA;IACAH,IAAA;IACAC,MAAA;IACAC,WAAA;IACAN,YAAA;IACAE,mBAAA;IACAO;EACF,IACA,CAACF,EAAA,EAAIP,YAAA,EAAcE,mBAAA,EAAqBE,IAAA,EAAMC,MAAA,EAAQC,WAAA,EAAaG,iBAAiB,CACtF;EAEA,OACE,eAAAZ,GAAA,CAACD,sBAAA,CAAuBiB,QAAA,EAAvB;IAAgCC,KAAA,EAAOH,SAAA;IACrCZ;EAAA,CACH;AAEJ","ignoreList":[]}

package/dist/esm/SheetController.native.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { useId, useRef } from "react";
+import { useEvent } from "@hanzogui/core";
+import { SheetControllerContext } from "./useSheetController.native.js";
+var SheetController = function (param) {
+  var {
+    children,
+    onOpenChange: onOpenChangeProp,
+    onAnimationComplete: onAnimationCompleteProp,
+    open,
+    hidden,
+    disableDrag
+  } = param;
+  var onOpenChange = useEvent(onOpenChangeProp);
+  var onAnimationComplete = useEvent(onAnimationCompleteProp);
+  var id = useId();
+  var wasHiddenRef = useRef(hidden);
+  var skipNextAnimation = false;
+  if (wasHiddenRef.current && !hidden && open) {
+    skipNextAnimation = true;
+  }
+  wasHiddenRef.current = hidden;
+  var memoValue = React.useMemo(function () {
+    return {
+      id,
+      open,
+      hidden,
+      disableDrag,
+      onOpenChange,
+      onAnimationComplete,
+      skipNextAnimation
+    };
+  }, [id, onOpenChange, onAnimationComplete, open, hidden, disableDrag, skipNextAnimation]);
+  return /* @__PURE__ */_jsx(SheetControllerContext.Provider, {
+    value: memoValue,
+    children
+  });
+};
+export { SheetController };
+//# sourceMappingURL=SheetController.native.js.map

package/dist/esm/SheetController.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["jsx","_jsx","React","useId","useRef","useEvent","SheetControllerContext","SheetController","param","children","onOpenChange","onOpenChangeProp","onAnimationComplete","onAnimationCompleteProp","open","hidden","disableDrag","id","wasHiddenRef","skipNextAnimation","current","memoValue","useMemo","Provider"],"sources":["../../src/SheetController.tsx"],"sourcesContent":[null],"mappings":"AAAA,SAAOA,GAAA,IAASC,IAAA,QAAO,mBAAc;AACrC,OAAAC,KAAS,IAAAC,KAAA,EAAAC,MAAgB;AAIzB,SAASC,QAAA,wBAA8B;AAqCnC,SAAAC,sBAAA;AAnCG,IAAAC,eAAM,YAAAA,CAAmBC,KAAA;EAC9B;IAAAC,QAAA;IAAAC,YAAA,EAAAC,gBAAA;IAAAC,mBAAA,EAAAC,uBAAA;IAAAC,IAAA;IAAAC,MAAA;IAAAC;EAAA,IAAAR,KAAA;EACA,IAAAE,YAAc,GAAAL,QAAA,CAAAM,gBAAA;EACd,IAAAC,mBAAqB,GAAAP,QAAA,CAAAQ,uBAAA;EACrB,IAAAI,EAAA,GAAAd,KAAA;EACA,IAAAe,YAAA,GAAAd,MAAA,CAAAW,MAAA;EACA,IAAAI,iBAAA;EACF,IAAuED,YAAA,CAAAE,OAAA,KAAAL,MAAA,IAAAD,IAAA;IACrEK,iBAAM,GAAe;EACrB;EACAD,YAAW,CAAAE,OAAM,GAAAL,MAAA;EAIjB,IAAAM,SAAM,GAAAnB,KAAe,CAAAoB,OAAO,aAAM;IAClC,OAAI;MACAL,EAAA;MACFH,IAAA;MACFC,MAAA;MACAC,WAAa;MAEbN,YAAM;MACJE,mBAAO;MACLO;IAAA;EACA,IACAF,EACA,EAAAP,YACA,EAAAE,mBACA,EAAAE,IACA,EACFC,MAAA,EACAC,WAAK,EACPG,iBAAA,CAEA;EAKF,sBAAAlB,IAAA,CAAAK,sBAAA,CAAAiB,QAAA","ignoreList":[]}

package/dist/esm/SheetImplementationCustom.mjs

@@ -0,0 +1,552 @@
+import { ProvideAdaptContext, useAdaptContext } from "@hanzogui/adapt";
+import { AnimatePresence } from "@hanzogui/animate-presence";
+import { useComposedRefs } from "@hanzogui/compose-refs";
+import { isWeb, useIsomorphicLayoutEffect } from "@hanzogui/constants";
+import { LayoutMeasurementController, View as GuiView, useConfiguration, useDidFinishSSR, useEvent, useThemeName } from "@hanzogui/core";
+import { getSafeArea } from "@hanzogui/native";
+import { needsPortalRepropagation, Portal } from "@hanzogui/portal";
+import React, { useState } from "react";
+import { Dimensions, PanResponder, View } from "react-native-web";
+import { ParentSheetContext, SheetInsideSheetContext } from "./contexts.mjs";
+import { GestureDetectorWrapper } from "./GestureDetectorWrapper.mjs";
+import { GestureSheetProvider } from "./GestureSheetContext.mjs";
+import { resisted } from "./helpers.mjs";
+import { SheetProvider } from "./SheetContext.mjs";
+import { useGestureHandlerPan } from "./useGestureHandlerPan.mjs";
+import { useKeyboardControllerSheet } from "./useKeyboardControllerSheet.mjs";
+import { useSheetOpenState } from "./useSheetOpenState.mjs";
+import { useSheetProviderProps } from "./useSheetProviderProps.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+const hiddenSize = 10000.1;
+let _cachedSafeAreaTop;
+function getSafeAreaTopInset() {
+  if (_cachedSafeAreaTop !== void 0) return _cachedSafeAreaTop;
+  _cachedSafeAreaTop = getSafeArea().getInsets().top;
+  return _cachedSafeAreaTop;
+}
+let sheetHiddenStyleSheet = null;
+const relativeDimensionTo = isWeb ? "window" : "screen";
+const SheetImplementationCustom = React.forwardRef(function SheetImplementationCustom2(props, forwardedRef) {
+  const parentSheet = React.useContext(ParentSheetContext);
+  const {
+    transition,
+    transitionConfig: transitionConfigProp,
+    modal = false,
+    zIndex = parentSheet.zIndex + 1,
+    moveOnKeyboardChange = false,
+    unmountChildrenWhenHidden = false,
+    portalProps,
+    containerComponent: ContainerComponent = React.Fragment,
+    onAnimationComplete
+  } = props;
+  const state = useSheetOpenState(props);
+  const [overlayComponent, setOverlayComponent] = React.useState(null);
+  const providerProps = useSheetProviderProps(props, state, {
+    onOverlayComponent: setOverlayComponent
+  });
+  const {
+    frameSize,
+    setFrameSize,
+    snapPoints,
+    snapPointsMode,
+    hasFit,
+    position,
+    setPosition,
+    scrollBridge,
+    screenSize,
+    setMaxContentSize,
+    maxSnapPoint
+  } = providerProps;
+  const {
+    open,
+    controller,
+    isHidden
+  } = state;
+  const openRef = React.useRef(open);
+  openRef.current = open;
+  const sheetRef = React.useRef(void 0);
+  const ref = useComposedRefs(forwardedRef, sheetRef, providerProps.contentRef);
+  const {
+    animationDriver
+  } = useConfiguration();
+  if (!animationDriver) throw new Error(`Sheet requires an animation driver to be set`);
+  const transitionConfig = (() => {
+    if (transitionConfigProp) return transitionConfigProp;
+    const [animationProp, animationPropConfig] = !transition ? [] : Array.isArray(transition) ? transition : [transition];
+    if (animationProp && animationDriver.animations?.[animationProp]) return {
+      ...animationDriver.animations[animationProp],
+      ...animationPropConfig
+    };
+    return null;
+  })();
+  const [isShowingInnerSheet, setIsShowingInnerSheet] = React.useState(false);
+  const shouldHideParentSheet = !isWeb && modal && isShowingInnerSheet && needsPortalRepropagation();
+  const sheetInsideSheet = React.useContext(SheetInsideSheetContext);
+  const onInnerSheet = React.useCallback(hasChild => {
+    setIsShowingInnerSheet(hasChild);
+  }, []);
+  const stableFrameSize = React.useRef(frameSize);
+  React.useEffect(() => {
+    if (open && frameSize) stableFrameSize.current = frameSize;
+  }, [open, frameSize]);
+  const effectiveFrameSize = open ? frameSize : stableFrameSize.current || frameSize;
+  const positions = React.useMemo(() => snapPoints.map(point => getYPositions(snapPointsMode, point, screenSize, effectiveFrameSize)), [screenSize, effectiveFrameSize, snapPoints, snapPointsMode]);
+  const {
+    keyboardHeight,
+    isKeyboardVisible,
+    dismissKeyboard,
+    pauseKeyboardHandler,
+    flushPendingHide
+  } = useKeyboardControllerSheet({
+    enabled: !isWeb && Boolean(moveOnKeyboardChange)
+  });
+  const [isDragging, setIsDragging_] = React.useState(false);
+  const isDraggingRef = React.useRef(false);
+  const setIsDragging = React.useCallback(val => {
+    isDraggingRef.current = val;
+    pauseKeyboardHandler.current = val;
+    setIsDragging_(val);
+    if (!val) flushPendingHide();
+  }, [pauseKeyboardHandler, flushPendingHide]);
+  const activePositionsRef = React.useRef(positions);
+  const activePositions = React.useMemo(() => {
+    if (isDragging || isDraggingRef.current) return activePositionsRef.current;
+    let result;
+    if (!isKeyboardVisible || keyboardHeight <= 0) result = positions;else {
+      const safeAreaTop = isWeb ? 0 : getSafeAreaTopInset();
+      result = positions.map(p => {
+        if (screenSize && p >= screenSize) return p;
+        return Math.max(safeAreaTop, p - keyboardHeight);
+      });
+    }
+    activePositionsRef.current = result;
+    return result;
+  }, [positions, isKeyboardVisible, keyboardHeight, screenSize, isDragging]);
+  const {
+    useAnimatedNumber,
+    useAnimatedNumberStyle,
+    useAnimatedNumberReaction
+  } = animationDriver;
+  const AnimatedView = animationDriver.View ?? GuiView;
+  useIsomorphicLayoutEffect(() => {
+    if (!(sheetInsideSheet && open)) return;
+    sheetInsideSheet(true);
+    return () => {
+      sheetInsideSheet(false);
+    };
+  }, [sheetInsideSheet, open]);
+  const nextParentContext = React.useMemo(() => ({
+    zIndex
+  }), [zIndex]);
+  const startPosition = useDidFinishSSR() && screenSize ? screenSize : hiddenSize;
+  const animatedNumber = useAnimatedNumber(startPosition);
+  const at = React.useRef(startPosition);
+  const hasntMeasured = at.current === hiddenSize;
+  const [disableAnimation, setDisableAnimation] = useState(hasntMeasured);
+  const skipAdaptAnimation = React.useRef(false);
+  if (controller?.skipNextAnimation) skipAdaptAnimation.current = true;
+  const hasScrollView = React.useRef(false);
+  const opacityFallbackTimer = React.useRef(null);
+  useAnimatedNumberReaction({
+    value: animatedNumber,
+    hostRef: sheetRef
+  }, React.useCallback(value => {
+    at.current = value;
+    scrollBridge.paneY = value;
+    const minY = activePositions[0];
+    const wasAtTop = scrollBridge.isAtTop;
+    const nowAtTop = value <= minY + 5;
+    if (wasAtTop !== nowAtTop) {
+      scrollBridge.isAtTop = nowAtTop;
+      if (nowAtTop) {
+        if (scrollBridge.y > 0) {
+          scrollBridge.forceScrollTo?.(0);
+          scrollBridge.y = 0;
+        }
+        scrollBridge.scrollLockY = void 0;
+        scrollBridge.setScrollEnabled?.(true);
+      } else {
+        scrollBridge.scrollLockY = 0;
+        scrollBridge.setScrollEnabled?.(false);
+      }
+    }
+  }, [animationDriver, activePositions]));
+  function stopSpring() {
+    animatedNumber.stop();
+    if (scrollBridge.onFinishAnimate) {
+      scrollBridge.onFinishAnimate();
+      scrollBridge.onFinishAnimate = void 0;
+    }
+  }
+  const animateTo = useEvent((position2, animationOverride) => {
+    if (frameSize === 0) return;
+    let toValue = isHidden || position2 === -1 ? screenSize : activePositions[position2];
+    if (at.current === toValue) return;
+    at.current = toValue;
+    stopSpring();
+    const isOpenAnimation = position2 !== -1 && !isHidden;
+    if (opacityFallbackTimer.current) {
+      clearTimeout(opacityFallbackTimer.current);
+      opacityFallbackTimer.current = null;
+    }
+    const animationCompleteCallback = () => {
+      if (opacityFallbackTimer.current) {
+        clearTimeout(opacityFallbackTimer.current);
+        opacityFallbackTimer.current = null;
+      }
+      if (!isOpenAnimation && !openRef.current) setOpacity(0);
+      onAnimationComplete?.({
+        open: isOpenAnimation
+      });
+      controller?.onAnimationComplete?.({
+        open: isOpenAnimation
+      });
+    };
+    if (!isOpenAnimation) opacityFallbackTimer.current = setTimeout(() => {
+      opacityFallbackTimer.current = null;
+      if (!openRef.current) setOpacity(0);
+    }, 1e3);
+    if (skipAdaptAnimation.current) {
+      skipAdaptAnimation.current = false;
+      animatedNumber.setValue(toValue, {
+        type: "timing",
+        duration: 0
+      }, animationCompleteCallback);
+      return;
+    }
+    animatedNumber.setValue(toValue, animationOverride || {
+      type: "spring",
+      ...transitionConfig
+    }, animationCompleteCallback);
+  });
+  useIsomorphicLayoutEffect(() => {
+    if (hasntMeasured && screenSize && frameSize) {
+      at.current = screenSize;
+      animatedNumber.setValue(screenSize, {
+        type: "timing",
+        duration: 0
+      }, () => {
+        setTimeout(() => {
+          setDisableAnimation(false);
+        }, 10);
+      });
+      return;
+    }
+    if (disableAnimation) return;
+    if (!frameSize || !screenSize || isHidden || hasntMeasured && !open) return;
+    animateTo(position);
+    if (position === -1) {
+      scrollBridge.scrollLock = false;
+      scrollBridge.scrollStartY = -1;
+    }
+    if (open && position >= 0) {
+      const isTopPosition = position === 0;
+      scrollBridge.isAtTop = isTopPosition;
+      if (isTopPosition) {
+        scrollBridge.scrollLockY = void 0;
+        scrollBridge.setScrollEnabled?.(true);
+      } else {
+        scrollBridge.scrollLockY = 0;
+        scrollBridge.setScrollEnabled?.(false);
+      }
+    }
+  }, [hasntMeasured, disableAnimation, isHidden, frameSize, screenSize, open, position]);
+  const disableDrag = props.disableDrag ?? controller?.disableDrag;
+  useThemeName();
+  const [blockPan, setBlockPan] = React.useState(false);
+  const panResponder = React.useMemo(() => {
+    if (disableDrag) return;
+    if (!frameSize) return;
+    if (isShowingInnerSheet) return;
+    const minY = positions[0];
+    scrollBridge.paneMinY = minY;
+    let startY = at.current;
+    function setPanning(val) {
+      setIsDragging(val);
+      if (!sheetHiddenStyleSheet) {
+        sheetHiddenStyleSheet = document.createElement("style");
+        if (typeof document.head !== "undefined") document.head.appendChild(sheetHiddenStyleSheet);
+      }
+      if (!val) sheetHiddenStyleSheet.innerText = "";else sheetHiddenStyleSheet.innerText = ":root * { user-select: none !important; -webkit-user-select: none !important; }";
+    }
+    const release = ({
+      vy
+    }) => {
+      scrollBridge.setParentDragging(false);
+      if (scrollBridge.scrollLock) return;
+      isExternalDrag = false;
+      previouslyScrolling = false;
+      setPanning(false);
+      const end = at.current + frameSize * vy * .2;
+      let closestPoint = 0;
+      let dist = Number.POSITIVE_INFINITY;
+      for (let i = 0; i < positions.length; i++) {
+        const position2 = positions[i];
+        const curDist = end > position2 ? end - position2 : position2 - end;
+        if (curDist < dist) {
+          dist = curDist;
+          closestPoint = i;
+        }
+      }
+      setPosition(closestPoint);
+      animateTo(closestPoint);
+    };
+    const finish = (_e, state2) => {
+      release({
+        vy: state2.vy,
+        dragAt: state2.dy
+      });
+    };
+    let previouslyScrolling = false;
+    const onMoveShouldSet = (e, {
+      dy
+    }) => {
+      function getShouldSet() {
+        if (e.target === providerProps.handleRef.current) return true;
+        if (scrollBridge.hasScrollableContent === true) {
+          if (scrollBridge.scrollLock) return false;
+          const isScrolled = scrollBridge.y !== 0;
+          const isDraggingUp = dy < 0;
+          const isNearTop = scrollBridge.paneY - 5 <= scrollBridge.paneMinY;
+          if (isScrolled) return false;
+          if (isNearTop) {
+            if (hasScrollView.current && isDraggingUp) return false;
+          }
+        }
+        return Math.abs(dy) > 10;
+      }
+      const granted = getShouldSet();
+      if (granted) scrollBridge.setParentDragging(true);
+      return granted;
+    };
+    const grant = () => {
+      setPanning(true);
+      stopSpring();
+      startY = at.current;
+    };
+    let isExternalDrag = false;
+    scrollBridge.drag = dy => {
+      if (!isExternalDrag) {
+        isExternalDrag = true;
+        grant();
+      }
+      const to = dy + startY;
+      animatedNumber.setValue(resisted(to, minY), {
+        type: "direct"
+      });
+    };
+    scrollBridge.release = release;
+    scrollBridge.snapToPosition = positionIndex => {
+      isExternalDrag = false;
+      setPanning(false);
+      setPosition(positionIndex);
+      animateTo(positionIndex);
+    };
+    return PanResponder.create({
+      onMoveShouldSetPanResponder: onMoveShouldSet,
+      onPanResponderGrant: grant,
+      onPanResponderMove: (_e, {
+        dy
+      }) => {
+        const to = resisted(dy + startY, minY);
+        if (to <= minY) scrollBridge.setParentDragging(false);else scrollBridge.setParentDragging(true);
+        animatedNumber.setValue(to, {
+          type: "direct"
+        });
+      },
+      onPanResponderEnd: finish,
+      onPanResponderTerminate: finish,
+      onPanResponderRelease: finish
+    });
+  }, [disableDrag, isShowingInnerSheet, animateTo, frameSize, positions, setPosition]);
+  React.useEffect(() => {
+    if (isDragging || isHidden || !open || disableAnimation) return;
+    if (!frameSize || !screenSize) return;
+    animateTo(position, {
+      type: "timing",
+      duration: 250
+    });
+  }, [isKeyboardVisible, keyboardHeight]);
+  const wasDragging = React.useRef(false);
+  React.useEffect(() => {
+    if (isDragging) {
+      wasDragging.current = true;
+      return;
+    }
+    if (!wasDragging.current) return;
+    wasDragging.current = false;
+    if (!frameSize || !screenSize || isHidden || !open) return;
+    animateTo(position);
+  }, [isDragging]);
+  React.useEffect(() => {
+    if (!open && isKeyboardVisible) dismissKeyboard();
+  }, [open]);
+  const {
+    panGesture,
+    panGestureRef,
+    gestureHandlerEnabled
+  } = useGestureHandlerPan({
+    positions: activePositions,
+    frameSize,
+    setPosition,
+    animateTo,
+    stopSpring,
+    scrollBridge,
+    setIsDragging,
+    getCurrentPosition: () => at.current,
+    resisted,
+    disableDrag,
+    isShowingInnerSheet,
+    setAnimatedPosition: val => {
+      at.current = val;
+      animatedNumber.setValue(val, {
+        type: "direct"
+      });
+    },
+    pauseKeyboardHandler
+  });
+  const handleAnimationViewLayout = useEvent(e => {
+    if (!open && stableFrameSize.current !== 0) return;
+    const layoutHeight = e.nativeEvent?.layout.height;
+    const next = modal ? Math.min(layoutHeight, Dimensions.get(relativeDimensionTo).height) : layoutHeight;
+    if (!next) return;
+    setFrameSize(next);
+  });
+  const handleMaxContentViewLayout = React.useCallback(e => {
+    const next = Math.min(e.nativeEvent?.layout.height, Dimensions.get(relativeDimensionTo).height);
+    if (!next) return;
+    setMaxContentSize(next);
+  }, []);
+  const animatedStyle = useAnimatedNumberStyle(animatedNumber, React.useCallback(val => {
+    "worklet";
+
+    return {
+      transform: [{
+        translateY: frameSize === 0 ? hiddenSize : val
+      }]
+    };
+  }, [frameSize]));
+  const [opacity, setOpacity] = React.useState(open ? 1 : 0);
+  if (open && opacity === 0) {
+    setOpacity(1);
+    if (opacityFallbackTimer.current) {
+      clearTimeout(opacityFallbackTimer.current);
+      opacityFallbackTimer.current = null;
+    }
+  }
+  const forcedContentHeight = hasFit ? void 0 : snapPointsMode === "percent" ? `${maxSnapPoint}${isWeb ? modal ? "dvh" : "%" : "%"}` : maxSnapPoint;
+  const setHasScrollView = React.useCallback(val => {
+    hasScrollView.current = val;
+  }, []);
+  let contents = /* @__PURE__ */jsx(LayoutMeasurementController, {
+    disable: !open,
+    children: /* @__PURE__ */jsx(ParentSheetContext.Provider, {
+      value: nextParentContext,
+      children: /* @__PURE__ */jsx(SheetProvider, {
+        ...providerProps,
+        setHasScrollView,
+        children: /* @__PURE__ */jsxs(GestureSheetProvider, {
+          isDragging,
+          blockPan,
+          setBlockPan,
+          panGesture,
+          panGestureRef,
+          children: [/* @__PURE__ */jsx(AnimatePresence, {
+            custom: {
+              open
+            },
+            children: shouldHideParentSheet || !open ? null : overlayComponent
+          }), snapPointsMode !== "percent" && /* @__PURE__ */jsx(View, {
+            style: {
+              opacity: 0,
+              position: "absolute",
+              top: 0,
+              left: 0,
+              right: 0,
+              bottom: 0,
+              pointerEvents: "none"
+            },
+            onLayout: handleMaxContentViewLayout
+          }), /* @__PURE__ */jsx(AnimatedView, {
+            ref,
+            onLayout: handleAnimationViewLayout,
+            transition: isDragging || disableAnimation ? null : transition,
+            disableClassName: true,
+            style: [{
+              position: "absolute",
+              zIndex,
+              width: "100%",
+              height: forcedContentHeight,
+              minHeight: forcedContentHeight,
+              opacity: !shouldHideParentSheet ? opacity : 0,
+              ...((shouldHideParentSheet || !open) && {
+                pointerEvents: "none"
+              })
+            }, animatedStyle],
+            children: gestureHandlerEnabled && panGesture ? /* @__PURE__ */jsx(GestureDetectorWrapper, {
+              gesture: panGesture,
+              style: {
+                flex: 1
+              },
+              children: props.children
+            }) : /* @__PURE__ */jsx(View, {
+              ...panResponder?.panHandlers,
+              style: {
+                flex: 1,
+                width: "100%",
+                height: "100%"
+              },
+              children: props.children
+            })
+          })]
+        })
+      })
+    })
+  });
+  const shouldMountChildren = unmountChildrenWhenHidden ? !!opacity : true;
+  if (modal) {
+    const modalContents = /* @__PURE__ */jsx(Portal, {
+      stackZIndex: zIndex,
+      ...portalProps,
+      children: shouldMountChildren && /* @__PURE__ */jsx(ContainerComponent, {
+        children: contents
+      })
+    });
+    if (isWeb) return modalContents;
+    return /* @__PURE__ */jsx(SheetInsideSheetContext.Provider, {
+      value: onInnerSheet,
+      children: modalContents
+    });
+  }
+  return contents;
+});
+function getYPositions(mode, point, screenSize, frameSize) {
+  if (!screenSize || !frameSize) return 0;
+  if (mode === "mixed") {
+    if (typeof point === "number") return screenSize - Math.min(screenSize, Math.max(0, point));
+    if (point === "fit") return screenSize - Math.min(screenSize, frameSize);
+    if (point.endsWith("%")) {
+      const pct2 = Math.min(100, Math.max(0, Number(point.slice(0, -1)))) / 100;
+      if (Number.isNaN(pct2)) {
+        console.warn("Invalid snapPoint percentage string");
+        return 0;
+      }
+      return Math.round(screenSize - pct2 * screenSize);
+    }
+    console.warn("Invalid snapPoint unknown value");
+    return 0;
+  }
+  if (mode === "fit") {
+    if (point === 0) return screenSize;
+    return screenSize - Math.min(screenSize, frameSize);
+  }
+  if (mode === "constant" && typeof point === "number") return screenSize - Math.min(screenSize, Math.max(0, point));
+  const pct = Math.min(100, Math.max(0, Number(point))) / 100;
+  if (Number.isNaN(pct)) {
+    console.warn("Invalid snapPoint percentage");
+    return 0;
+  }
+  return Math.round(screenSize - pct * screenSize);
+}
+export { SheetImplementationCustom };
+//# sourceMappingURL=SheetImplementationCustom.mjs.map