react-native-system-ui 0.0.7 → 1.0.0

package/dist/es/components/swiper/Swiper.js

@@ -1,23 +1,18 @@
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-import React, { useRef, useState, useCallback, useEffect, useImperativeHandle, forwardRef, useMemo, Children, isValidElement } from 'react';
+import React, { useRef, useState, useCallback, useEffect, useImperativeHandle, forwardRef, memo, useMemo, Children, isValidElement } from 'react';
 import { FlatList, View, StyleSheet, useWindowDimensions, Platform } from 'react-native';
 import { clamp } from '../../utils/number';
 import SwiperPagIndicator from './SwiperPagIndicator';
-export const SwiperItem = /*#__PURE__*/forwardRef((props, ref) => {
-  const {
-    style,
-    children,
-    testID
-  } = props;
-  return /*#__PURE__*/React.createElement(View, {
-    ref: ref,
-    style: [styles.item, style],
-    testID: testID
-  }, children);
-});
-SwiperItem.displayName = 'SwiperItem';
-const DEFAULT_AUTOPLAY_INTERVAL = 3000;
-const LOOP_RENDER_ALL_THRESHOLD = 10;
+import { useSwiperTokens } from './tokens';
+const SwiperItemImpl = (props, ref) => /*#__PURE__*/React.createElement(View, {
+  ref: ref,
+  style: [S.item, props.style],
+  testID: props.testID
+}, props.children);
+const SwiperItemFR = /*#__PURE__*/forwardRef(SwiperItemImpl);
+SwiperItemFR.displayName = 'SwiperItem';
+export const SwiperItem = /*#__PURE__*/memo(SwiperItemFR);
+const LOOP_THRESHOLD = 10;
 const SwiperImpl = (props, ref) => {
   const {
     data,
@@ -34,310 +29,313 @@ const SwiperImpl = (props, ref) => {
     style,
     testID
   } = props;
-  const flatListRef = useRef(null);
-  const autoplayTimerRef = useRef(null);
-  const isInteractingRef = useRef(false);
-  const isAnimatingRef = useRef(false);
-  const queuedIndexRef = useRef(null);
-  const isMomentumRef = useRef(false);
+  const tokens = useSwiperTokens();
+  const listRef = useRef(null);
+  const autoRef = useRef(null);
+  const interRef = useRef(false);
+  const animRef = useRef(false);
+  const queueRef = useRef(null);
+  const momRef = useRef(false);
+  const dragRef = useRef(null);
   const isWeb = Platform.OS === 'web';
   const {
-    width: windowWidth,
-    height: windowHeight
+    width: wW,
+    height: wH
   } = useWindowDimensions();
   const [layout, setLayout] = useState({
     width: 0,
     height: 0
   });
-  const handleLayout = useCallback(event => {
+  const onLayout = useCallback(e => {
     const {
-      width,
-      height
-    } = event.nativeEvent.layout;
-    setLayout(prev => prev.width === width && prev.height === height ? prev : {
-      width,
-      height
+      width: w,
+      height: h
+    } = e.nativeEvent.layout;
+    setLayout(p => p.width === w && p.height === h ? p : {
+      width: w,
+      height: h
     });
   }, []);
-  const childItems = useMemo(() => {
-    if (!children) return [];
-    return Children.toArray(children).filter(child => /*#__PURE__*/isValidElement(child));
-  }, [children]);
+  const items = useMemo(() => !children ? [] : Children.toArray(children).filter(c => /*#__PURE__*/isValidElement(c)), [children]);
   const usingData = Array.isArray(data);
-  const baseItems = useMemo(() => usingData ? data : childItems, [usingData, data, childItems]);
-  const count = baseItems.length;
+  const base = usingData ? data : items;
+  const count = base.length;
   const shouldLoop = loop && count > 1;
-  const displayData = useMemo(() => {
-    if (!shouldLoop) return baseItems;
-    const head = baseItems[count - 1];
-    const tail = baseItems[0];
-    return [head, ...baseItems, tail];
-  }, [baseItems, shouldLoop, count]);
-  const displayCount = displayData.length;
-  const loopRenderAll = shouldLoop && displayCount <= LOOP_RENDER_ALL_THRESHOLD;
-  const getRealIndex = useCallback(displayIndex => {
-    if (!shouldLoop) return clamp(displayIndex, 0, count - 1);
-    if (displayIndex === 0) return count - 1;
-    if (displayIndex === displayCount - 1) return 0;
-    return displayIndex - 1;
-  }, [shouldLoop, count, displayCount]);
-  const getDisplayIndex = useCallback(realIndex => {
-    if (!shouldLoop) return clamp(realIndex, 0, count - 1);
-    return clamp(realIndex, 0, count - 1) + 1;
-  }, [shouldLoop, count]);
-  const initialRealIndex = clamp(initialSwipe, 0, Math.max(0, count - 1));
-  const initialDisplayIndex = getDisplayIndex(initialRealIndex);
-  const currentIndexRef = useRef(initialRealIndex);
-  const [currentIndex, setCurrentIndex] = useState(initialRealIndex);
-  const layoutReady = layout.width > 0 && layout.height > 0;
-  const mainSize = vertical ? layout.height || windowHeight || 1 : layout.width || windowWidth || 1;
-  const crossSize = vertical ? layout.width || windowWidth || 1 : layout.height || windowHeight || 1;
-  const itemStyle = useMemo(() => ({
-    width: vertical ? crossSize : mainSize,
-    height: vertical ? mainSize : crossSize
-  }), [vertical, mainSize, crossSize]);
-  const clearAutoplay = useCallback(() => {
-    if (autoplayTimerRef.current) {
-      clearTimeout(autoplayTimerRef.current);
-      autoplayTimerRef.current = null;
+  const display = useMemo(() => shouldLoop ? [base[count - 1], ...base, base[0]] : base, [base, shouldLoop, count]);
+  const dCount = display.length;
+  const loopAll = shouldLoop && dCount <= LOOP_THRESHOLD;
+  const realIdx = useCallback(di => !shouldLoop ? clamp(di, 0, count - 1) : di === 0 ? count - 1 : di === dCount - 1 ? 0 : di - 1, [shouldLoop, count, dCount]);
+  const dispIdx = useCallback(ri => shouldLoop ? clamp(ri, 0, count - 1) + 1 : clamp(ri, 0, count - 1), [shouldLoop, count]);
+  const initReal = clamp(initialSwipe, 0, Math.max(0, count - 1));
+  const initDisp = dispIdx(initReal);
+  const curRef = useRef(initReal);
+  const [curIdx, setCurIdx] = useState(initReal);
+  const ready = layout.width > 0 && layout.height > 0;
+  const mainSz = vertical ? layout.height || wH || 1 : layout.width || wW || 1;
+  const crossSz = vertical ? layout.width || wW || 1 : layout.height || wH || 1;
+  const itemSz = useMemo(() => ({
+    width: vertical ? crossSz : mainSz,
+    height: vertical ? mainSz : crossSz
+  }), [vertical, mainSz, crossSz]);
+  const clearAuto = useCallback(() => {
+    if (autoRef.current) {
+      clearTimeout(autoRef.current);
+      autoRef.current = null;
     }
   }, []);
-  const updateIndex = useCallback(next => {
-    const clamped = clamp(next, 0, Math.max(0, count - 1));
-    if (currentIndexRef.current === clamped) return;
-    currentIndexRef.current = clamped;
-    setCurrentIndex(clamped);
-    onChange?.(clamped);
-  }, [count, onChange]);
-  const scrollToDisplayIndex = useCallback((displayIndex, animated) => {
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  const update = useCallback(n => {
+    const c = clamp(n, 0, Math.max(0, count - 1));
+    if (curRef.current === c) return;
+    curRef.current = c;
+    setCurIdx(c);
+    onChangeRef.current?.(c);
+  }, [count]);
+  const scrollTo = useCallback((i, anim) => {
     try {
-      flatListRef.current?.scrollToIndex({
-        index: displayIndex,
-        animated
+      listRef.current?.scrollToIndex({
+        index: i,
+        animated: anim
       });
     } catch {}
   }, []);
   const swipeTo = useCallback((index, animated = true) => {
     if (count === 0) return;
-    if (animated && isAnimatingRef.current) {
-      queuedIndexRef.current = index;
+    if (animated && animRef.current) {
+      queueRef.current = index;
       return;
     }
-    const targetRealIndex = clamp(index, 0, count - 1);
-    let targetDisplayIndex = getDisplayIndex(targetRealIndex);
-    let resolvedAnimated = animated;
-    if (isWeb && shouldLoop && animated) {
-      const currentRealIndex = currentIndexRef.current;
-      if (currentRealIndex === count - 1 && targetRealIndex === 0 || currentRealIndex === 0 && targetRealIndex === count - 1) {
-        resolvedAnimated = false;
-      }
-    }
-    if (shouldLoop && resolvedAnimated) {
-      const currentDisplayIndex = getDisplayIndex(currentIndexRef.current);
-      if (currentDisplayIndex === count && targetRealIndex === 0) {
-        targetDisplayIndex = displayCount - 1;
-      } else if (currentDisplayIndex === 1 && targetRealIndex === count - 1) {
-        targetDisplayIndex = 0;
-      }
+    const tReal = clamp(index, 0, count - 1);
+    let tDisp = dispIdx(tReal);
+    if (shouldLoop && animated) {
+      const cDisp = dispIdx(curRef.current);
+      if (cDisp === count && tReal === 0) tDisp = dCount - 1;else if (cDisp === 1 && tReal === count - 1) tDisp = 0;
     }
-    const currentRealIndex = currentIndexRef.current;
-    const currentDisplayIndex = getDisplayIndex(currentRealIndex);
-    if (targetRealIndex === currentRealIndex && targetDisplayIndex === currentDisplayIndex) {
-      if (queuedIndexRef.current != null) {
-        const next = queuedIndexRef.current;
-        queuedIndexRef.current = null;
-        swipeTo(next, true);
+    const cReal = curRef.current,
+      cDisp = dispIdx(cReal);
+    if (tReal === cReal && tDisp === cDisp) {
+      if (queueRef.current != null) {
+        const q = queueRef.current;
+        queueRef.current = null;
+        swipeTo(q, true);
       }
+      ;
       return;
     }
-    if (resolvedAnimated) {
-      isAnimatingRef.current = true;
-    }
-    scrollToDisplayIndex(targetDisplayIndex, resolvedAnimated);
-    if (!resolvedAnimated) {
-      updateIndex(targetRealIndex);
-      if (queuedIndexRef.current != null) {
-        const next = queuedIndexRef.current;
-        queuedIndexRef.current = null;
-        swipeTo(next, true);
+    if (animated) animRef.current = true;
+    scrollTo(tDisp, animated);
+    if (!animated) {
+      update(tReal);
+      if (queueRef.current != null) {
+        const q = queueRef.current;
+        queueRef.current = null;
+        swipeTo(q, true);
       }
     }
-  }, [count, getDisplayIndex, scrollToDisplayIndex, shouldLoop, displayCount, updateIndex, isWeb]);
-  const resolveAutoplayInterval = useCallback(() => {
-    if (typeof autoplay === 'number') return Math.max(0, autoplay);
-    if (autoplay) return DEFAULT_AUTOPLAY_INTERVAL;
-    return 0;
-  }, [autoplay]);
-  const scheduleAutoplay = useCallback(() => {
-    const interval = resolveAutoplayInterval();
-    if (!interval || count <= 1) return;
-    if (isInteractingRef.current && !isWeb) return;
-    clearAutoplay();
-    autoplayTimerRef.current = setTimeout(() => {
-      if (isInteractingRef.current && !isWeb) return;
-      const nextIndex = shouldLoop ? (currentIndexRef.current + 1) % count : clamp(currentIndexRef.current + 1, 0, count - 1);
-      swipeTo(nextIndex, true);
-    }, interval);
-  }, [resolveAutoplayInterval, count, clearAutoplay, shouldLoop, swipeTo]);
-  const swipeNext = useCallback(() => {
+  }, [count, dispIdx, scrollTo, shouldLoop, dCount, update]);
+  const schedule = useCallback(() => {
+    const iv = typeof autoplay === 'number' ? Math.max(0, autoplay) : autoplay ? tokens.defaults.autoplayInterval : 0;
+    if (!iv || count <= 1) return;
+    if (interRef.current && !isWeb) return;
+    clearAuto();
+    autoRef.current = setTimeout(() => {
+      if (interRef.current && !isWeb) return;
+      swipeTo(shouldLoop ? (curRef.current + 1) % count : clamp(curRef.current + 1, 0, count - 1), true);
+    }, iv);
+  }, [autoplay, count, clearAuto, shouldLoop, swipeTo, isWeb, tokens.defaults.autoplayInterval]);
+  const next = useCallback(() => {
     if (count === 0) return;
-    const next = shouldLoop ? (currentIndexRef.current + 1) % count : clamp(currentIndexRef.current + 1, 0, count - 1);
-    swipeTo(next, true);
+    swipeTo(shouldLoop ? (curRef.current + 1) % count : clamp(curRef.current + 1, 0, count - 1), true);
   }, [count, shouldLoop, swipeTo]);
-  const swipePrev = useCallback(() => {
+  const prev = useCallback(() => {
     if (count === 0) return;
-    const next = shouldLoop ? (currentIndexRef.current - 1 + count) % count : clamp(currentIndexRef.current - 1, 0, count - 1);
-    swipeTo(next, true);
+    swipeTo(shouldLoop ? (curRef.current - 1 + count) % count : clamp(curRef.current - 1, 0, count - 1), true);
   }, [count, shouldLoop, swipeTo]);
-  const flushQueuedSwipe = () => {
-    if (queuedIndexRef.current == null) return;
-    const next = queuedIndexRef.current;
-    queuedIndexRef.current = null;
-    swipeTo(next, true);
+  const flush = () => {
+    if (queueRef.current == null) return;
+    const q = queueRef.current;
+    queueRef.current = null;
+    swipeTo(q, true);
   };
   useImperativeHandle(ref, () => ({
     swipeTo,
-    swipeNext,
-    swipePrev,
-    getCurrentIndex: () => currentIndexRef.current
-  }), [swipeTo, swipeNext, swipePrev]);
+    swipeNext: next,
+    swipePrev: prev,
+    getCurrentIndex: () => curRef.current
+  }), [swipeTo, next, prev]);
   useEffect(() => {
-    if (!layoutReady || count === 0) return;
-    scrollToDisplayIndex(initialDisplayIndex, false);
-  }, [layoutReady, count, initialDisplayIndex, scrollToDisplayIndex]);
+    if (!ready || count === 0) return;
+    scrollTo(initDisp, false);
+  }, [ready, count, initDisp, scrollTo]);
   useEffect(() => {
-    scheduleAutoplay();
-    return clearAutoplay;
-  }, [scheduleAutoplay, clearAutoplay, currentIndex]);
-  const handleScrollBeginDrag = () => {
-    isInteractingRef.current = true;
-    clearAutoplay();
-  };
-  const handleScroll = event => {
-    if (!isWeb || count <= 1) return;
-    const offset = vertical ? event.nativeEvent.contentOffset.y : event.nativeEvent.contentOffset.x;
-    const displayIndex = Math.round(offset / mainSize);
-    const nextDisplayIndex = shouldLoop ? clamp(displayIndex, 0, displayCount - 1) : clamp(displayIndex, 0, count - 1);
-    updateIndex(getRealIndex(nextDisplayIndex));
-    const alignedOffset = Math.round(offset / mainSize) * mainSize;
-    if (Math.abs(offset - alignedOffset) < 0.5) {
-      isAnimatingRef.current = false;
-      isInteractingRef.current = false;
-      isMomentumRef.current = false;
-      scheduleAutoplay();
-      flushQueuedSwipe();
+    schedule();
+    return clearAuto;
+  }, [schedule, clearAuto, curIdx]);
+  const reset = useCallback(() => {
+    animRef.current = false;
+    interRef.current = false;
+    momRef.current = false;
+    schedule();
+    flush();
+  }, [schedule]);
+  const onScroll = useCallback(e => {
+    if (count <= 1) return;
+    const off = vertical ? e.nativeEvent.contentOffset.y : e.nativeEvent.contentOffset.x;
+    const di = Math.round(off / mainSz);
+    const cdi = shouldLoop ? clamp(di, 0, dCount - 1) : clamp(di, 0, count - 1);
+    update(realIdx(cdi));
+    if (isWeb) {
+      const aligned = di * mainSz;
+      if (Math.abs(off - aligned) < 0.5) {
+        if (shouldLoop && (di <= 0 || di >= dCount - 1)) scrollTo(di <= 0 ? count : 1, false);
+        reset();
+      }
     }
-  };
-  const handleMomentumScrollBegin = () => {
-    isMomentumRef.current = true;
-  };
-  const handleScrollEndDrag = event => {
-    if (isMomentumRef.current) return;
-    handleScrollEnd(event);
-  };
-  const handleScrollEnd = event => {
-    if (count === 0) return;
-    const offset = vertical ? event.nativeEvent.contentOffset.y : event.nativeEvent.contentOffset.x;
-    const displayIndex = Math.round(offset / mainSize);
-    let nextDisplayIndex = displayIndex;
+  }, [count, vertical, mainSz, shouldLoop, dCount, update, realIdx, scrollTo, reset, isWeb]);
+  const onEnd = useCallback(e => {
+    if (isWeb || count === 0) return;
+    const off = vertical ? e.nativeEvent.contentOffset.y : e.nativeEvent.contentOffset.x;
+    const di = Math.round(off / mainSz);
+    let ndi = di;
     if (shouldLoop) {
-      if (displayIndex === 0) nextDisplayIndex = count;
-      if (displayIndex === displayCount - 1) nextDisplayIndex = 1;
+      if (di === 0) ndi = count;
+      if (di === dCount - 1) ndi = 1;
     }
-    if (nextDisplayIndex !== displayIndex) {
-      scrollToDisplayIndex(nextDisplayIndex, false);
-    }
-    updateIndex(getRealIndex(nextDisplayIndex));
-    isInteractingRef.current = false;
-    isAnimatingRef.current = false;
-    isMomentumRef.current = false;
-    scheduleAutoplay();
-    flushQueuedSwipe();
-  };
-  const renderIndicator = () => {
-    if (indicator === false || count <= 1) return null;
-    if (typeof indicator === 'function') return indicator(count, currentIndex);
-    return /*#__PURE__*/React.createElement(SwiperPagIndicator, _extends({}, indicatorProps, {
-      total: count,
-      current: currentIndex,
-      vertical: vertical
-    }));
-  };
+    if (ndi !== di) scrollTo(ndi, false);
+    update(realIdx(ndi));
+    reset();
+  }, [vertical, count, mainSz, shouldLoop, dCount, scrollTo, update, realIdx, reset, isWeb]);
+  const onDragBegin = useCallback(() => {
+    interRef.current = true;
+    clearAuto();
+  }, [clearAuto]);
+  const onDragEnd = useCallback(e => {
+    if (!momRef.current) onEnd(e);
+  }, [onEnd]);
+  const onMomBegin = useCallback(() => {
+    momRef.current = true;
+  }, []);
+  const onFail = useCallback(info => {
+    scrollTo(info.index, false);
+    update(realIdx(info.index));
+    reset();
+  }, [scrollTo, update, realIdx, reset]);
+  const renderItemRef = useRef(renderItem);
+  renderItemRef.current = renderItem;
   const renderSlide = useCallback(info => {
-    const content = usingData ? renderItem?.(info) ?? null : info.item;
-    if (!content) return null;
-    return /*#__PURE__*/React.createElement(View, {
-      style: [styles.slide, itemStyle]
-    }, content);
-  }, [usingData, renderItem, itemStyle]);
+    const c = usingData ? renderItemRef.current?.(info) ?? null : info.item;
+    return c ? /*#__PURE__*/React.createElement(View, {
+      style: [S.slide, itemSz]
+    }, c) : null;
+  }, [usingData, itemSz]);
+  const getLayout = useCallback((_, i) => ({
+    length: mainSz,
+    offset: mainSz * i,
+    index: i
+  }), [mainSz]);
+  const keyEx = useCallback((_, i) => `s-${i}`, []);
   if (count === 0) return null;
-  return /*#__PURE__*/React.createElement(View, {
-    style: [styles.container, style],
-    onLayout: handleLayout,
+  const indNode = indicator === false || count <= 1 ? null : typeof indicator === 'function' ? indicator(count, curIdx) : /*#__PURE__*/React.createElement(SwiperPagIndicator, _extends({}, indicatorProps, {
+    total: count,
+    current: curIdx,
+    vertical: vertical
+  }));
+  const webMouse = isWeb && touchable && count > 1 ? {
+    onPointerDown: e => {
+      if (e.nativeEvent.pointerType !== 'mouse' || e.nativeEvent.button !== 0) return;
+      dragRef.current = vertical ? e.nativeEvent.pageY : e.nativeEvent.pageX;
+      interRef.current = true;
+      clearAuto();
+    },
+    onPointerUp: e => {
+      const s = dragRef.current;
+      dragRef.current = null;
+      if (s == null || e.nativeEvent.pointerType !== 'mouse') return;
+      const d = (vertical ? e.nativeEvent.pageY : e.nativeEvent.pageX) - s;
+      if (Math.abs(d) >= mainSz * 0.15) {
+        d < 0 ? next() : prev();
+      }
+      ;
+      interRef.current = false;
+      schedule();
+    },
+    onPointerLeave: () => {
+      if (dragRef.current != null) {
+        dragRef.current = null;
+        interRef.current = false;
+        schedule();
+      }
+    }
+  } : undefined;
+  return /*#__PURE__*/React.createElement(View, _extends({
+    accessibilityRole: "adjustable",
+    accessibilityLabel: `swiper, ${curIdx + 1} of ${count}`,
+    accessibilityValue: {
+      min: 0,
+      max: count - 1,
+      now: curIdx
+    },
+    style: [S.ctr, webMouse && S.web, style],
+    onLayout: onLayout,
     testID: testID
-  }, /*#__PURE__*/React.createElement(FlatList, {
-    ref: flatListRef,
-    data: displayData,
+  }, webMouse), /*#__PURE__*/React.createElement(FlatList, {
+    ref: listRef,
+    data: display,
     renderItem: renderSlide,
-    keyExtractor: (_item, index) => `swiper-${index}`,
+    keyExtractor: keyEx,
     horizontal: !vertical,
-    getItemLayout: (_, index) => ({
-      length: mainSize,
-      offset: mainSize * index,
-      index
-    }),
-    initialScrollIndex: layoutReady ? initialDisplayIndex : undefined,
+    getItemLayout: getLayout,
+    initialScrollIndex: ready ? initDisp : undefined,
     scrollEnabled: touchable && count > 1,
-    removeClippedSubviews: !shouldLoop || !loopRenderAll,
-    disableVirtualization: shouldLoop && loopRenderAll,
-    initialNumToRender: shouldLoop ? loopRenderAll ? displayCount : 3 : 3,
-    maxToRenderPerBatch: shouldLoop ? loopRenderAll ? displayCount : 3 : 3,
-    windowSize: shouldLoop ? loopRenderAll ? displayCount : 7 : 5,
+    removeClippedSubviews: !shouldLoop || !loopAll,
+    disableVirtualization: shouldLoop && loopAll,
+    initialNumToRender: shouldLoop ? loopAll ? dCount : 3 : 3,
+    maxToRenderPerBatch: shouldLoop ? loopAll ? dCount : 3 : 3,
+    windowSize: shouldLoop ? loopAll ? dCount : 7 : 5,
     pagingEnabled: true,
-    snapToInterval: mainSize,
+    snapToInterval: mainSz,
     decelerationRate: "fast",
     showsHorizontalScrollIndicator: false,
     showsVerticalScrollIndicator: false,
-    onScrollBeginDrag: handleScrollBeginDrag,
-    onScroll: handleScroll,
-    scrollEventThrottle: 16,
-    onScrollEndDrag: handleScrollEndDrag,
-    onMomentumScrollBegin: handleMomentumScrollBegin,
-    onMomentumScrollEnd: handleScrollEnd,
-    onScrollToIndexFailed: info => {
-      scrollToDisplayIndex(info.index, false);
-      isAnimatingRef.current = false;
-      isInteractingRef.current = false;
-      updateIndex(getRealIndex(info.index));
-      scheduleAutoplay();
-      flushQueuedSwipe();
-    }
+    onScrollBeginDrag: onDragBegin,
+    onScroll: onScroll,
+    scrollEventThrottle: tokens.defaults.scrollEventThrottle,
+    onScrollEndDrag: onDragEnd,
+    onMomentumScrollBegin: onMomBegin,
+    onMomentumScrollEnd: onEnd,
+    onScrollToIndexFailed: onFail
   }), /*#__PURE__*/React.createElement(View, {
     pointerEvents: "none",
-    style: styles.indicatorOverlay
-  }, renderIndicator()));
+    style: [S.ind, {
+      zIndex: tokens.layer.zIndex,
+      elevation: tokens.layer.elevation
+    }]
+  }, indNode));
 };
-const Swiper = /*#__PURE__*/forwardRef(SwiperImpl);
-Swiper.displayName = 'Swiper';
-const styles = StyleSheet.create({
-  container: {
+const SwiperFR = /*#__PURE__*/forwardRef(SwiperImpl);
+const Swiper = /*#__PURE__*/memo(SwiperFR);
+const S = StyleSheet.create({
+  ctr: {
     position: 'relative',
     overflow: 'hidden'
   },
+  web: {
+    cursor: 'grab',
+    userSelect: 'none'
+  },
   slide: {
     flex: 1
   },
   item: {
     flex: 1
   },
-  indicatorOverlay: {
+  ind: {
     position: 'absolute',
     left: 0,
     right: 0,
     top: 0,
-    bottom: 0,
-    zIndex: 10,
-    elevation: 10
+    bottom: 0
   }
 });
 export default Swiper;