@tamagui/react-native-web-lite 1.125.5 → 1.125.7

package/dist/esm/ScrollView/index.native.js

@@ -1,19 +1,17 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from "react";
 import { StyleSheet, TextInputState, dismissKeyboard, invariant, mergeRefs, warning } from "@tamagui/react-native-web-internals";
-import View from "../View/index";
-import ScrollViewBase from "./ScrollViewBase";
+import View from "../View/index.native.js";
+import ScrollViewBase from "./ScrollViewBase.native.js";
 function _assert_this_initialized(self) {
-  if (self === void 0)
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
   return self;
 }
 function _call_super(_this, derived, args) {
   return derived = _get_prototype_of(derived), _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
 }
 function _class_call_check(instance, Constructor) {
-  if (!(instance instanceof Constructor))
-    throw new TypeError("Cannot call a class as a function");
+  if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
 function _defineProperties(target, props) {
   for (var i = 0; i < props.length; i++) {
@@ -33,13 +31,12 @@ function _define_property(obj, key, value) {
   }) : obj[key] = value, obj;
 }
 function _get_prototype_of(o) {
-  return _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function(o2) {
+  return _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function (o2) {
     return o2.__proto__ || Object.getPrototypeOf(o2);
   }, _get_prototype_of(o);
 }
 function _inherits(subClass, superClass) {
-  if (typeof superClass != "function" && superClass !== null)
-    throw new TypeError("Super expression must either be null or a function");
+  if (typeof superClass != "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function");
   subClass.prototype = Object.create(superClass && superClass.prototype, {
     constructor: {
       value: subClass,
@@ -52,39 +49,40 @@ function _possible_constructor_return(self, call) {
   return call && (_type_of(call) === "object" || typeof call == "function") ? call : _assert_this_initialized(self);
 }
 function _set_prototype_of(o, p) {
-  return _set_prototype_of = Object.setPrototypeOf || function(o2, p2) {
+  return _set_prototype_of = Object.setPrototypeOf || function (o2, p2) {
     return o2.__proto__ = p2, o2;
   }, _set_prototype_of(o, p);
 }
 function _type_of(obj) {
   "@swc/helpers - typeof";
+
   return obj && typeof Symbol < "u" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 function _is_native_reflect_construct() {
   try {
-    var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
-    }));
-  } catch {
-  }
-  return (_is_native_reflect_construct = function() {
+    var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch {}
+  return (_is_native_reflect_construct = function () {
     return !!result;
   })();
 }
-var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16, ScrollView = /* @__PURE__ */ function(_React_Component) {
-  "use strict";
-  _inherits(ScrollView2, _React_Component);
-  function ScrollView2() {
-    _class_call_check(this, ScrollView2);
-    var _this;
-    return _this = _call_super(this, ScrollView2, arguments), _define_property(_this, "_scrollNodeRef", void 0), _define_property(_this, "_innerViewRef", void 0), _define_property(_this, "keyboardWillOpenTo", null), _define_property(_this, "additionalScrollOffset", 0), _define_property(_this, "isTouching", !1), _define_property(_this, "lastMomentumScrollBeginTime", 0), _define_property(_this, "lastMomentumScrollEndTime", 0), // Reset to false every time becomes responder. This is used to:
-    // - Determine if the scroll view has been scrolled and therefore should
-    // refuse to give up its responder lock.
-    // - Determine if releasing should dismiss the keyboard when we are in
-    // tap-to-dismiss mode (!this.props.keyboardShouldPersistTaps).
-    _define_property(_this, "observedScrollSinceBecomingResponder", !1), _define_property(_this, "becameResponderWhileAnimating", !1), _this;
-  }
-  return _create_class(ScrollView2, [
-    {
+var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16,
+  ScrollView = /* @__PURE__ */function (_React_Component) {
+    "use strict";
+
+    _inherits(ScrollView2, _React_Component);
+    function ScrollView2() {
+      _class_call_check(this, ScrollView2);
+      var _this;
+      return _this = _call_super(this, ScrollView2, arguments), _define_property(_this, "_scrollNodeRef", void 0), _define_property(_this, "_innerViewRef", void 0), _define_property(_this, "keyboardWillOpenTo", null), _define_property(_this, "additionalScrollOffset", 0), _define_property(_this, "isTouching", !1), _define_property(_this, "lastMomentumScrollBeginTime", 0), _define_property(_this, "lastMomentumScrollEndTime", 0),
+      // Reset to false every time becomes responder. This is used to:
+      // - Determine if the scroll view has been scrolled and therefore should
+      // refuse to give up its responder lock.
+      // - Determine if releasing should dismiss the keyboard when we are in
+      // tap-to-dismiss mode (!this.props.keyboardShouldPersistTaps).
+      _define_property(_this, "observedScrollSinceBecomingResponder", !1), _define_property(_this, "becameResponderWhileAnimating", !1), _this;
+    }
+    return _create_class(ScrollView2, [{
       /**
       * Returns a reference to the underlying scroll responder, which supports
       * operations like `scrollTo`. All ScrollView-like components should
@@ -92,37 +90,32 @@ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16, ScrollView = /* @__PURE__ */ fun
       * to the underlying scroll responder's methods.
       */
       key: "getScrollResponder",
-      value: function() {
+      value: function () {
         return this.mixin;
       }
-    },
-    {
+    }, {
       key: "getScrollableNode",
-      value: function() {
+      value: function () {
         return this._scrollNodeRef;
       }
-    },
-    {
+    }, {
       key: "getInnerViewRef",
-      value: function() {
+      value: function () {
         return this._innerViewRef;
       }
-    },
-    {
+    }, {
       key: "getInnerViewNode",
-      value: function() {
+      value: function () {
         return this._innerViewRef;
       }
-    },
-    {
+    }, {
       key: "getNativeScrollRef",
-      value: function() {
+      value: function () {
         return this._scrollNodeRef;
       }
-    },
-    {
+    }, {
       key: "render",
-      value: function() {
+      value: function () {
         var {
           contentContainerStyle,
           horizontal,
@@ -139,106 +132,99 @@ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16, ScrollView = /* @__PURE__ */ fun
           ...other
         } = this.props;
         if (process.env.NODE_ENV !== "production" && this.props.style) {
-          var style = StyleSheet.flatten(this.props.style), childLayoutProps = [
-            "alignItems",
-            "justifyContent"
-          ].filter(function(prop) {
-            return style && style[prop] !== void 0;
-          });
+          var style = StyleSheet.flatten(this.props.style),
+            childLayoutProps = ["alignItems", "justifyContent"].filter(function (prop) {
+              return style && style[prop] !== void 0;
+            });
           invariant(childLayoutProps.length === 0, `ScrollView child layout (${JSON.stringify(childLayoutProps)}) must be applied through the contentContainerStyle prop.`);
         }
         var contentSizeChangeProps = {};
         onContentSizeChange && (contentSizeChangeProps = {
           onLayout: this._handleContentOnLayout.bind(this)
         });
-        var hasStickyHeaderIndices = !horizontal && Array.isArray(stickyHeaderIndices), children = hasStickyHeaderIndices || pagingEnabled ? React.Children.map(this.props.children, function(child, i) {
-          var isSticky = hasStickyHeaderIndices && stickyHeaderIndices.indexOf(i) > -1;
-          return child != null && (isSticky || pagingEnabled) ? /* @__PURE__ */ _jsx(View, {
-            style: StyleSheet.compose(isSticky && styles.stickyHeader, pagingEnabled && styles.pagingEnabledChild),
-            children: child
-          }) : child;
-        }) : this.props.children, contentContainer = /* @__PURE__ */ _jsx(View, {
-          ...contentSizeChangeProps,
-          // @ts-ignore
-          collapsable: !1,
-          ref: this._setInnerViewRef.bind(this),
-          style: [
-            horizontal && styles.contentContainerHorizontal,
-            centerContent && styles.contentContainerCenterContent,
-            contentContainerStyle
-          ],
-          children
-        }), baseStyle = horizontal ? styles.baseHorizontal : styles.baseVertical, pagingEnabledStyle = horizontal ? styles.pagingEnabledHorizontal : styles.pagingEnabledVertical, props = {
-          ...other,
-          style: [
-            baseStyle,
-            pagingEnabled && pagingEnabledStyle,
-            this.props.style
-          ],
-          onTouchStart: this.scrollResponderHandleTouchStart.bind(this),
-          onTouchMove: this.scrollResponderHandleTouchMove.bind(this),
-          onTouchEnd: this.scrollResponderHandleTouchEnd.bind(this),
-          onScrollBeginDrag: this.scrollResponderHandleScrollBeginDrag.bind(this),
-          onScrollEndDrag: this.scrollResponderHandleScrollEndDrag.bind(this),
-          onMomentumScrollBegin: this.scrollResponderHandleMomentumScrollBegin.bind(this),
-          onMomentumScrollEnd: this.scrollResponderHandleMomentumScrollEnd.bind(this),
-          onStartShouldSetResponder: this.scrollResponderHandleStartShouldSetResponder.bind(this),
-          onStartShouldSetResponderCapture: this.scrollResponderHandleStartShouldSetResponderCapture.bind(this),
-          onScrollShouldSetResponder: this.scrollResponderHandleScrollShouldSetResponder.bind(this),
-          onScroll: this._handleScroll.bind(this),
-          onResponderGrant: this.scrollResponderHandleResponderGrant.bind(this),
-          onResponderTerminationRequest: this.scrollResponderHandleTerminationRequest.bind(this),
-          onResponderRelease: this.scrollResponderHandleResponderRelease.bind(this),
-          onResponderReject: this.scrollResponderHandleResponderReject.bind(this)
-        }, ScrollViewClass = ScrollViewBase;
+        var hasStickyHeaderIndices = !horizontal && Array.isArray(stickyHeaderIndices),
+          children = hasStickyHeaderIndices || pagingEnabled ? React.Children.map(this.props.children, function (child, i) {
+            var isSticky = hasStickyHeaderIndices && stickyHeaderIndices.indexOf(i) > -1;
+            return child != null && (isSticky || pagingEnabled) ? /* @__PURE__ */_jsx(View, {
+              style: StyleSheet.compose(isSticky && styles.stickyHeader, pagingEnabled && styles.pagingEnabledChild),
+              children: child
+            }) : child;
+          }) : this.props.children,
+          contentContainer = /* @__PURE__ */_jsx(View, {
+            ...contentSizeChangeProps,
+            // @ts-ignore
+            collapsable: !1,
+            ref: this._setInnerViewRef.bind(this),
+            style: [horizontal && styles.contentContainerHorizontal, centerContent && styles.contentContainerCenterContent, contentContainerStyle],
+            children
+          }),
+          baseStyle = horizontal ? styles.baseHorizontal : styles.baseVertical,
+          pagingEnabledStyle = horizontal ? styles.pagingEnabledHorizontal : styles.pagingEnabledVertical,
+          props = {
+            ...other,
+            style: [baseStyle, pagingEnabled && pagingEnabledStyle, this.props.style],
+            onTouchStart: this.scrollResponderHandleTouchStart.bind(this),
+            onTouchMove: this.scrollResponderHandleTouchMove.bind(this),
+            onTouchEnd: this.scrollResponderHandleTouchEnd.bind(this),
+            onScrollBeginDrag: this.scrollResponderHandleScrollBeginDrag.bind(this),
+            onScrollEndDrag: this.scrollResponderHandleScrollEndDrag.bind(this),
+            onMomentumScrollBegin: this.scrollResponderHandleMomentumScrollBegin.bind(this),
+            onMomentumScrollEnd: this.scrollResponderHandleMomentumScrollEnd.bind(this),
+            onStartShouldSetResponder: this.scrollResponderHandleStartShouldSetResponder.bind(this),
+            onStartShouldSetResponderCapture: this.scrollResponderHandleStartShouldSetResponderCapture.bind(this),
+            onScrollShouldSetResponder: this.scrollResponderHandleScrollShouldSetResponder.bind(this),
+            onScroll: this._handleScroll.bind(this),
+            onResponderGrant: this.scrollResponderHandleResponderGrant.bind(this),
+            onResponderTerminationRequest: this.scrollResponderHandleTerminationRequest.bind(this),
+            onResponderRelease: this.scrollResponderHandleResponderRelease.bind(this),
+            onResponderReject: this.scrollResponderHandleResponderReject.bind(this)
+          },
+          ScrollViewClass = ScrollViewBase;
         invariant(ScrollViewClass !== void 0, "ScrollViewClass must not be undefined");
-        var scrollView = /* @__PURE__ */ _jsx(ScrollViewClass, {
+        var scrollView = /* @__PURE__ */_jsx(ScrollViewClass, {
           ...props,
           ref: this._setScrollNodeRef.bind(this),
           children: contentContainer
         });
-        return refreshControl ? /* @__PURE__ */ React.cloneElement(refreshControl, {
+        return refreshControl ? /* @__PURE__ */React.cloneElement(refreshControl, {
           style: props.style
         }, scrollView) : scrollView;
       }
-    },
-    {
+    }, {
       key: "_handleContentOnLayout",
-      value: function(e) {
-        var { width, height } = e.nativeEvent.layout;
+      value: function (e) {
+        var {
+          width,
+          height
+        } = e.nativeEvent.layout;
         this.props.onContentSizeChange(width, height);
       }
-    },
-    {
+    }, {
       key: "_handleScroll",
-      value: function(e) {
+      value: function (e) {
         process.env.NODE_ENV !== "production" && this.props.onScroll && this.props.scrollEventThrottle == null && console.info("You specified `onScroll` on a <ScrollView> but not `scrollEventThrottle`. You will only receive one event. Using `16` you get all the events but be aware that it may cause frame drops, use a bigger number if you don't need as much precision."), this.props.keyboardDismissMode === "on-drag" && dismissKeyboard(), this.scrollResponderHandleScroll(e);
       }
-    },
-    {
+    }, {
       key: "_setInnerViewRef",
-      value: function(node) {
+      value: function (node) {
         this._innerViewRef = node;
       }
-    },
-    {
+    }, {
       key: "_setScrollNodeRef",
-      value: function(node) {
+      value: function (node) {
         this._scrollNodeRef = node, node != null && (node.getScrollResponder = this.getScrollResponder, node.getInnerViewNode = this.getInnerViewNode, node.getInnerViewRef = this.getInnerViewRef, node.getNativeScrollRef = this.getNativeScrollRef, node.getScrollableNode = this.getScrollableNode, node.scrollTo = this.scrollTo, node.scrollToEnd = this.scrollToEnd, node.scrollResponderZoomTo = this.scrollResponderZoomTo, node.scrollResponderScrollNativeHandleToKeyboard = this.scrollResponderScrollNativeHandleToKeyboard);
         var ref = mergeRefs(this.props.forwardedRef);
         ref(node);
       }
-    },
-    {
+    }, {
       /**
       * Invoke this from an `onScroll` event.
       */
       key: "scrollResponderHandleScrollShouldSetResponder",
-      value: function() {
+      value: function () {
         return this.isTouching;
       }
-    },
-    {
+    }, {
       /**
       * Merely touch starting is not sufficient for a scroll view to become the
       * responder. Being the "responder" means that the very next touch move/end
@@ -265,11 +251,10 @@ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16, ScrollView = /* @__PURE__ */ fun
       *
       */
       key: "scrollResponderHandleStartShouldSetResponder",
-      value: function() {
+      value: function () {
         return !1;
       }
-    },
-    {
+    }, {
       /**
       * There are times when the scroll view wants to become the responder
       * (meaning respond to the next immediate `touchStart/touchEnd`), in a way
@@ -282,11 +267,10 @@ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16, ScrollView = /* @__PURE__ */ fun
       * Invoke this from an `onStartShouldSetResponderCapture` event.
       */
       key: "scrollResponderHandleStartShouldSetResponderCapture",
-      value: function(e) {
+      value: function (e) {
         return this.scrollResponderIsAnimating();
       }
-    },
-    {
+    }, {
       /**
       * Invoke this from an `onResponderReject` event.
       *
@@ -298,11 +282,10 @@ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16, ScrollView = /* @__PURE__ */ fun
       * a touch has already started.
       */
       key: "scrollResponderHandleResponderReject",
-      value: function() {
+      value: function () {
         warning(!1, "ScrollView doesn't take rejection well - scrolls anyway");
       }
-    },
-    {
+    }, {
       /**
       * We will allow the scroll view to give up its lock iff it acquired the lock
       * during an animation. This is a very useful default that happens to satisfy
@@ -319,49 +302,44 @@ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16, ScrollView = /* @__PURE__ */ fun
       *   rejected.
       */
       key: "scrollResponderHandleTerminationRequest",
-      value: function() {
+      value: function () {
         return !this.observedScrollSinceBecomingResponder;
       }
-    },
-    {
+    }, {
       /**
       * Invoke this from an `onTouchEnd` event.
       *
       * @param {SyntheticEvent} e Event.
       */
       key: "scrollResponderHandleTouchEnd",
-      value: function(e) {
+      value: function (e) {
         var nativeEvent = e.nativeEvent;
         this.isTouching = nativeEvent.touches.length !== 0, this.props.onTouchEnd && this.props.onTouchEnd(e);
       }
-    },
-    {
+    }, {
       /**
       * Invoke this from an `onResponderRelease` event.
       */
       key: "scrollResponderHandleResponderRelease",
-      value: function(e) {
+      value: function (e) {
         this.props.onResponderRelease && this.props.onResponderRelease(e);
         var currentlyFocusedTextInput = TextInputState.currentlyFocusedField();
         !this.props.keyboardShouldPersistTaps && currentlyFocusedTextInput != null && e.target !== currentlyFocusedTextInput && !this.observedScrollSinceBecomingResponder && !this.becameResponderWhileAnimating && (this.props.onScrollResponderKeyboardDismissed && this.props.onScrollResponderKeyboardDismissed(e), TextInputState.blurTextInput(currentlyFocusedTextInput));
       }
-    },
-    {
+    }, {
       key: "scrollResponderHandleScroll",
-      value: function(e) {
+      value: function (e) {
         this.observedScrollSinceBecomingResponder = !0, this.props.onScroll && this.props.onScroll(e);
       }
-    },
-    {
+    }, {
       /**
       * Invoke this from an `onResponderGrant` event.
       */
       key: "scrollResponderHandleResponderGrant",
-      value: function(e) {
+      value: function (e) {
         this.observedScrollSinceBecomingResponder = !1, this.props.onResponderGrant && this.props.onResponderGrant(e), this.becameResponderWhileAnimating = this.scrollResponderIsAnimating();
       }
-    },
-    {
+    }, {
       /**
       * Unfortunately, `onScrollBeginDrag` also fires when *stopping* the scroll
       * animation, and there's not an easy way to distinguish a drag vs. stopping
@@ -370,38 +348,34 @@ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16, ScrollView = /* @__PURE__ */ fun
       * Invoke this from an `onScrollBeginDrag` event.
       */
       key: "scrollResponderHandleScrollBeginDrag",
-      value: function(e) {
+      value: function (e) {
         this.props.onScrollBeginDrag && this.props.onScrollBeginDrag(e);
       }
-    },
-    {
+    }, {
       /**
       * Invoke this from an `onScrollEndDrag` event.
       */
       key: "scrollResponderHandleScrollEndDrag",
-      value: function(e) {
+      value: function (e) {
         this.props.onScrollEndDrag && this.props.onScrollEndDrag(e);
       }
-    },
-    {
+    }, {
       /**
       * Invoke this from an `onMomentumScrollBegin` event.
       */
       key: "scrollResponderHandleMomentumScrollBegin",
-      value: function(e) {
+      value: function (e) {
         this.lastMomentumScrollBeginTime = Date.now(), this.props.onMomentumScrollBegin && this.props.onMomentumScrollBegin(e);
       }
-    },
-    {
+    }, {
       /**
       * Invoke this from an `onMomentumScrollEnd` event.
       */
       key: "scrollResponderHandleMomentumScrollEnd",
-      value: function(e) {
+      value: function (e) {
         this.lastMomentumScrollEndTime = Date.now(), this.props.onMomentumScrollEnd && this.props.onMomentumScrollEnd(e);
       }
-    },
-    {
+    }, {
       /**
       * Invoke this from an `onTouchStart` event.
       *
@@ -414,11 +388,10 @@ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16, ScrollView = /* @__PURE__ */ fun
       * @param {SyntheticEvent} e Touch Start event.
       */
       key: "scrollResponderHandleTouchStart",
-      value: function(e) {
+      value: function (e) {
         this.isTouching = !0, this.props.onTouchStart && this.props.onTouchStart(e);
       }
-    },
-    {
+    }, {
       /**
       * Invoke this from an `onTouchMove` event.
       *
@@ -431,79 +404,78 @@ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16, ScrollView = /* @__PURE__ */ fun
       * @param {SyntheticEvent} e Touch Start event.
       */
       key: "scrollResponderHandleTouchMove",
-      value: function(e) {
+      value: function (e) {
         this.props.onTouchMove && this.props.onTouchMove(e);
       }
-    },
-    {
+    }, {
       /**
       * A helper function for this class that lets us quickly determine if the
       * view is currently animating. This is particularly useful to know when
       * a touch has just started or ended.
       */
       key: "scrollResponderIsAnimating",
-      value: function() {
-        var now = Date.now(), timeSinceLastMomentumScrollEnd = now - this.lastMomentumScrollEndTime, isAnimating = timeSinceLastMomentumScrollEnd < IS_ANIMATING_TOUCH_START_THRESHOLD_MS || this.lastMomentumScrollEndTime < this.lastMomentumScrollBeginTime;
+      value: function () {
+        var now = Date.now(),
+          timeSinceLastMomentumScrollEnd = now - this.lastMomentumScrollEndTime,
+          isAnimating = timeSinceLastMomentumScrollEnd < IS_ANIMATING_TOUCH_START_THRESHOLD_MS || this.lastMomentumScrollEndTime < this.lastMomentumScrollBeginTime;
         return isAnimating;
       }
-    }
-  ]), ScrollView2;
-}(React.Component), commonStyle = {
-  flexGrow: 1,
-  flexShrink: 1,
-  // Enable hardware compositing in modern browsers.
-  // Creates a new layer with its own backing surface that can significantly
-  // improve scroll performance.
-  transform: [
-    {
+    }]), ScrollView2;
+  }(React.Component),
+  commonStyle = {
+    flexGrow: 1,
+    flexShrink: 1,
+    // Enable hardware compositing in modern browsers.
+    // Creates a new layer with its own backing surface that can significantly
+    // improve scroll performance.
+    transform: [{
       translateZ: 0
-    }
-  ],
-  // iOS native scrolling
-  WebkitOverflowScrolling: "touch"
-}, styles = {
-  baseVertical: {
-    ...commonStyle,
-    flexDirection: "column",
-    overflowX: "hidden",
-    overflowY: "auto"
-  },
-  baseHorizontal: {
-    ...commonStyle,
-    flexDirection: "row",
-    overflowX: "auto",
-    overflowY: "hidden"
-  },
-  contentContainerHorizontal: {
-    flexDirection: "row"
-  },
-  contentContainerCenterContent: {
-    justifyContent: "center",
-    flexGrow: 1
+    }],
+    // iOS native scrolling
+    WebkitOverflowScrolling: "touch"
   },
-  stickyHeader: {
-    position: "sticky",
-    top: 0,
-    zIndex: 10
-  },
-  pagingEnabledHorizontal: {
-    scrollSnapType: "x mandatory"
-  },
-  pagingEnabledVertical: {
-    scrollSnapType: "y mandatory"
+  styles = {
+    baseVertical: {
+      ...commonStyle,
+      flexDirection: "column",
+      overflowX: "hidden",
+      overflowY: "auto"
+    },
+    baseHorizontal: {
+      ...commonStyle,
+      flexDirection: "row",
+      overflowX: "auto",
+      overflowY: "hidden"
+    },
+    contentContainerHorizontal: {
+      flexDirection: "row"
+    },
+    contentContainerCenterContent: {
+      justifyContent: "center",
+      flexGrow: 1
+    },
+    stickyHeader: {
+      position: "sticky",
+      top: 0,
+      zIndex: 10
+    },
+    pagingEnabledHorizontal: {
+      scrollSnapType: "x mandatory"
+    },
+    pagingEnabledVertical: {
+      scrollSnapType: "y mandatory"
+    },
+    pagingEnabledChild: {
+      scrollSnapAlign: "start"
+    }
   },
-  pagingEnabledChild: {
-    scrollSnapAlign: "start"
-  }
-}, ForwardedScrollView = /* @__PURE__ */ React.forwardRef(function(props, forwardedRef) {
-  return /* @__PURE__ */ _jsx(ScrollView, {
-    ...props,
-    forwardedRef
+  ForwardedScrollView = /* @__PURE__ */React.forwardRef(function (props, forwardedRef) {
+    return /* @__PURE__ */_jsx(ScrollView, {
+      ...props,
+      forwardedRef
+    });
   });
-});
 ForwardedScrollView.displayName = "ScrollView";
 var ScrollView_default = ForwardedScrollView;
-export {
-  ScrollView_default as default
-};
-//# sourceMappingURL=index.js.map
+export { ScrollView_default as default };
+//# sourceMappingURL=index.native.js.map