@mustmove/bottom-sheet 1.0.0 → 1.0.2

package/lib/commonjs/hooks/useBottomSheetContentContainerStyle.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBottomSheetContentContainerStyle = useBottomSheetContentContainerStyle;
+var _react = require("react");
+var _reactNative = require("react-native");
+var _reactNativeReanimated = require("react-native-reanimated");
+var _useBottomSheetInternal = require("./useBottomSheetInternal");
+function useBottomSheetContentContainerStyle(enableFooterMarginAdjustment, _style) {
+  const [footerHeight, setFooterHeight] = (0, _react.useState)(0);
+  //#region hooks
+  const {
+    animatedLayoutState
+  } = (0, _useBottomSheetInternal.useBottomSheetInternal)();
+  //#endregion
+
+  //#region styles
+  const flattenStyle = (0, _react.useMemo)(() => {
+    return !_style ? {} : Array.isArray(_style) ?
+    // @ts-ignore
+    _reactNative.StyleSheet.compose(..._style) : _style;
+  }, [_style]);
+  const style = (0, _react.useMemo)(() => {
+    if (!enableFooterMarginAdjustment) {
+      return flattenStyle;
+    }
+    let currentBottomPadding = 0;
+    if (flattenStyle && typeof flattenStyle === 'object') {
+      const {
+        paddingBottom,
+        padding,
+        paddingVertical
+      } = flattenStyle;
+      if (paddingBottom !== undefined && typeof paddingBottom === 'number') {
+        currentBottomPadding = paddingBottom;
+      } else if (paddingVertical !== undefined && typeof paddingVertical === 'number') {
+        currentBottomPadding = paddingVertical;
+      } else if (padding !== undefined && typeof padding === 'number') {
+        currentBottomPadding = padding;
+      }
+    }
+    return [flattenStyle, {
+      paddingBottom: currentBottomPadding + footerHeight,
+      overflow: 'visible'
+    }];
+  }, [footerHeight, enableFooterMarginAdjustment, flattenStyle]);
+  //#endregion
+
+  //#region effects
+  (0, _reactNativeReanimated.useAnimatedReaction)(() => animatedLayoutState.get().footerHeight, (result, previousFooterHeight) => {
+    if (!enableFooterMarginAdjustment) {
+      return;
+    }
+    (0, _reactNativeReanimated.runOnJS)(setFooterHeight)(result);
+    if (_reactNative.Platform.OS === 'web') {
+      /**
+       * a reaction that will append the footer height to the content
+       * height if margin adjustment is true.
+       *
+       * This is needed due to the web layout the footer after the content.
+       */
+      if (result && !previousFooterHeight) {
+        animatedLayoutState.modify(state => {
+          'worklet';
+
+          state.contentHeight = state.contentHeight + result;
+          return state;
+        });
+      }
+    }
+  }, [animatedLayoutState, enableFooterMarginAdjustment]);
+  //#endregion
+  return style;
+}
+//# sourceMappingURL=useBottomSheetContentContainerStyle.js.map

package/lib/commonjs/hooks/useBottomSheetContentContainerStyle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_reactNative","_reactNativeReanimated","_useBottomSheetInternal","useBottomSheetContentContainerStyle","enableFooterMarginAdjustment","_style","footerHeight","setFooterHeight","useState","animatedLayoutState","useBottomSheetInternal","flattenStyle","useMemo","Array","isArray","StyleSheet","compose","style","currentBottomPadding","paddingBottom","padding","paddingVertical","undefined","overflow","useAnimatedReaction","get","result","previousFooterHeight","runOnJS","Platform","OS","modify","state","contentHeight"],"sourceRoot":"../../../src","sources":["hooks/useBottomSheetContentContainerStyle.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAMA,IAAAE,sBAAA,GAAAF,OAAA;AACA,IAAAG,uBAAA,GAAAH,OAAA;AAEO,SAASI,mCAAmCA,CACjDC,4BAAqC,EACrCC,MAA2B,EAC3B;EACA,MAAM,CAACC,YAAY,EAAEC,eAAe,CAAC,GAAG,IAAAC,eAAQ,EAAC,CAAC,CAAC;EACnD;EACA,MAAM;IAAEC;EAAoB,CAAC,GAAG,IAAAC,8CAAsB,EAAC,CAAC;EACxD;;EAEA;EACA,MAAMC,YAAY,GAAG,IAAAC,cAAO,EAAY,MAAM;IAC5C,OAAO,CAACP,MAAM,GACV,CAAC,CAAC,GACFQ,KAAK,CAACC,OAAO,CAACT,MAAM,CAAC;IACnB;IACCU,uBAAU,CAACC,OAAO,CAAC,GAAGX,MAAM,CAAC,GAC7BA,MAAoB;EAC7B,CAAC,EAAE,CAACA,MAAM,CAAC,CAAC;EACZ,MAAMY,KAAK,GAAG,IAAAL,cAAO,EAAqB,MAAM;IAC9C,IAAI,CAACR,4BAA4B,EAAE;MACjC,OAAOO,YAAY;IACrB;IAEA,IAAIO,oBAAoB,GAAG,CAAC;IAC5B,IAAIP,YAAY,IAAI,OAAOA,YAAY,KAAK,QAAQ,EAAE;MACpD,MAAM;QAAEQ,aAAa;QAAEC,OAAO;QAAEC;MAAgB,CAAC,GAAGV,YAAY;MAChE,IAAIQ,aAAa,KAAKG,SAAS,IAAI,OAAOH,aAAa,KAAK,QAAQ,EAAE;QACpED,oBAAoB,GAAGC,aAAa;MACtC,CAAC,MAAM,IACLE,eAAe,KAAKC,SAAS,IAC7B,OAAOD,eAAe,KAAK,QAAQ,EACnC;QACAH,oBAAoB,GAAGG,eAAe;MACxC,CAAC,MAAM,IAAID,OAAO,KAAKE,SAAS,IAAI,OAAOF,OAAO,KAAK,QAAQ,EAAE;QAC/DF,oBAAoB,GAAGE,OAAO;MAChC;IACF;IAEA,OAAO,CACLT,YAAY,EACZ;MACEQ,aAAa,EAAED,oBAAoB,GAAGZ,YAAY;MAClDiB,QAAQ,EAAE;IACZ,CAAC,CACF;EACH,CAAC,EAAE,CAACjB,YAAY,EAAEF,4BAA4B,EAAEO,YAAY,CAAC,CAAC;EAC9D;;EAEA;EACA,IAAAa,0CAAmB,EACjB,MAAMf,mBAAmB,CAACgB,GAAG,CAAC,CAAC,CAACnB,YAAY,EAC5C,CAACoB,MAAM,EAAEC,oBAAoB,KAAK;IAChC,IAAI,CAACvB,4BAA4B,EAAE;MACjC;IACF;IACA,IAAAwB,8BAAO,EAACrB,eAAe,CAAC,CAACmB,MAAM,CAAC;IAEhC,IAAIG,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MACzB;AACR;AACA;AACA;AACA;AACA;MACQ,IAAIJ,MAAM,IAAI,CAACC,oBAAoB,EAAE;QACnClB,mBAAmB,CAACsB,MAAM,CAACC,KAAK,IAAI;UAClC,SAAS;;UACTA,KAAK,CAACC,aAAa,GAAGD,KAAK,CAACC,aAAa,GAAGP,MAAM;UAClD,OAAOM,KAAK;QACd,CAAC,CAAC;MACJ;IACF;EACF,CAAC,EACD,CAACvB,mBAAmB,EAAEL,4BAA4B,CACpD,CAAC;EACD;EACA,OAAOa,KAAK;AACd","ignoreList":[]}

package/lib/commonjs/hooks/useBottomSheetGestureHandlers.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBottomSheetGestureHandlers = void 0;
+var _react = require("react");
+var _gesture = require("../contexts/gesture");
+const useBottomSheetGestureHandlers = () => {
+  const context = (0, _react.useContext)(_gesture.BottomSheetGestureHandlersContext);
+  if (context === null) {
+    throw "'useBottomSheetGestureHandlers' cannot be used out of the BottomSheet!";
+  }
+  return context;
+};
+exports.useBottomSheetGestureHandlers = useBottomSheetGestureHandlers;
+//# sourceMappingURL=useBottomSheetGestureHandlers.js.map

package/lib/commonjs/hooks/useBottomSheetGestureHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_gesture","useBottomSheetGestureHandlers","context","useContext","BottomSheetGestureHandlersContext","exports"],"sourceRoot":"../../../src","sources":["hooks/useBottomSheetGestureHandlers.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AAEO,MAAME,6BAA6B,GAAGA,CAAA,KAAM;EACjD,MAAMC,OAAO,GAAG,IAAAC,iBAAU,EAACC,0CAAiC,CAAC;EAE7D,IAAIF,OAAO,KAAK,IAAI,EAAE;IACpB,MAAM,wEAAwE;EAChF;EAEA,OAAOA,OAAO;AAChB,CAAC;AAACG,OAAA,CAAAJ,6BAAA,GAAAA,6BAAA","ignoreList":[]}

package/lib/commonjs/hooks/useBottomSheetInternal.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBottomSheetInternal = useBottomSheetInternal;
+var _react = require("react");
+var _internal = require("../contexts/internal");
+function useBottomSheetInternal(unsafe) {
+  const context = (0, _react.useContext)(_internal.BottomSheetInternalContext);
+  if (unsafe !== true && context === null) {
+    throw "'useBottomSheetInternal' cannot be used out of the BottomSheet!";
+  }
+  return context;
+}
+//# sourceMappingURL=useBottomSheetInternal.js.map

package/lib/commonjs/hooks/useBottomSheetInternal.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_internal","useBottomSheetInternal","unsafe","context","useContext","BottomSheetInternalContext"],"sourceRoot":"../../../src","sources":["hooks/useBottomSheetInternal.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AAaO,SAASE,sBAAsBA,CACpCC,MAAgB,EACuB;EACvC,MAAMC,OAAO,GAAG,IAAAC,iBAAU,EAACC,oCAA0B,CAAC;EAEtD,IAAIH,MAAM,KAAK,IAAI,IAAIC,OAAO,KAAK,IAAI,EAAE;IACvC,MAAM,iEAAiE;EACzE;EAEA,OAAOA,OAAO;AAChB","ignoreList":[]}

package/lib/commonjs/hooks/useBottomSheetModal.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBottomSheetModal = void 0;
+var _react = require("react");
+var _contexts = require("../contexts");
+const useBottomSheetModal = () => {
+  const context = (0, _react.useContext)(_contexts.BottomSheetModalContext);
+  if (context === null) {
+    throw "'BottomSheetModalContext' cannot be null!";
+  }
+  return context;
+};
+exports.useBottomSheetModal = useBottomSheetModal;
+//# sourceMappingURL=useBottomSheetModal.js.map

package/lib/commonjs/hooks/useBottomSheetModal.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_contexts","useBottomSheetModal","context","useContext","BottomSheetModalContext","exports"],"sourceRoot":"../../../src","sources":["hooks/useBottomSheetModal.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AAEO,MAAME,mBAAmB,GAAGA,CAAA,KAAM;EACvC,MAAMC,OAAO,GAAG,IAAAC,iBAAU,EAACC,iCAAuB,CAAC;EAEnD,IAAIF,OAAO,KAAK,IAAI,EAAE;IACpB,MAAM,2CAA2C;EACnD;EAEA,OAAOA,OAAO;AAChB,CAAC;AAACG,OAAA,CAAAJ,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/lib/commonjs/hooks/useBottomSheetModalInternal.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBottomSheetModalInternal = useBottomSheetModalInternal;
+var _react = require("react");
+var _contexts = require("../contexts");
+function useBottomSheetModalInternal(unsafe) {
+  const context = (0, _react.useContext)(_contexts.BottomSheetModalInternalContext);
+  if (unsafe !== true && context === null) {
+    throw "'BottomSheetModalInternalContext' cannot be null!";
+  }
+  return context;
+}
+//# sourceMappingURL=useBottomSheetModalInternal.js.map

package/lib/commonjs/hooks/useBottomSheetModalInternal.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_contexts","useBottomSheetModalInternal","unsafe","context","useContext","BottomSheetModalInternalContext"],"sourceRoot":"../../../src","sources":["hooks/useBottomSheetModalInternal.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AAaO,SAASE,2BAA2BA,CACzCC,MAAgB,EAC4B;EAC5C,MAAMC,OAAO,GAAG,IAAAC,iBAAU,EAACC,yCAA+B,CAAC;EAE3D,IAAIH,MAAM,KAAK,IAAI,IAAIC,OAAO,KAAK,IAAI,EAAE;IACvC,MAAM,mDAAmD;EAC3D;EAEA,OAAOA,OAAO;AAChB","ignoreList":[]}

package/lib/commonjs/hooks/useBottomSheetScrollableCreator.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBottomSheetScrollableCreator = useBottomSheetScrollableCreator;
+var _react = require("react");
+var _bottomSheetScrollable = require("../components/bottomSheetScrollable");
+var _jsxRuntime = require("react/jsx-runtime");
+/**
+ * A custom hook that creates a scrollable component for third-party libraries
+ * like `LegendList` or `FlashList` to integrate the interaction and scrolling
+ * behaviors with th BottomSheet component.
+ *
+ * @param configs - Configuration options for the scrollable creator.
+ * @param configs.focusHook - This needed when bottom sheet used with multiple scrollables to allow bottom sheet
+ * detect the current scrollable ref, especially when used with `React Navigation`.
+ * You will need to provide `useFocusEffect` from `@react-navigation/native`.
+ * @param configs.scrollEventsHandlersHook - Custom hook to provide scroll events handler, which will allow advance and
+ * customize handling for scrollables.
+ * @param configs.enableFooterMarginAdjustment - Adjust the scrollable bottom margin to avoid the animated footer.
+ *
+ * @example
+ * ```tsx
+ * const BottomSheetLegendListScrollable = useBottomSheetScrollableCreator();
+ *
+ * // Usage in JSX
+ * <LegendList
+ *  renderScrollComponent={BottomSheetLegendListScrollable}
+ * />
+ * ```
+ */
+// biome-ignore lint/suspicious/noExplicitAny: out of my control
+function useBottomSheetScrollableCreator({
+  focusHook,
+  scrollEventsHandlersHook,
+  enableFooterMarginAdjustment
+} = {}) {
+  return (0, _react.useCallback)(function useBottomSheetScrollableCreator(
+  // @ts-expect-error
+  {
+    data: _,
+    ...props
+  }, ref) {
+    return (
+      /*#__PURE__*/
+      // @ts-expect-error
+      (0, _jsxRuntime.jsx)(_bottomSheetScrollable.BottomSheetScrollView, {
+        ref: ref,
+        ...props,
+        focusHook: focusHook,
+        scrollEventsHandlersHook: scrollEventsHandlersHook,
+        enableFooterMarginAdjustment: enableFooterMarginAdjustment
+      })
+    );
+  }, [focusHook, scrollEventsHandlersHook, enableFooterMarginAdjustment]);
+}
+//# sourceMappingURL=useBottomSheetScrollableCreator.js.map

package/lib/commonjs/hooks/useBottomSheetScrollableCreator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_bottomSheetScrollable","_jsxRuntime","useBottomSheetScrollableCreator","focusHook","scrollEventsHandlersHook","enableFooterMarginAdjustment","useCallback","data","_","props","ref","jsx","BottomSheetScrollView"],"sourceRoot":"../../../src","sources":["hooks/useBottomSheetScrollableCreator.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAD,OAAA;AAG6C,IAAAE,WAAA,GAAAF,OAAA;AAI7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,+BAA+BA,CAAU;EACvDC,SAAS;EACTC,wBAAwB;EACxBC;AACmC,CAAC,GAAG,CAAC,CAAC,EAGtB;EACnB,OAAO,IAAAC,kBAAW,EAChB,SAASJ,+BAA+BA;EACtC;EACA;IAAEK,IAAI,EAAEC,CAAC;IAAE,GAAGC;EAAS,CAAC,EACxBC,GAAW,EACM;IACjB;MAAA;MACE;MACA,IAAAT,WAAA,CAAAU,GAAA,EAACX,sBAAA,CAAAY,qBAAqB;QACpBF,GAAG,EAAEA,GAAI;QAAA,GACLD,KAAK;QACTN,SAAS,EAAEA,SAAU;QACrBC,wBAAwB,EAAEA,wBAAyB;QACnDC,4BAA4B,EAAEA;MAA6B,CAC5D;IAAC;EAEN,CAAC,EACD,CAACF,SAAS,EAAEC,wBAAwB,EAAEC,4BAA4B,CACpE,CAAC;AACH","ignoreList":[]}

package/lib/commonjs/hooks/useBottomSheetSpringConfigs.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBottomSheetSpringConfigs = void 0;
+/**
+ * Generate spring animation configs.
+ * @param configs overridable configs.
+ */
+const useBottomSheetSpringConfigs = configs => {
+  return configs;
+};
+exports.useBottomSheetSpringConfigs = useBottomSheetSpringConfigs;
+//# sourceMappingURL=useBottomSheetSpringConfigs.js.map

package/lib/commonjs/hooks/useBottomSheetSpringConfigs.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useBottomSheetSpringConfigs","configs","exports"],"sourceRoot":"../../../src","sources":["hooks/useBottomSheetSpringConfigs.ts"],"mappings":";;;;;;AAEA;AACA;AACA;AACA;AACO,MAAMA,2BAA2B,GACtCC,OAA2C,IACxC;EACH,OAAOA,OAAO;AAChB,CAAC;AAACC,OAAA,CAAAF,2BAAA,GAAAA,2BAAA","ignoreList":[]}

package/lib/commonjs/hooks/useBottomSheetTimingConfigs.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBottomSheetTimingConfigs = void 0;
+var _react = require("react");
+var _constants = require("../constants");
+/**
+ * this is needed to avoid TS4023
+ * https://github.com/microsoft/TypeScript/issues/5711
+ */
+
+/**
+ * Generate timing animation configs.
+ * @default
+ * - easing: Easing.out(Easing.exp)
+ * - duration: 250
+ * @param configs overridable configs.
+ */
+const useBottomSheetTimingConfigs = configs => {
+  return (0, _react.useMemo)(() => {
+    const _configs = {
+      easing: configs.easing || _constants.ANIMATION_EASING,
+      duration: configs.duration || _constants.ANIMATION_DURATION,
+      reduceMotion: configs.reduceMotion
+    };
+    return _configs;
+  }, [configs.duration, configs.easing, configs.reduceMotion]);
+};
+exports.useBottomSheetTimingConfigs = useBottomSheetTimingConfigs;
+//# sourceMappingURL=useBottomSheetTimingConfigs.js.map

package/lib/commonjs/hooks/useBottomSheetTimingConfigs.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_constants","useBottomSheetTimingConfigs","configs","useMemo","_configs","easing","ANIMATION_EASING","duration","ANIMATION_DURATION","reduceMotion","exports"],"sourceRoot":"../../../src","sources":["hooks/useBottomSheetTimingConfigs.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMA,IAAAC,UAAA,GAAAD,OAAA;AAEA;AACA;AACA;AACA;;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAME,2BAA2B,GAAIC,OAAqB,IAAK;EACpE,OAAO,IAAAC,cAAO,EAAC,MAAM;IACnB,MAAMC,QAAsB,GAAG;MAC7BC,MAAM,EAAEH,OAAO,CAACG,MAAM,IAAIC,2BAAgB;MAC1CC,QAAQ,EAAEL,OAAO,CAACK,QAAQ,IAAIC,6BAAkB;MAChDC,YAAY,EAAEP,OAAO,CAACO;IACxB,CAAC;IAED,OAAOL,QAAQ;EACjB,CAAC,EAAE,CAACF,OAAO,CAACK,QAAQ,EAAEL,OAAO,CAACG,MAAM,EAAEH,OAAO,CAACO,YAAY,CAAC,CAAC;AAC9D,CAAC;AAACC,OAAA,CAAAT,2BAAA,GAAAA,2BAAA","ignoreList":[]}

package/lib/commonjs/hooks/useBoundingClientRect.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useBoundingClientRect = useBoundingClientRect;
+var _react = require("react");
+var _isFabricInstalled = require("../utilities/isFabricInstalled");
+/**
+ * A custom hook that retrieves the bounding client rectangle of a given `ref` element
+ * and invokes a handler function with the layout information.
+ *
+ * This hook is designed to work with React Native's Fabric architecture and provides
+ * support for both `unstable_getBoundingClientRect` and `getBoundingClientRect` methods.
+ *
+ * @param ref - A `RefObject` pointing to a `View` or `null`. The bounding client rectangle
+ *              will be retrieved from this reference.
+ * @param handler - A callback function that will be invoked with the layout information
+ *                  of the referenced element.
+ *
+ * @remarks
+ * - The hook uses `useLayoutEffect` to ensure the layout information is retrieved
+ *   after the DOM updates.
+ * - The `isFabricInstalled` function is used to determine if the Fabric architecture
+ *   is available.
+ * - The `unstable_getBoundingClientRect` method is used if available, falling back
+ *   to `getBoundingClientRect` otherwise.
+ *
+ * @example
+ * ```tsx
+ * const ref = useRef<View | null>(null);
+ * useBoundingClientRect(ref, (layout) => {
+ *   console.log('Bounding client rect:', layout);
+ * });
+ * ```
+ */
+function useBoundingClientRect(ref, handler) {
+  if (!(0, _isFabricInstalled.isFabricInstalled)()) {
+    return;
+  }
+
+  // biome-ignore lint/correctness/useHookAtTopLevel: `isFabricInstalled` is a constant that will not change during the runtime
+  (0, _react.useLayoutEffect)(() => {
+    if (!ref || !ref.current) {
+      return;
+    }
+    if (
+    // @ts-expect-error 👉 https://github.com/facebook/react/commit/53b1f69ba
+    ref.current.unstable_getBoundingClientRect !== null &&
+    // @ts-expect-error 👉 https://github.com/facebook/react/commit/53b1f69ba
+    typeof ref.current.unstable_getBoundingClientRect === 'function') {
+      // @ts-expect-error https://github.com/facebook/react/commit/53b1f69ba
+      const layout = ref.current.unstable_getBoundingClientRect();
+      handler(layout);
+      return;
+    }
+
+    // @ts-expect-error once it `unstable_getBoundingClientRect` gets stable 🤞.
+    if (ref.current.getBoundingClientRect !== null) {
+      // @ts-expect-error once it `unstable_getBoundingClientRect` gets stable.
+      const layout = ref.current.getBoundingClientRect();
+      handler(layout);
+    }
+  });
+}
+//# sourceMappingURL=useBoundingClientRect.js.map

package/lib/commonjs/hooks/useBoundingClientRect.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_isFabricInstalled","useBoundingClientRect","ref","handler","isFabricInstalled","useLayoutEffect","current","unstable_getBoundingClientRect","layout","getBoundingClientRect"],"sourceRoot":"../../../src","sources":["hooks/useBoundingClientRect.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,kBAAA,GAAAD,OAAA;AAaA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,qBAAqBA,CACnCC,GAA2B,EAC3BC,OAA6C,EAC7C;EACA,IAAI,CAAC,IAAAC,oCAAiB,EAAC,CAAC,EAAE;IACxB;EACF;;EAEA;EACA,IAAAC,sBAAe,EAAC,MAAM;IACpB,IAAI,CAACH,GAAG,IAAI,CAACA,GAAG,CAACI,OAAO,EAAE;MACxB;IACF;IAEA;IACE;IACAJ,GAAG,CAACI,OAAO,CAACC,8BAA8B,KAAK,IAAI;IACnD;IACA,OAAOL,GAAG,CAACI,OAAO,CAACC,8BAA8B,KAAK,UAAU,EAChE;MACA;MACA,MAAMC,MAAM,GAAGN,GAAG,CAACI,OAAO,CAACC,8BAA8B,CAAC,CAAC;MAC3DJ,OAAO,CAACK,MAAM,CAAC;MACf;IACF;;IAEA;IACA,IAAIN,GAAG,CAACI,OAAO,CAACG,qBAAqB,KAAK,IAAI,EAAE;MAC9C;MACA,MAAMD,MAAM,GAAGN,GAAG,CAACI,OAAO,CAACG,qBAAqB,CAAC,CAAC;MAClDN,OAAO,CAACK,MAAM,CAAC;IACjB;EACF,CAAC,CAAC;AACJ","ignoreList":[]}

package/lib/commonjs/hooks/useGestureEventsHandlersDefault.js

@@ -0,0 +1,299 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGestureEventsHandlersDefault = void 0;
+var _react = require("react");
+var _reactNative = require("react-native");
+var _reactNativeReanimated = require("react-native-reanimated");
+var _constants = require("../constants");
+var _clamp = require("../utilities/clamp");
+var _snapPoint = require("../utilities/snapPoint");
+var _useBottomSheetInternal = require("./useBottomSheetInternal");
+const INITIAL_CONTEXT = {
+  initialPosition: 0,
+  initialKeyboardStatus: _constants.KEYBOARD_STATUS.UNDETERMINED,
+  isScrollablePositionLocked: false
+};
+const dismissKeyboard = _reactNative.Keyboard.dismiss;
+
+// biome-ignore lint: to be addressed!
+const resetContext = context => {
+  'worklet';
+
+  Object.keys(context).map(key => {
+    context[key] = undefined;
+  });
+};
+const useGestureEventsHandlersDefault = () => {
+  //#region variables
+  const {
+    animatedPosition,
+    animatedDetentsState,
+    animatedKeyboardState,
+    animatedScrollableState,
+    animatedLayoutState,
+    enableOverDrag,
+    enablePanDownToClose,
+    overDragResistanceFactor,
+    isInTemporaryPosition,
+    enableBlurKeyboardOnGesture,
+    animateToPosition,
+    stopAnimation
+  } = (0, _useBottomSheetInternal.useBottomSheetInternal)();
+  const context = (0, _reactNativeReanimated.useSharedValue)({
+    ...INITIAL_CONTEXT
+  });
+  //#endregion
+
+  //#region gesture methods
+  const handleOnStart = (0, _react.useCallback)(function handleOnStart(__, _) {
+    'worklet';
+
+    // cancel current animation
+    stopAnimation();
+    let initialKeyboardStatus = animatedKeyboardState.get().status;
+    // blur the keyboard when user start dragging the bottom sheet
+    if (enableBlurKeyboardOnGesture && initialKeyboardStatus === _constants.KEYBOARD_STATUS.SHOWN) {
+      initialKeyboardStatus = _constants.KEYBOARD_STATUS.HIDDEN;
+      (0, _reactNativeReanimated.runOnJS)(dismissKeyboard)();
+    }
+
+    // store current animated position
+    context.value = {
+      ...context.value,
+      initialPosition: animatedPosition.value,
+      initialKeyboardStatus
+    };
+
+    /**
+     * if the scrollable content is scrolled, then
+     * we lock the position.
+     */
+    if (animatedScrollableState.get().contentOffsetY > 0) {
+      context.value = {
+        ...context.value,
+        isScrollablePositionLocked: true
+      };
+    }
+  }, [stopAnimation, context, enableBlurKeyboardOnGesture, animatedPosition, animatedKeyboardState, animatedScrollableState]);
+  const handleOnChange = (0, _react.useCallback)(function handleOnChange(source, {
+    translationY
+  }) {
+    'worklet';
+
+    const {
+      highestDetentPosition,
+      detents
+    } = animatedDetentsState.get();
+    if (highestDetentPosition === undefined || detents === undefined || detents.length === 0) {
+      return;
+    }
+    let highestSnapPoint = highestDetentPosition;
+
+    /**
+     * if keyboard is shown, then we set the highest point to the current
+     * position which includes the keyboard height.
+     */
+    if (isInTemporaryPosition.value && context.value.initialKeyboardStatus === _constants.KEYBOARD_STATUS.SHOWN) {
+      highestSnapPoint = context.value.initialPosition;
+    }
+
+    /**
+     * if current position is out of provided `snapPoints` and smaller then
+     * highest snap pont, then we set the highest point to the current position.
+     */
+    if (isInTemporaryPosition.value && context.value.initialPosition < highestSnapPoint) {
+      highestSnapPoint = context.value.initialPosition;
+    }
+    const {
+      containerHeight
+    } = animatedLayoutState.get();
+    const lowestSnapPoint = enablePanDownToClose ? containerHeight : detents[0];
+
+    /**
+     * if scrollable is refreshable and sheet position at the highest
+     * point, then do not interact with current gesture.
+     */
+    if (source === _constants.GESTURE_SOURCE.CONTENT && animatedScrollableState.get().refreshable && animatedPosition.value === highestSnapPoint) {
+      return;
+    }
+
+    /**
+     * a negative scrollable content offset to be subtracted from accumulated
+     * current position and gesture translation Y to allow user to drag the sheet,
+     * when scrollable position at the top.
+     * a negative scrollable content offset when the scrollable is not locked.
+     */
+    const negativeScrollableContentOffset = context.value.initialPosition === highestSnapPoint && source === _constants.GESTURE_SOURCE.CONTENT || !context.value.isScrollablePositionLocked ? animatedScrollableState.get().contentOffsetY * -1 : 0;
+
+    /**
+     * an accumulated value of starting position with gesture translation y.
+     */
+    const draggedPosition = context.value.initialPosition + translationY;
+
+    /**
+     * an accumulated value of dragged position and negative scrollable content offset,
+     * this will insure locking sheet position when user is scrolling the scrollable until,
+     * they reach to the top of the scrollable.
+     */
+    const accumulatedDraggedPosition = draggedPosition + negativeScrollableContentOffset;
+
+    /**
+     * a clamped value of the accumulated dragged position, to insure keeping the dragged
+     * position between the highest and lowest snap points.
+     */
+    const clampedPosition = (0, _clamp.clamp)(accumulatedDraggedPosition, highestSnapPoint, lowestSnapPoint);
+
+    /**
+     * if scrollable position is locked and the animated position
+     * reaches the highest point, then we unlock the scrollable position.
+     */
+    if (context.value.isScrollablePositionLocked && source === _constants.GESTURE_SOURCE.CONTENT && animatedPosition.value === highestSnapPoint) {
+      context.value = {
+        ...context.value,
+        isScrollablePositionLocked: false
+      };
+    }
+
+    /**
+     * over-drag implementation.
+     */
+    if (enableOverDrag) {
+      if ((source === _constants.GESTURE_SOURCE.HANDLE || animatedScrollableState.get().type === _constants.SCROLLABLE_TYPE.VIEW) && draggedPosition < highestSnapPoint) {
+        const resistedPosition = highestSnapPoint - Math.sqrt(1 + (highestSnapPoint - draggedPosition)) * overDragResistanceFactor;
+        animatedPosition.value = resistedPosition;
+        return;
+      }
+      if (source === _constants.GESTURE_SOURCE.HANDLE && draggedPosition > lowestSnapPoint) {
+        const resistedPosition = lowestSnapPoint + Math.sqrt(1 + (draggedPosition - lowestSnapPoint)) * overDragResistanceFactor;
+        animatedPosition.value = resistedPosition;
+        return;
+      }
+      if (source === _constants.GESTURE_SOURCE.CONTENT && draggedPosition + negativeScrollableContentOffset > lowestSnapPoint) {
+        const resistedPosition = lowestSnapPoint + Math.sqrt(1 + (draggedPosition + negativeScrollableContentOffset - lowestSnapPoint)) * overDragResistanceFactor;
+        animatedPosition.value = resistedPosition;
+        return;
+      }
+    }
+    animatedPosition.value = clampedPosition;
+  }, [enableOverDrag, enablePanDownToClose, overDragResistanceFactor, isInTemporaryPosition, animatedScrollableState, animatedDetentsState, animatedLayoutState, animatedPosition, context]);
+  const handleOnEnd = (0, _react.useCallback)(function handleOnEnd(source, {
+    translationY,
+    absoluteY,
+    velocityY
+  }) {
+    'worklet';
+
+    const {
+      highestDetentPosition,
+      detents,
+      closedDetentPosition
+    } = animatedDetentsState.get();
+    if (highestDetentPosition === undefined || detents === undefined || detents.length === 0 || closedDetentPosition === undefined) {
+      return;
+    }
+    const highestSnapPoint = highestDetentPosition;
+    const isSheetAtHighestSnapPoint = animatedPosition.value === highestSnapPoint;
+    const {
+      refreshable: scrollableIsRefreshable,
+      contentOffsetY: scrollableContentOffsetY,
+      type: scrollableType
+    } = animatedScrollableState.get();
+
+    /**
+     * if scrollable is refreshable and sheet position at the highest
+     * point, then do not interact with current gesture.
+     */
+    if (source === _constants.GESTURE_SOURCE.CONTENT && scrollableIsRefreshable && isSheetAtHighestSnapPoint) {
+      return;
+    }
+
+    /**
+     * if the sheet is in a temporary position and the gesture ended above
+     * the current position, then we snap back to the temporary position.
+     */
+    if (isInTemporaryPosition.value && context.value.initialPosition >= animatedPosition.value) {
+      if (context.value.initialPosition > animatedPosition.value) {
+        animateToPosition(context.value.initialPosition, _constants.ANIMATION_SOURCE.GESTURE, velocityY / 2);
+      }
+      return;
+    }
+
+    /**
+     * close keyboard if current position is below the recorded
+     * start position and keyboard still shown.
+     */
+    const isScrollable = scrollableType !== _constants.SCROLLABLE_TYPE.UNDETERMINED && scrollableType !== _constants.SCROLLABLE_TYPE.VIEW;
+
+    /**
+     * if keyboard is shown and the sheet is dragged down,
+     * then we dismiss the keyboard.
+     */
+    if (context.value.initialKeyboardStatus === _constants.KEYBOARD_STATUS.SHOWN && animatedPosition.value > context.value.initialPosition) {
+      /**
+       * if the platform is ios, current content is scrollable and
+       * the end touch point is below the keyboard position then
+       * we exit the method.
+       *
+       * because the the keyboard dismiss is interactive in iOS.
+       */
+      if (!(_reactNative.Platform.OS === 'ios' && isScrollable && absoluteY > _constants.WINDOW_HEIGHT - animatedKeyboardState.get().heightWithinContainer)) {
+        (0, _reactNativeReanimated.runOnJS)(dismissKeyboard)();
+      }
+    }
+
+    /**
+     * reset isInTemporaryPosition value
+     */
+    if (isInTemporaryPosition.value) {
+      isInTemporaryPosition.value = false;
+    }
+
+    /**
+     * clone snap points array, and insert the container height
+     * if pan down to close is enabled.
+     */
+    const snapPoints = detents.slice();
+    if (enablePanDownToClose) {
+      snapPoints.unshift(closedDetentPosition);
+    }
+
+    /**
+     * calculate the destination point, using redash.
+     */
+    const destinationPoint = (0, _snapPoint.snapPoint)(translationY + context.value.initialPosition, velocityY, snapPoints);
+
+    /**
+     * if destination point is the same as the current position,
+     * then no need to perform animation.
+     */
+    if (destinationPoint === animatedPosition.value) {
+      return;
+    }
+    const wasGestureHandledByScrollView = source === _constants.GESTURE_SOURCE.CONTENT && scrollableContentOffsetY > 0;
+    /**
+     * prevents snapping from top to middle / bottom with repeated interrupted scrolls
+     */
+    if (wasGestureHandledByScrollView && isSheetAtHighestSnapPoint) {
+      return;
+    }
+    animateToPosition(destinationPoint, _constants.ANIMATION_SOURCE.GESTURE, velocityY / 2);
+  }, [enablePanDownToClose, isInTemporaryPosition, animatedScrollableState, animatedDetentsState, animatedKeyboardState, animatedPosition, animateToPosition, context]);
+  const handleOnFinalize = (0, _react.useCallback)(function handleOnFinalize() {
+    'worklet';
+
+    resetContext(context);
+  }, [context]);
+  //#endregion
+
+  return {
+    handleOnStart,
+    handleOnChange,
+    handleOnEnd,
+    handleOnFinalize
+  };
+};
+exports.useGestureEventsHandlersDefault = useGestureEventsHandlersDefault;
+//# sourceMappingURL=useGestureEventsHandlersDefault.js.map