react-native-tab-view 3.2.1 → 3.3.0

package/lib/module/TabBar.js

@@ -1,9 +1,8 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 import * as React from 'react';
 import { Animated, StyleSheet, View, I18nManager, Platform } from 'react-native';
 import TabBarItem from './TabBarItem';
 import TabBarIndicator from './TabBarIndicator';
+import useAnimatedValue from './useAnimatedValue';
 
 const Separator = _ref => {
   let {
@@ -16,359 +15,360 @@ const Separator = _ref => {
   });
 };
 
-export default class TabBar extends React.Component {
-  constructor() {
-    super(...arguments);
-
-    _defineProperty(this, "state", {
-      layout: {
-        width: 0,
-        height: 0
-      },
-      tabWidths: {}
-    });
-
-    _defineProperty(this, "measuredTabWidths", {});
+const getFlattenedTabWidth = style => {
+  const tabStyle = StyleSheet.flatten(style);
+  return tabStyle === null || tabStyle === void 0 ? void 0 : tabStyle.width;
+};
 
-    _defineProperty(this, "scrollAmount", new Animated.Value(0));
+const getComputedTabWidth = (index, layout, routes, scrollEnabled, tabWidths, flattenedWidth) => {
+  if (flattenedWidth === 'auto') {
+    return tabWidths[routes[index].key] || 0;
+  }
 
-    _defineProperty(this, "flatListRef", /*#__PURE__*/React.createRef());
+  switch (typeof flattenedWidth) {
+    case 'number':
+      return flattenedWidth;
 
-    _defineProperty(this, "getFlattenedTabWidth", style => {
-      const tabStyle = StyleSheet.flatten(style);
-      return tabStyle ? tabStyle.width : undefined;
-    });
+    case 'string':
+      if (flattenedWidth.endsWith('%')) {
+        const width = parseFloat(flattenedWidth);
 
-    _defineProperty(this, "getComputedTabWidth", (index, layout, routes, scrollEnabled, tabWidths, flattenedWidth) => {
-      if (flattenedWidth === 'auto') {
-        return tabWidths[routes[index].key] || 0;
+        if (Number.isFinite(width)) {
+          return layout.width * (width / 100);
+        }
       }
 
-      switch (typeof flattenedWidth) {
-        case 'number':
-          return flattenedWidth;
-
-        case 'string':
-          if (flattenedWidth.endsWith('%')) {
-            const width = parseFloat(flattenedWidth);
-
-            if (Number.isFinite(width)) {
-              return layout.width * (width / 100);
-            }
-          }
-
-      }
+  }
 
-      if (scrollEnabled) {
-        return layout.width / 5 * 2;
-      }
+  if (scrollEnabled) {
+    return layout.width / 5 * 2;
+  }
 
-      return layout.width / routes.length;
-    });
+  return layout.width / routes.length;
+};
 
-    _defineProperty(this, "getMaxScrollDistance", (tabBarWidth, layoutWidth) => tabBarWidth - layoutWidth);
+const getMaxScrollDistance = (tabBarWidth, layoutWidth) => tabBarWidth - layoutWidth;
 
-    _defineProperty(this, "getTabBarWidth", (props, state) => {
-      const {
-        layout,
-        tabWidths
-      } = state;
-      const {
-        scrollEnabled,
-        tabStyle
-      } = props;
-      const {
-        routes
-      } = props.navigationState;
-      return routes.reduce((acc, _, i) => acc + (i > 0 ? props.gap ?? 0 : 0) + this.getComputedTabWidth(i, layout, routes, scrollEnabled, tabWidths, this.getFlattenedTabWidth(tabStyle)), 0);
-    });
+const getTranslateX = (scrollAmount, maxScrollDistance) => Animated.multiply(Platform.OS === 'android' && I18nManager.isRTL ? Animated.add(maxScrollDistance, Animated.multiply(scrollAmount, -1)) : scrollAmount, I18nManager.isRTL ? 1 : -1);
 
-    _defineProperty(this, "normalizeScrollValue", (props, state, value) => {
-      const {
-        layout
-      } = state;
-      const tabBarWidth = this.getTabBarWidth(props, state);
-      const maxDistance = this.getMaxScrollDistance(tabBarWidth, layout.width);
-      const scrollValue = Math.max(Math.min(value, maxDistance), 0);
+const getTabBarWidth = _ref2 => {
+  let {
+    navigationState,
+    layout,
+    gap,
+    scrollEnabled,
+    flattenedTabWidth,
+    tabWidths
+  } = _ref2;
+  const {
+    routes
+  } = navigationState;
+  return routes.reduce((acc, _, i) => acc + (i > 0 ? gap ?? 0 : 0) + getComputedTabWidth(i, layout, routes, scrollEnabled, tabWidths, flattenedTabWidth), 0);
+};
 
-      if (Platform.OS === 'android' && I18nManager.isRTL) {
-        // On Android, scroll value is not applied in reverse in RTL
-        // so we need to manually adjust it to apply correct value
-        return maxDistance - scrollValue;
-      }
+const normalizeScrollValue = _ref3 => {
+  let {
+    layout,
+    navigationState,
+    gap,
+    scrollEnabled,
+    tabWidths,
+    value,
+    flattenedTabWidth
+  } = _ref3;
+  const tabBarWidth = getTabBarWidth({
+    layout,
+    navigationState,
+    tabWidths,
+    gap,
+    scrollEnabled,
+    flattenedTabWidth
+  });
+  const maxDistance = getMaxScrollDistance(tabBarWidth, layout.width);
+  const scrollValue = Math.max(Math.min(value, maxDistance), 0);
 
-      return scrollValue;
-    });
+  if (Platform.OS === 'android' && I18nManager.isRTL) {
+    // On Android, scroll value is not applied in reverse in RTL
+    // so we need to manually adjust it to apply correct value
+    return maxDistance - scrollValue;
+  }
 
-    _defineProperty(this, "getScrollAmount", (props, state, index) => {
-      const {
-        layout,
-        tabWidths
-      } = state;
-      const {
-        scrollEnabled,
-        tabStyle
-      } = props;
-      const {
-        routes
-      } = props.navigationState;
-      const centerDistance = Array.from({
-        length: index + 1
-      }).reduce((total, _, i) => {
-        const tabWidth = this.getComputedTabWidth(i, layout, routes, scrollEnabled, tabWidths, this.getFlattenedTabWidth(tabStyle)); // To get the current index centered we adjust scroll amount by width of indexes
-        // 0 through (i - 1) and add half the width of current index i
+  return scrollValue;
+};
 
-        return total + (index === i ? (tabWidth + (props.gap ?? 0)) / 2 : tabWidth + (props.gap ?? 0));
-      }, 0);
-      const scrollAmount = centerDistance - layout.width / 2;
-      return this.normalizeScrollValue(props, state, scrollAmount);
-    });
+const getScrollAmount = _ref4 => {
+  let {
+    layout,
+    navigationState,
+    gap,
+    scrollEnabled,
+    flattenedTabWidth,
+    tabWidths
+  } = _ref4;
+  const centerDistance = Array.from({
+    length: navigationState.index + 1
+  }).reduce((total, _, i) => {
+    const tabWidth = getComputedTabWidth(i, layout, navigationState.routes, scrollEnabled, tabWidths, flattenedTabWidth); // To get the current index centered we adjust scroll amount by width of indexes
+    // 0 through (i - 1) and add half the width of current index i
+
+    return total + (navigationState.index === i ? (tabWidth + (gap ?? 0)) / 2 : tabWidth + (gap ?? 0));
+  }, 0);
+  const scrollAmount = centerDistance - layout.width / 2;
+  return normalizeScrollValue({
+    layout,
+    navigationState,
+    tabWidths,
+    value: scrollAmount,
+    gap,
+    scrollEnabled,
+    flattenedTabWidth
+  });
+};
 
-    _defineProperty(this, "resetScroll", index => {
-      if (this.props.scrollEnabled) {
-        var _this$flatListRef$cur;
+const getLabelTextDefault = _ref5 => {
+  let {
+    route
+  } = _ref5;
+  return route.title;
+};
 
-        (_this$flatListRef$cur = this.flatListRef.current) === null || _this$flatListRef$cur === void 0 ? void 0 : _this$flatListRef$cur.scrollToOffset({
-          offset: this.getScrollAmount(this.props, this.state, index),
-          animated: true
-        });
-      }
-    });
+const getAccessibleDefault = _ref6 => {
+  let {
+    route
+  } = _ref6;
+  return typeof route.accessible !== 'undefined' ? route.accessible : true;
+};
 
-    _defineProperty(this, "handleLayout", e => {
-      const {
-        height,
-        width
-      } = e.nativeEvent.layout;
+const getAccessibilityLabelDefault = _ref7 => {
+  let {
+    route
+  } = _ref7;
+  return typeof route.accessibilityLabel === 'string' ? route.accessibilityLabel : typeof route.title === 'string' ? route.title : undefined;
+};
 
-      if (this.state.layout.width === width && this.state.layout.height === height) {
-        return;
-      }
+const renderIndicatorDefault = props => /*#__PURE__*/React.createElement(TabBarIndicator, props);
 
-      this.setState({
-        layout: {
-          height,
-          width
-        }
-      });
-    });
+const getTestIdDefault = _ref8 => {
+  let {
+    route
+  } = _ref8;
+  return route.testID;
+};
 
-    _defineProperty(this, "getTranslateX", (scrollAmount, maxScrollDistance) => Animated.multiply(Platform.OS === 'android' && I18nManager.isRTL ? Animated.add(maxScrollDistance, Animated.multiply(scrollAmount, -1)) : scrollAmount, I18nManager.isRTL ? 1 : -1));
-  }
+export default function TabBar(_ref9) {
+  let {
+    getLabelText = getLabelTextDefault,
+    getAccessible = getAccessibleDefault,
+    getAccessibilityLabel = getAccessibilityLabelDefault,
+    getTestID = getTestIdDefault,
+    renderIndicator = renderIndicatorDefault,
+    gap = 0,
+    scrollEnabled,
+    jumpTo,
+    navigationState,
+    position,
+    activeColor,
+    bounces,
+    contentContainerStyle,
+    inactiveColor,
+    indicatorContainerStyle,
+    indicatorStyle,
+    labelStyle,
+    onTabLongPress,
+    onTabPress,
+    pressColor,
+    pressOpacity,
+    renderBadge,
+    renderIcon,
+    renderLabel,
+    renderTabBarItem,
+    style,
+    tabStyle
+  } = _ref9;
+  const [layout, setLayout] = React.useState({
+    width: 0,
+    height: 0
+  });
+  const [tabWidths, setTabWidths] = React.useState({});
+  const flatListRef = React.useRef(null);
+  const isFirst = React.useRef(true);
+  const scrollAmount = useAnimatedValue(0);
+  const measuredTabWidths = React.useRef({});
+  const {
+    routes
+  } = navigationState;
+  const flattenedTabWidth = getFlattenedTabWidth(tabStyle);
+  const isWidthDynamic = flattenedTabWidth === 'auto';
+  const scrollOffset = getScrollAmount({
+    layout,
+    navigationState,
+    tabWidths,
+    gap,
+    scrollEnabled,
+    flattenedTabWidth
+  });
+  const hasMeasuredTabWidths = Boolean(layout.width) && routes.every(r => typeof tabWidths[r.key] === 'number');
+  React.useEffect(() => {
+    if (isFirst.current) {
+      isFirst.current = false;
+      return;
+    }
 
-  componentDidUpdate(prevProps, prevState) {
-    const {
-      navigationState
-    } = this.props;
-    const {
-      layout,
-      tabWidths
-    } = this.state;
+    if (isWidthDynamic && !hasMeasuredTabWidths) {
+      // When tab width is dynamic, only adjust the scroll once we have all tab widths and layout
+      return;
+    }
 
-    if (prevProps.navigationState.routes.length !== navigationState.routes.length || prevProps.navigationState.index !== navigationState.index || prevState.layout.width !== layout.width || prevState.tabWidths !== tabWidths) {
-      if (this.getFlattenedTabWidth(this.props.tabStyle) === 'auto' && !(layout.width && navigationState.routes.every(r => typeof tabWidths[r.key] === 'number'))) {
-        // When tab width is dynamic, only adjust the scroll once we have all tab widths and layout
-        return;
-      }
+    if (scrollEnabled) {
+      var _flatListRef$current;
 
-      this.resetScroll(navigationState.index);
+      (_flatListRef$current = flatListRef.current) === null || _flatListRef$current === void 0 ? void 0 : _flatListRef$current.scrollToOffset({
+        offset: scrollOffset,
+        animated: true
+      });
     }
-  } // to store the layout.width of each tab
-  // when all onLayout's are fired, this would be set in state
-
+  }, [hasMeasuredTabWidths, isWidthDynamic, scrollEnabled, scrollOffset]);
 
-  render() {
+  const handleLayout = e => {
     const {
-      position,
-      navigationState,
-      jumpTo,
-      scrollEnabled,
-      bounces,
-      getAccessibilityLabel,
-      getAccessible,
-      getLabelText,
-      getTestID,
-      renderBadge,
-      renderIcon,
-      renderLabel,
-      renderTabBarItem,
-      activeColor,
-      inactiveColor,
-      pressColor,
-      pressOpacity,
-      onTabPress,
-      onTabLongPress,
-      tabStyle,
-      labelStyle,
-      indicatorStyle,
-      contentContainerStyle,
-      style,
-      indicatorContainerStyle,
-      gap = 0
-    } = this.props;
-    const {
-      layout,
-      tabWidths
-    } = this.state;
-    const {
-      routes
-    } = navigationState;
-    const isWidthDynamic = this.getFlattenedTabWidth(tabStyle) === 'auto';
-    const tabBarWidth = this.getTabBarWidth(this.props, this.state);
-    const separatorsWidth = Math.max(0, routes.length - 1) * gap;
-    const separatorPercent = separatorsWidth / tabBarWidth * 100;
-    const tabBarWidthPercent = `${routes.length * 40}%`;
-    const translateX = this.getTranslateX(this.scrollAmount, this.getMaxScrollDistance(tabBarWidth, layout.width));
-    return /*#__PURE__*/React.createElement(Animated.View, {
-      onLayout: this.handleLayout,
-      style: [styles.tabBar, style]
-    }, /*#__PURE__*/React.createElement(Animated.View, {
-      pointerEvents: "none",
-      style: [styles.indicatorContainer, scrollEnabled ? {
-        transform: [{
-          translateX
-        }]
-      } : null, tabBarWidth > separatorsWidth ? {
-        width: tabBarWidth - separatorsWidth
-      } : scrollEnabled ? {
-        width: tabBarWidthPercent
-      } : null, indicatorContainerStyle]
-    }, this.props.renderIndicator({
-      position,
-      layout,
-      navigationState,
-      jumpTo,
-      width: isWidthDynamic ? 'auto' : `${(100 - separatorPercent) / routes.length}%`,
-      style: indicatorStyle,
-      getTabWidth: i => this.getComputedTabWidth(i, layout, routes, scrollEnabled, tabWidths, this.getFlattenedTabWidth(tabStyle)),
-      gap
-    })), /*#__PURE__*/React.createElement(View, {
-      style: styles.scroll
-    }, /*#__PURE__*/React.createElement(Animated.FlatList, {
-      data: routes,
-      keyExtractor: item => item.key,
-      horizontal: true,
-      accessibilityRole: "tablist",
-      keyboardShouldPersistTaps: "handled",
-      scrollEnabled: scrollEnabled,
-      bounces: bounces,
-      alwaysBounceHorizontal: false,
-      scrollsToTop: false,
-      showsHorizontalScrollIndicator: false,
-      showsVerticalScrollIndicator: false,
-      automaticallyAdjustContentInsets: false,
-      overScrollMode: "never",
-      contentContainerStyle: [styles.tabContent, scrollEnabled ? {
-        width: tabBarWidth > separatorsWidth ? tabBarWidth : tabBarWidthPercent
-      } : styles.container, contentContainerStyle],
-      scrollEventThrottle: 16,
-      renderItem: _ref2 => {
-        let {
-          item: route,
-          index
-        } = _ref2;
-        const props = {
-          key: route.key,
-          position: position,
-          route: route,
-          navigationState: navigationState,
-          getAccessibilityLabel: getAccessibilityLabel,
-          getAccessible: getAccessible,
-          getLabelText: getLabelText,
-          getTestID: getTestID,
-          renderBadge: renderBadge,
-          renderIcon: renderIcon,
-          renderLabel: renderLabel,
-          activeColor: activeColor,
-          inactiveColor: inactiveColor,
-          pressColor: pressColor,
-          pressOpacity: pressOpacity,
-          onLayout: isWidthDynamic ? e => {
-            this.measuredTabWidths[route.key] = e.nativeEvent.layout.width; // When we have measured widths for all of the tabs, we should updates the state
-            // We avoid doing separate setState for each layout since it triggers multiple renders and slows down app
-
-            if (routes.every(r => typeof this.measuredTabWidths[r.key] === 'number')) {
-              this.setState({
-                tabWidths: { ...this.measuredTabWidths
-                }
-              });
-            }
-          } : undefined,
-          onPress: () => {
-            const event = {
-              route,
-              defaultPrevented: false,
-              preventDefault: () => {
-                event.defaultPrevented = true;
-              }
-            };
-            onTabPress === null || onTabPress === void 0 ? void 0 : onTabPress(event);
+      height,
+      width
+    } = e.nativeEvent.layout;
+    setLayout(layout => layout.width === width && layout.height === height ? layout : {
+      width,
+      height
+    });
+  };
+
+  const tabBarWidth = getTabBarWidth({
+    layout,
+    navigationState,
+    tabWidths,
+    gap,
+    scrollEnabled,
+    flattenedTabWidth
+  });
+  const separatorsWidth = Math.max(0, routes.length - 1) * gap;
+  const separatorPercent = separatorsWidth / tabBarWidth * 100;
+  const tabBarWidthPercent = `${routes.length * 40}%`;
+  const translateX = React.useMemo(() => getTranslateX(scrollAmount, getMaxScrollDistance(tabBarWidth, layout.width)), [layout.width, scrollAmount, tabBarWidth]);
+  const renderItem = React.useCallback(_ref10 => {
+    let {
+      item: route,
+      index
+    } = _ref10;
+    const props = {
+      key: route.key,
+      position: position,
+      route: route,
+      navigationState: navigationState,
+      getAccessibilityLabel: getAccessibilityLabel,
+      getAccessible: getAccessible,
+      getLabelText: getLabelText,
+      getTestID: getTestID,
+      renderBadge: renderBadge,
+      renderIcon: renderIcon,
+      renderLabel: renderLabel,
+      activeColor: activeColor,
+      inactiveColor: inactiveColor,
+      pressColor: pressColor,
+      pressOpacity: pressOpacity,
+      onLayout: isWidthDynamic ? e => {
+        measuredTabWidths.current[route.key] = e.nativeEvent.layout.width; // When we have measured widths for all of the tabs, we should updates the state
+        // We avoid doing separate setState for each layout since it triggers multiple renders and slows down app
+
+        if (routes.every(r => typeof measuredTabWidths.current[r.key] === 'number')) {
+          setTabWidths({ ...measuredTabWidths.current
+          });
+        }
+      } : undefined,
+      onPress: () => {
+        const event = {
+          route,
+          defaultPrevented: false,
+          preventDefault: () => {
+            event.defaultPrevented = true;
+          }
+        };
+        onTabPress === null || onTabPress === void 0 ? void 0 : onTabPress(event);
 
-            if (event.defaultPrevented) {
-              return;
-            }
+        if (event.defaultPrevented) {
+          return;
+        }
 
-            this.props.jumpTo(route.key);
-          },
-          onLongPress: () => onTabLongPress === null || onTabLongPress === void 0 ? void 0 : onTabLongPress({
-            route
-          }),
-          labelStyle: labelStyle,
-          style: [tabStyle, // Calculate the deafult width for tab for FlatList to work.
-          this.getFlattenedTabWidth(tabStyle) === undefined && {
-            width: this.getComputedTabWidth(index, layout, routes, scrollEnabled, tabWidths, this.getFlattenedTabWidth(tabStyle))
-          }]
-        };
-        return /*#__PURE__*/React.createElement(React.Fragment, {
-          key: route.key
-        }, gap > 0 && index > 0 ? /*#__PURE__*/React.createElement(Separator, {
-          width: gap
-        }) : null, renderTabBarItem ? renderTabBarItem(props) : /*#__PURE__*/React.createElement(TabBarItem, props));
+        jumpTo(route.key);
       },
-      onScroll: Animated.event([{
-        nativeEvent: {
-          contentOffset: {
-            x: this.scrollAmount
-          }
-        }
-      }], {
-        useNativeDriver: true
+      onLongPress: () => onTabLongPress === null || onTabLongPress === void 0 ? void 0 : onTabLongPress({
+        route
       }),
-      ref: this.flatListRef
-    })));
-  }
-
+      labelStyle: labelStyle,
+      style: tabStyle,
+      // Calculate the deafult width for tab for FlatList to work
+      defaultTabWidth: !isWidthDynamic ? getComputedTabWidth(index, layout, routes, scrollEnabled, tabWidths, getFlattenedTabWidth(tabStyle)) : undefined
+    };
+    return /*#__PURE__*/React.createElement(React.Fragment, null, gap > 0 && index > 0 ? /*#__PURE__*/React.createElement(Separator, {
+      width: gap
+    }) : null, renderTabBarItem ? renderTabBarItem(props) : /*#__PURE__*/React.createElement(TabBarItem, props));
+  }, [activeColor, gap, getAccessibilityLabel, getAccessible, getLabelText, getTestID, inactiveColor, isWidthDynamic, jumpTo, labelStyle, layout, navigationState, onTabLongPress, onTabPress, position, pressColor, pressOpacity, renderBadge, renderIcon, renderLabel, renderTabBarItem, routes, scrollEnabled, tabStyle, tabWidths]);
+  const keyExtractor = React.useCallback(item => item.key, []);
+  const contentContainerStyleMemoized = React.useMemo(() => [styles.tabContent, scrollEnabled ? {
+    width: tabBarWidth > separatorsWidth ? tabBarWidth : tabBarWidthPercent
+  } : styles.container, contentContainerStyle], [contentContainerStyle, scrollEnabled, separatorsWidth, tabBarWidth, tabBarWidthPercent]);
+  const handleScroll = React.useMemo(() => Animated.event([{
+    nativeEvent: {
+      contentOffset: {
+        x: scrollAmount
+      }
+    }
+  }], {
+    useNativeDriver: true
+  }), [scrollAmount]);
+  return /*#__PURE__*/React.createElement(Animated.View, {
+    onLayout: handleLayout,
+    style: [styles.tabBar, style]
+  }, /*#__PURE__*/React.createElement(Animated.View, {
+    pointerEvents: "none",
+    style: [styles.indicatorContainer, scrollEnabled ? {
+      transform: [{
+        translateX
+      }]
+    } : null, tabBarWidth > separatorsWidth ? {
+      width: tabBarWidth - separatorsWidth
+    } : scrollEnabled ? {
+      width: tabBarWidthPercent
+    } : null, indicatorContainerStyle]
+  }, renderIndicator({
+    position,
+    layout,
+    navigationState,
+    jumpTo,
+    width: isWidthDynamic ? 'auto' : `${(100 - separatorPercent) / routes.length}%`,
+    style: indicatorStyle,
+    getTabWidth: i => getComputedTabWidth(i, layout, routes, scrollEnabled, tabWidths, flattenedTabWidth),
+    gap
+  })), /*#__PURE__*/React.createElement(View, {
+    style: styles.scroll
+  }, /*#__PURE__*/React.createElement(Animated.FlatList, {
+    data: routes,
+    keyExtractor: keyExtractor,
+    horizontal: true,
+    accessibilityRole: "tablist",
+    keyboardShouldPersistTaps: "handled",
+    scrollEnabled: scrollEnabled,
+    bounces: bounces,
+    alwaysBounceHorizontal: false,
+    scrollsToTop: false,
+    showsHorizontalScrollIndicator: false,
+    showsVerticalScrollIndicator: false,
+    automaticallyAdjustContentInsets: false,
+    overScrollMode: "never",
+    contentContainerStyle: contentContainerStyleMemoized,
+    scrollEventThrottle: 16,
+    renderItem: renderItem,
+    onScroll: handleScroll,
+    ref: flatListRef
+  })));
 }
-
-_defineProperty(TabBar, "defaultProps", {
-  getLabelText: _ref3 => {
-    let {
-      route
-    } = _ref3;
-    return route.title;
-  },
-  getAccessible: _ref4 => {
-    let {
-      route
-    } = _ref4;
-    return typeof route.accessible !== 'undefined' ? route.accessible : true;
-  },
-  getAccessibilityLabel: _ref5 => {
-    let {
-      route
-    } = _ref5;
-    return typeof route.accessibilityLabel === 'string' ? route.accessibilityLabel : typeof route.title === 'string' ? route.title : undefined;
-  },
-  getTestID: _ref6 => {
-    let {
-      route
-    } = _ref6;
-    return route.testID;
-  },
-  renderIndicator: props => /*#__PURE__*/React.createElement(TabBarIndicator, props),
-  gap: 0
-});
-
 const styles = StyleSheet.create({
   container: {
     flex: 1