react-native-system-ui 0.0.5 → 0.0.7

package/dist/es/components/index-bar/IndexBar.js

@@ -1,417 +0,0 @@
-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, { useCallback, useEffect, useImperativeHandle, useRef, useState } from 'react';
-import { Pressable, ScrollView, StyleSheet, Text, View } from 'react-native';
-import { useControllableValue } from '../../hooks';
-import { isFiniteNumber, isUndefined } from '../../utils/validate';
-import { SafeAreaView } from '../safe-area-view';
-import { useIndexBarTokens } from './tokens';
-const IndexBarBase = /*#__PURE__*/React.forwardRef((props, ref) => {
-  const {
-    children,
-    value,
-    defaultValue,
-    highlightColor,
-    zIndex = 1,
-    sticky = true,
-    stickyOffsetTop = 0,
-    indexList,
-    itemRender,
-    showIndicator = true,
-    indicatorStyle,
-    indexTextStyle,
-    safeAreaInsetTop = false,
-    tokensOverride,
-    onChange,
-    onSelect,
-    style,
-    ...rest
-  } = props;
-  const {
-    colors,
-    layout,
-    typography
-  } = useIndexBarTokens(tokensOverride);
-  const scrollRef = useRef(null);
-  const scrollYRef = useRef(0);
-  const anchorLayouts = useRef(new Map());
-  const anchorOffsetsRef = useRef([]);
-  const indexListHeightRef = useRef(0);
-  const navItemLayoutsRef = useRef(new Map());
-  const navItemOffsetsRef = useRef([]);
-  const draggingIndexRef = useRef(null);
-  const pendingScrollToValueRef = useRef(null);
-  const [interactionIndex, setInteractionIndex] = useState(null);
-  const [stickyVisible, setStickyVisible] = useState(false);
-  const [indicator, setIndicator] = useState({
-    visible: false
-  });
-  const anchors = React.Children.toArray(children).filter(React.isValidElement);
-  const navItems = indexList?.length ? indexList : anchors.map(anchor => anchor.props.index);
-  const firstIndex = navItems[0];
-  const [activeIndex, setActiveIndex] = useControllableValue(props, {
-    defaultValue: isUndefined(firstIndex) ? anchors[0]?.props.index : firstIndex,
-    valuePropName: 'value',
-    defaultValuePropName: 'defaultValue',
-    trigger: 'onChange'
-  });
-  const currentIndex = activeIndex === undefined || activeIndex === null || !navItems.includes(activeIndex) ? firstIndex : activeIndex;
-  const displayIndex = interactionIndex ?? currentIndex;
-  const showIndicatorNow = useCallback(label => {
-    if (!showIndicator) return;
-    setIndicator({
-      visible: true,
-      label
-    });
-  }, [showIndicator]);
-  const hideIndicatorNow = useCallback(() => {
-    if (!showIndicator) return;
-    setIndicator(prev => prev.visible ? {
-      visible: false
-    } : prev);
-  }, [showIndicator]);
-  const scrollToAnchor = useCallback((index, animated) => {
-    const y = anchorLayouts.current.get(index);
-    if (y === undefined) {
-      pendingScrollToValueRef.current = index;
-      return;
-    }
-    scrollRef.current?.scrollTo({
-      y: Math.max(0, y - stickyOffsetTop),
-      animated
-    });
-  }, [stickyOffsetTop]);
-  const handleAnchorLayout = useCallback((index, layoutY) => {
-    anchorLayouts.current.set(index, layoutY);
-    anchorOffsetsRef.current = Array.from(anchorLayouts.current.entries()).map(([key, y]) => ({
-      index: key,
-      y
-    })).sort((a, b) => a.y - b.y);
-    const pending = pendingScrollToValueRef.current;
-    if (pending === null) return;
-    const y = anchorLayouts.current.get(pending);
-    if (y === undefined) return;
-    pendingScrollToValueRef.current = null;
-    scrollRef.current?.scrollTo({
-      y: Math.max(0, y - stickyOffsetTop),
-      animated: false
-    });
-  }, [stickyOffsetTop]);
-  const scrollToIndex = useCallback((index, animated = true) => {
-    scrollToAnchor(index, animated);
-    setActiveIndex(index);
-  }, [scrollToAnchor, setActiveIndex]);
-  useImperativeHandle(ref, () => ({
-    scrollTo: index => scrollToIndex(index, true)
-  }), [scrollToIndex]);
-  const handleScroll = useCallback(event => {
-    const offsetY = event?.nativeEvent?.contentOffset?.y ?? 0;
-    scrollYRef.current = offsetY;
-    const threshold = sticky ? stickyOffsetTop : 0;
-    let nextIndex = currentIndex;
-    const entries = anchorOffsetsRef.current;
-    const targetY = offsetY + threshold + 1;
-    let low = 0;
-    let high = entries.length - 1;
-    let found = null;
-    while (low <= high) {
-      const mid = Math.floor((low + high) / 2);
-      const entry = entries[mid];
-      if (entry && entry.y <= targetY) {
-        found = entry.index;
-        low = mid + 1;
-      } else {
-        high = mid - 1;
-      }
-    }
-    if (found !== null) {
-      nextIndex = found;
-    }
-    if (nextIndex !== undefined && nextIndex !== null && nextIndex !== currentIndex) {
-      setActiveIndex(nextIndex);
-    }
-    if (sticky && nextIndex !== undefined && nextIndex !== null) {
-      const y = anchorLayouts.current.get(nextIndex);
-      const nextStickyVisible = y !== undefined && offsetY > Math.max(0, y - stickyOffsetTop);
-      setStickyVisible(prev => prev === nextStickyVisible ? prev : nextStickyVisible);
-    } else {
-      setStickyVisible(prev => prev ? false : prev);
-    }
-  }, [currentIndex, setActiveIndex, sticky, stickyOffsetTop]);
-  useEffect(() => {
-    const valid = new Set(anchors.map(anchor => anchor.props.index));
-    Array.from(anchorLayouts.current.keys()).forEach(key => {
-      if (!valid.has(key)) {
-        anchorLayouts.current.delete(key);
-      }
-    });
-    anchorOffsetsRef.current = Array.from(anchorLayouts.current.entries()).map(([key, y]) => ({
-      index: key,
-      y
-    })).sort((a, b) => a.y - b.y);
-  }, [anchors]);
-  useEffect(() => {
-    const valid = new Set(navItems);
-    Array.from(navItemLayoutsRef.current.keys()).forEach(key => {
-      if (!valid.has(key)) {
-        navItemLayoutsRef.current.delete(key);
-      }
-    });
-    navItemOffsetsRef.current = Array.from(navItemLayoutsRef.current.entries()).map(([key, layoutItem]) => ({
-      index: key,
-      y: layoutItem.y,
-      height: layoutItem.height
-    })).sort((a, b) => a.y - b.y);
-  }, [navItems]);
-  useEffect(() => {
-    if (interactionIndex == null) return;
-    if (!navItems.includes(interactionIndex)) {
-      setInteractionIndex(null);
-    }
-  }, [interactionIndex, navItems]);
-  useEffect(() => {
-    if (value === undefined || value === null) return;
-    const y = anchorLayouts.current.get(value);
-    if (y === undefined) {
-      pendingScrollToValueRef.current = value;
-      return;
-    }
-    const targetY = Math.max(0, y - stickyOffsetTop);
-    if (Math.abs(targetY - scrollYRef.current) < 1) return;
-    scrollRef.current?.scrollTo({
-      y: targetY,
-      animated: true
-    });
-  }, [stickyOffsetTop, value]);
-  const selectIndex = useCallback((index, animated) => {
-    showIndicatorNow(String(index));
-    onSelect?.(index);
-    scrollToIndex(index, animated);
-  }, [onSelect, scrollToIndex, showIndicatorNow]);
-  const handlePressIn = useCallback(index => {
-    setInteractionIndex(index);
-    selectIndex(index, true);
-  }, [selectIndex]);
-  const handlePressOut = useCallback(() => {
-    hideIndicatorNow();
-    setInteractionIndex(null);
-  }, [hideIndicatorNow]);
-  const handleIndexItemLayout = useCallback((index, event) => {
-    const {
-      y,
-      height
-    } = event.nativeEvent.layout;
-    navItemLayoutsRef.current.set(index, {
-      y,
-      height
-    });
-    navItemOffsetsRef.current = Array.from(navItemLayoutsRef.current.entries()).map(([key, layoutItem]) => ({
-      index: key,
-      y: layoutItem.y,
-      height: layoutItem.height
-    })).sort((a, b) => a.y - b.y);
-  }, []);
-  if (anchors.length === 0) {
-    return null;
-  }
-  const highlight = highlightColor ?? colors.activeText;
-  const activeAnchor = anchors.find(anchor => anchor.props.index === displayIndex);
-  const stickyNode = sticky && stickyVisible && activeAnchor ? /*#__PURE__*/React.createElement(View, {
-    style: [styles.sticky, {
-      backgroundColor: colors.stickyBackground,
-      height: layout.stickyHeight,
-      paddingHorizontal: layout.stickyPaddingHorizontal
-    }]
-  }, /*#__PURE__*/React.createElement(Text, {
-    style: [styles.stickyText, {
-      color: highlight,
-      fontSize: typography.stickyTextSize
-    }]
-  }, activeAnchor.props.title ?? activeAnchor.props.index)) : null;
-  const indicatorSize = layout.indicatorSize;
-  const indicatorNode = !showIndicator || !indicator.visible ? null : /*#__PURE__*/React.createElement(View, {
-    style: [styles.indicator, {
-      width: indicatorSize,
-      height: indicatorSize,
-      borderRadius: indicatorSize / 2,
-      backgroundColor: colors.indicatorBackground,
-      zIndex,
-      transform: [{
-        translateX: -indicatorSize / 2
-      }, {
-        translateY: -indicatorSize / 2
-      }]
-    }, indicatorStyle]
-  }, /*#__PURE__*/React.createElement(Text, {
-    style: [styles.indicatorText, {
-      color: colors.indicatorText,
-      fontSize: typography.indicatorTextSize
-    }]
-  }, indicator.label));
-  const pickIndexFromEvent = useCallback(evt => {
-    if (!navItems.length) return null;
-    const locationY = evt?.nativeEvent?.locationY;
-    if (!isFiniteNumber(locationY)) return null;
-    const entries = navItemOffsetsRef.current;
-    if (entries.length) {
-      let picked = null;
-      let minDistance = Number.POSITIVE_INFINITY;
-      entries.forEach(entry => {
-        if (entry.height <= 0) return;
-        const center = entry.y + entry.height / 2;
-        const distance = Math.abs(locationY - center);
-        if (distance < minDistance) {
-          minDistance = distance;
-          picked = entry.index;
-        }
-      });
-      return picked;
-    }
-    const height = indexListHeightRef.current;
-    if (!height) return null;
-    const paddingY = layout.paddingVertical;
-    const contentHeight = Math.max(0, height - paddingY * 2);
-    const itemHeight = contentHeight / navItems.length;
-    if (itemHeight <= 0) return null;
-    const y = locationY - paddingY;
-    const idx = Math.max(0, Math.min(navItems.length - 1, Math.floor(y / itemHeight)));
-    return navItems[idx] || null;
-  }, [layout.paddingVertical, navItems]);
-  const shouldHandleResponder = useCallback(evt => {
-    if (!navItems.length) return false;
-    const locationY = evt?.nativeEvent?.locationY;
-    if (!isFiniteNumber(locationY)) return false;
-    if (navItemOffsetsRef.current.length) return true;
-    return indexListHeightRef.current > 0;
-  }, [navItems.length]);
-  const handleResponderGrant = useCallback(evt => {
-    const picked = pickIndexFromEvent(evt);
-    draggingIndexRef.current = picked;
-    if (picked !== null) {
-      setInteractionIndex(picked);
-      selectIndex(picked, true);
-    }
-  }, [pickIndexFromEvent, selectIndex]);
-  const handleResponderMove = useCallback(evt => {
-    const picked = pickIndexFromEvent(evt);
-    if (picked === null) return;
-    if (picked === draggingIndexRef.current) return;
-    draggingIndexRef.current = picked;
-    setInteractionIndex(picked);
-    selectIndex(picked, false);
-  }, [pickIndexFromEvent, selectIndex]);
-  const handleResponderRelease = useCallback(() => {
-    draggingIndexRef.current = null;
-    hideIndicatorNow();
-    setInteractionIndex(null);
-  }, [hideIndicatorNow]);
-  const StickyWrapper = safeAreaInsetTop ? SafeAreaView : View;
-  const stickyWrapperStyle = [styles.stickyWrapper, {
-    top: stickyOffsetTop,
-    zIndex
-  }];
-  const handleIndexListLayout = useCallback(e => {
-    const {
-      height
-    } = e.nativeEvent.layout;
-    indexListHeightRef.current = height;
-  }, []);
-  const anchorNodes = anchors.map(anchor => /*#__PURE__*/React.cloneElement(anchor, {
-    key: anchor.key ?? anchor.props.index,
-    active: anchor.props.index === displayIndex,
-    highlightColor: highlight,
-    onLayoutCapture: handleAnchorLayout
-  }));
-  return /*#__PURE__*/React.createElement(View, _extends({}, rest, {
-    style: [styles.container, style]
-  }), /*#__PURE__*/React.createElement(ScrollView, {
-    ref: scrollRef,
-    onScroll: handleScroll,
-    scrollEventThrottle: 16,
-    showsVerticalScrollIndicator: false
-  }, anchorNodes), sticky && stickyVisible && stickyNode && /*#__PURE__*/React.createElement(StickyWrapper, {
-    style: stickyWrapperStyle
-  }, stickyNode), /*#__PURE__*/React.createElement(View, {
-    testID: "rv-indexbar-nav-list",
-    style: [styles.indexList, {
-      width: layout.indexWidth,
-      paddingVertical: layout.paddingVertical,
-      paddingHorizontal: layout.indexListPaddingHorizontal,
-      zIndex
-    }],
-    onLayout: handleIndexListLayout,
-    onStartShouldSetResponder: () => false,
-    onMoveShouldSetResponder: evt => shouldHandleResponder(evt),
-    onStartShouldSetResponderCapture: () => false,
-    onMoveShouldSetResponderCapture: evt => shouldHandleResponder(evt),
-    onResponderGrant: handleResponderGrant,
-    onResponderStart: handleResponderGrant,
-    onResponderMove: handleResponderMove,
-    onResponderRelease: handleResponderRelease,
-    onResponderTerminate: handleResponderRelease
-  }, navItems.map(item => {
-    const isActive = item === displayIndex;
-    const node = itemRender?.(item, isActive);
-    return /*#__PURE__*/React.createElement(Pressable, {
-      key: String(item),
-      testID: `rv-indexbar-nav-${String(item)}`,
-      style: [styles.indexItem, {
-        paddingVertical: layout.indexItemPaddingVertical,
-        paddingHorizontal: layout.indexItemPaddingHorizontal
-      }],
-      hitSlop: layout.spacing,
-      onLayout: event => handleIndexItemLayout(item, event),
-      onPress: () => handlePressIn(item),
-      onPressIn: () => handlePressIn(item),
-      onPressOut: handlePressOut
-    }, node ?? /*#__PURE__*/React.createElement(Text, {
-      style: [styles.indexText, {
-        color: isActive ? highlight : colors.text,
-        fontSize: typography.indexTextSize
-      }, indexTextStyle]
-    }, String(item)));
-  })), indicatorNode);
-});
-const styles = StyleSheet.create({
-  container: {
-    flex: 1
-  },
-  indexList: {
-    position: 'absolute',
-    right: 0,
-    top: 0,
-    bottom: 0,
-    justifyContent: 'center',
-    alignItems: 'center'
-  },
-  indexItem: {
-    width: '100%',
-    alignItems: 'center',
-    justifyContent: 'center'
-  },
-  indexText: {},
-  indicator: {
-    position: 'absolute',
-    left: '50%',
-    top: '50%',
-    alignItems: 'center',
-    justifyContent: 'center',
-    pointerEvents: 'none'
-  },
-  indicatorText: {
-    fontWeight: '600'
-  },
-  stickyWrapper: {
-    position: 'absolute',
-    top: 0,
-    left: 0,
-    right: 0
-  },
-  sticky: {
-    justifyContent: 'center'
-  },
-  stickyText: {
-    fontWeight: '600'
-  }
-});
-IndexBarBase.displayName = 'IndexBar';
-export default IndexBarBase;

package/dist/es/components/index-bar/index.js

@@ -1,7 +0,0 @@
-import IndexBarBase from './IndexBar';
-import IndexAnchor from './IndexAnchor';
-export { useIndexBarTokens } from './tokens';
-const IndexBar = IndexBarBase;
-IndexBar.Anchor = IndexAnchor;
-export { IndexAnchor };
-export default IndexBar;

package/dist/es/components/index-bar/tokens.js

@@ -1,39 +0,0 @@
-import { createComponentTokensHook } from '../../design-system';
-const createTokens = foundations => {
-  const {
-    palette,
-    fontSize,
-    spacing
-  } = foundations;
-  return {
-    colors: {
-      text: palette.default[600],
-      activeText: palette.primary[600],
-      indicatorBackground: palette.primary[500],
-      indicatorText: palette.primary.foreground ?? '#ffffff',
-      stickyBackground: palette.default[50],
-      anchorBackground: palette.default[50],
-      anchorText: palette.default[800]
-    },
-    layout: {
-      indexWidth: 28,
-      paddingVertical: spacing.sm,
-      indexListPaddingHorizontal: spacing.xxs,
-      indexItemPaddingVertical: spacing.xxs,
-      indexItemPaddingHorizontal: spacing.xxs,
-      spacing: spacing.xs,
-      indicatorSize: 48,
-      stickyHeight: 32,
-      stickyPaddingHorizontal: spacing.md,
-      anchorHeight: 32,
-      anchorPaddingHorizontal: spacing.md
-    },
-    typography: {
-      indexTextSize: fontSize.xs,
-      indicatorTextSize: fontSize.lg,
-      stickyTextSize: fontSize.md,
-      anchorTitleSize: fontSize.sm
-    }
-  };
-};
-export const useIndexBarTokens = createComponentTokensHook('indexBar', createTokens);

package/dist/es/components/list/List.js

@@ -1,145 +0,0 @@
-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, { useCallback, useEffect, useImperativeHandle, useRef, useState } from 'react';
-import { Pressable, ScrollView, Text, View } from 'react-native';
-import { isFunction, isRenderable, isText, isUndefined } from '../../utils/validate';
-import { useLocale } from '../config-provider/useLocale';
-import Loading from '../loading';
-import { useListTokens } from './tokens';
-const List = /*#__PURE__*/React.forwardRef((props, ref) => {
-  const locale = useLocale();
-  const {
-    onLoad,
-    loading,
-    error,
-    finished: finishedProp,
-    offset: offsetProp,
-    immediateCheck: immediateCheckProp,
-    loadingText: loadingTextProp,
-    finishedText,
-    errorText,
-    children,
-    contentContainerStyle,
-    tokensOverride,
-    onScroll,
-    onContentSizeChange,
-    onLayout,
-    scrollEventThrottle: scrollEventThrottleProp,
-    ScrollComponent = ScrollView,
-    ...scrollProps
-  } = props;
-  const tokens = useListTokens(tokensOverride);
-  const finished = finishedProp ?? tokens.defaults.finished;
-  const offset = offsetProp ?? tokens.defaults.offset;
-  const immediateCheck = immediateCheckProp ?? tokens.defaults.immediateCheck;
-  const horizontal = !!scrollProps.horizontal;
-  const loadingText = isUndefined(loadingTextProp) ? locale.loading : loadingTextProp;
-  const loadingControlled = !isUndefined(loading);
-  const errorControlled = !isUndefined(error);
-  const [innerLoading, setInnerLoading] = useState(false);
-  const [innerError, setInnerError] = useState(false);
-  const mergedLoading = loadingControlled ? !!loading : innerLoading;
-  const mergedError = errorControlled ? !!error : innerError;
-  const loadingRef = useRef(false);
-  const mergedLoadingRef = useRef(mergedLoading);
-  const mergedErrorRef = useRef(mergedError);
-  const containerMainSizeRef = useRef(0);
-  const contentMainSizeRef = useRef(0);
-  useEffect(() => {
-    mergedLoadingRef.current = mergedLoading;
-    mergedErrorRef.current = mergedError;
-  }, [mergedLoading, mergedError]);
-  const triggerLoad = useCallback(async isRetry => {
-    if (!onLoad || finished) return;
-    if (loadingRef.current || mergedLoadingRef.current) return;
-    if (mergedErrorRef.current && !isRetry) return;
-    loadingRef.current = true;
-    if (!loadingControlled) setInnerLoading(true);
-    if (!errorControlled) setInnerError(false);
-    try {
-      await Promise.resolve(onLoad(isRetry));
-    } catch {
-      if (!errorControlled) setInnerError(true);
-    } finally {
-      loadingRef.current = false;
-      if (!loadingControlled) setInnerLoading(false);
-    }
-  }, [errorControlled, finished, loadingControlled, onLoad]);
-  const check = useCallback(() => {
-    if (mergedLoadingRef.current || mergedErrorRef.current) return;
-    if (!containerMainSizeRef.current) return;
-    if (contentMainSizeRef.current <= containerMainSizeRef.current && !finished) {
-      triggerLoad(false);
-    }
-  }, [finished, triggerLoad]);
-  useImperativeHandle(ref, () => ({
-    check
-  }), [check]);
-  const handleScroll = useCallback(event => {
-    onScroll?.(event);
-    const {
-      layoutMeasurement,
-      contentOffset,
-      contentSize
-    } = event.nativeEvent;
-    const distance = horizontal ? contentSize.width - (layoutMeasurement.width + contentOffset.x) : contentSize.height - (layoutMeasurement.height + contentOffset.y);
-    if (distance <= offset) triggerLoad(false);
-  }, [horizontal, offset, onScroll, triggerLoad]);
-  const handleContentSizeChange = useCallback((width, height) => {
-    onContentSizeChange?.(width, height);
-    contentMainSizeRef.current = horizontal ? width : height;
-    if (immediateCheck) check();
-  }, [check, horizontal, immediateCheck, onContentSizeChange]);
-  const handleLayout = useCallback(event => {
-    onLayout?.(event);
-    const {
-      layout
-    } = event.nativeEvent;
-    containerMainSizeRef.current = horizontal ? layout.width : layout.height;
-    if (immediateCheck) check();
-  }, [check, horizontal, immediateCheck, onLayout]);
-  const retry = () => triggerLoad(true);
-  return /*#__PURE__*/React.createElement(ScrollComponent, _extends({}, scrollProps, {
-    onScroll: handleScroll,
-    scrollEventThrottle: scrollEventThrottleProp ?? tokens.defaults.scrollEventThrottle,
-    contentContainerStyle: contentContainerStyle,
-    onContentSizeChange: handleContentSizeChange,
-    onLayout: handleLayout
-  }), children, /*#__PURE__*/React.createElement(View, {
-    style: [tokens.layout.footer, {
-      paddingVertical: tokens.spacing.footerPaddingVertical
-    }],
-    testID: "rv-list-footer"
-  }, mergedLoading ? isText(loadingText) ? /*#__PURE__*/React.createElement(Loading, {
-    size: tokens.sizing.loadingIndicator,
-    testID: "rv-list-loading"
-  }, loadingText) : /*#__PURE__*/React.createElement(View, {
-    style: tokens.layout.loadingInline,
-    testID: "rv-list-loading"
-  }, /*#__PURE__*/React.createElement(Loading, {
-    size: tokens.sizing.loadingIndicator
-  }), loadingText && /*#__PURE__*/React.createElement(View, {
-    style: {
-      marginLeft: tokens.spacing.inlineGap
-    }
-  }, loadingText)) : null, mergedError ? isFunction(errorText) ? errorText(retry) : isRenderable(errorText) ? isText(errorText) ? /*#__PURE__*/React.createElement(Text, {
-    testID: "rv-list-error",
-    onPress: retry,
-    accessibilityRole: "button",
-    style: {
-      color: tokens.colors.errorText
-    }
-  }, errorText) : /*#__PURE__*/React.createElement(Pressable, {
-    testID: "rv-list-error",
-    onPress: retry,
-    accessibilityRole: "button"
-  }, errorText) : null : null, finished && !mergedLoading && !mergedError && isRenderable(finishedText) ? isText(finishedText) ? /*#__PURE__*/React.createElement(Text, {
-    testID: "rv-list-finished",
-    style: {
-      color: tokens.colors.finishedText
-    }
-  }, finishedText) : /*#__PURE__*/React.createElement(View, {
-    testID: "rv-list-finished"
-  }, finishedText) : null));
-});
-List.displayName = 'List';
-export default List;

package/dist/es/components/list/index.js

@@ -1,2 +0,0 @@
-import List from './List';
-export default List;

package/dist/es/components/list/tokens.js

@@ -1,32 +0,0 @@
-import { createComponentTokensHook } from '../../design-system';
-export const createListTokens = foundations => {
-  return {
-    defaults: {
-      finished: false,
-      offset: 300,
-      immediateCheck: true,
-      scrollEventThrottle: 16
-    },
-    layout: {
-      footer: {
-        alignItems: 'center'
-      },
-      loadingInline: {
-        flexDirection: 'row',
-        alignItems: 'center'
-      }
-    },
-    colors: {
-      errorText: '#ff5b05',
-      finishedText: '#999999'
-    },
-    sizing: {
-      loadingIndicator: 16
-    },
-    spacing: {
-      footerPaddingVertical: foundations.spacing.lg,
-      inlineGap: foundations.spacing.sm
-    }
-  };
-};
-export const useListTokens = createComponentTokensHook('list', createListTokens);

package/dist/es/components/notify/defaults.js

@@ -1,9 +0,0 @@
-export const notifyDefaults = {
-  type: 'primary',
-  position: 'top',
-  duration: 3000,
-  closeOnClick: false,
-  animationDuration: 220,
-  safeAreaInsetTop: true,
-  safeAreaInsetBottom: true
-};