@fountain-ui/lab 2.0.0-beta.1 → 2.0.0-beta.12

package/build/typescript/Carousel/index.d.ts

@@ -1,2 +1,4 @@
-export { default } from './CarouselWeb';
+export { default } from './Carousel';
 export type { default as CarouselProps } from './CarouselProps';
+export type { CarouselInstance } from './types';
+export { normalItemStyleFactory, parallaxItemStyleFactory } from './animation';

package/build/typescript/Carousel/types.d.ts

@@ -0,0 +1,57 @@
+import type { ReactElement } from 'react';
+import type { Animated, ViewProps } from 'react-native';
+declare const directions: readonly ["next", "prev", "stay"];
+export declare type PagingDirection = (typeof directions)[number];
+export interface RenderItem<T> {
+    (info: {
+        item: T;
+        index: number;
+        interpolation: Animated.AnimatedInterpolation;
+    }): ReactElement | null;
+}
+export interface CreateScrollAnimation {
+    (aValue: Animated.AnimatedValue, toValue: number): Animated.CompositeAnimation;
+}
+export interface CreateItemStyle {
+    (itemInterpolation: Animated.AnimatedInterpolation, itemWidth: number): Animated.AnimatedProps<ViewProps['style']>;
+}
+export interface GetCurrentIndex {
+    (): number;
+}
+export interface IndexController {
+    currentIndex: number;
+    getCurrentIndex: GetCurrentIndex;
+    lastIndex: number;
+    monitorElement: ReactElement;
+}
+export interface StartPagingAnimation {
+    (direction: PagingDirection, isGesture?: boolean): void;
+}
+export declare type VisibleIndexRanges = Array<[number, number]>;
+export interface StoreSubscription {
+    (): void;
+}
+export interface ItemVisibilityStore {
+    dispatch: (ranges: VisibleIndexRanges) => void;
+    subscribe: (listener: (ranges: VisibleIndexRanges) => void) => StoreSubscription;
+    removeAllListeners: () => void;
+}
+export interface AutoplayController {
+    pause: () => void;
+    resume: () => void;
+}
+export interface CarouselInstance {
+    /**
+     * Scroll to next visible item.
+     */
+    next: () => void;
+    /**
+     * Scroll to previous visible item.
+     */
+    prev: () => void;
+    /**
+     * Get current visible item index.
+     */
+    getCurrentIndex: GetCurrentIndex;
+}
+export {};

package/build/typescript/ComicViewer/ComicViewer.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="react" />
 import { default as ComicViewerProps } from './ComicViewerProps';
 export default function ComicViewer<T>(props: ComicViewerProps<T>): JSX.Element;

package/build/typescript/DateTimePicker/DateTimePicker.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="react" />
 import type DateTimePickerProps from './DateTimePickerProps';
 export default function DateTimePicker(props: DateTimePickerProps): JSX.Element;

package/build/typescript/DateTimePicker/YearPicker.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 interface YearPickerProps {
     date: Date;
     locale?: string;

package/build/typescript/FlipCard/FlipCard.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="react" />
 import type FlipCardProps from './FlipCardProps';
 export default function FlipCard(props: FlipCardProps): JSX.Element;

package/build/typescript/StatusBarProvider/StatusBarProvider.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="react" />
 import type StatusBarProviderProps from './StatusBarProviderProps';
 export default function StatusBarProvider(props: StatusBarProviderProps): JSX.Element;

package/build/typescript/ViewPager/ChildrenMemoizedPage.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
 import type { PageProps } from './ViewPagerProps';
-declare const _default: React.MemoExoticComponent<(props: PageProps) => JSX.Element>;
+declare function Page(props: PageProps): JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof Page>;
 export default _default;

package/build/typescript/ViewPager/PageStateContext.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+interface PageState {
+    isActive: boolean;
+}
+declare const PageStateContext: import("react").Context<PageState>;
+export declare const useViewPagerPageState: () => PageState;
+export default PageStateContext;

package/build/typescript/ViewPager/ViewPagerNative.d.ts

@@ -1,3 +1,5 @@
-/// <reference types="react" />
+import React from 'react';
 import type ViewPagerProps from './ViewPagerProps';
-export default function ViewPager(props: ViewPagerProps): JSX.Element;
+import type { ViewPagerInstance } from './ViewPagerProps';
+declare const ViewPager: React.ForwardRefExoticComponent<Pick<ViewPagerProps, "style" | "children" | "onChange" | "scrollEnabled" | "keyboardDismissMode" | "loading" | "initialPage" | "offscreenPageRerenderLimit" | "pageComponent" | "pageForceRerenderKey" | "UNSTABLE_sharedIndex"> & React.RefAttributes<ViewPagerInstance>>;
+export default ViewPager;

package/build/typescript/ViewPager/ViewPagerProps.d.ts

@@ -1,38 +1,46 @@
-import React from 'react';
+import type { ComponentType, PropsWithChildren, ReactNode, Ref } from 'react';
 import type { ViewProps } from 'react-native';
+import type { SharedValue } from 'react-native-reanimated';
 import type { ComponentProps } from '@fountain-ui/core';
 export declare type KeyboardDismissMode = 'none' | 'on-drag';
-export declare type PageProps = React.PropsWithChildren<ViewProps> & {
-    isNeighbor: boolean;
-    isVisible: boolean;
-    rerenderKey?: any;
+export declare type PageProps = PropsWithChildren<ViewProps> & {
+    index: number;
+    loading: ViewPagerProps['loading'];
+    offscreenPageRerenderLimit: number;
+    sharedIndex: SharedValue<number>;
+    rerenderKey?: ViewPagerProps['pageForceRerenderKey'];
 };
-export declare type PageComponent = React.ComponentType<PageProps>;
+export declare type PageComponent = ComponentType<PageProps>;
 export declare type Loading = 'lazy' | 'eager';
-export default interface ViewPagerProps extends ComponentProps<{
+export interface ViewPagerInstance {
     /**
-     * Collection of ViewPager components.
+     * Function to scroll to a specific page in the ViewPager. Invalid index is ignored.
+     * @param index
      */
-    children?: React.ReactNode;
-    /**
-     * If `true`, enable page visible hint.
-     * @default false
-     */
-    enableVisibleHint?: boolean;
+    setPage: (index: number) => void;
+}
+export default interface ViewPagerProps extends ComponentProps<{
+    ref?: Ref<ViewPagerInstance>;
     /**
-     * If `true`, Based on the current index, the pages on the left and right are also rerender.
-     * @default false
+     * Collection of ViewPager components.
      */
-    enableNeighborPageRerender?: boolean;
+    children?: ReactNode;
     /**
-     * A number representing the index of the active page.
+     * Index of initial page that should be selected.
+     * @default 0
      */
-    index: number;
+    initialPage?: number;
     /**
      * Whether to load the page immediately (`eager`) or on an as-needed basis (`lazy`).
      * @default 'lazy'
      */
     loading?: Loading;
+    /**
+     * Mobile only. The number of pages that should be re-rendered to either side of the current page.
+     * Changing this value after the component mount has no effect.
+     * @default 0
+     */
+    offscreenPageRerenderLimit?: number;
     /**
      * Callback fired when an index is changed.
      */
@@ -56,5 +64,9 @@ export default interface ViewPagerProps extends ComponentProps<{
      * @default 'on-drag'
      */
     keyboardDismissMode?: KeyboardDismissMode;
+    /**
+     * Unstable API.
+     */
+    UNSTABLE_sharedIndex?: SharedValue<number>;
 }> {
 }

package/build/typescript/ViewPager/ViewPagerWeb.d.ts

@@ -1,3 +1,5 @@
-/// <reference types="react" />
+import React from 'react';
 import type ViewPagerProps from './ViewPagerProps';
-export default function ViewPager(props: ViewPagerProps): JSX.Element;
+import type { ViewPagerInstance } from './ViewPagerProps';
+declare const ViewPager: React.ForwardRefExoticComponent<Pick<ViewPagerProps, "style" | "children" | "onChange" | "scrollEnabled" | "keyboardDismissMode" | "loading" | "initialPage" | "offscreenPageRerenderLimit" | "pageComponent" | "pageForceRerenderKey" | "UNSTABLE_sharedIndex"> & React.RefAttributes<ViewPagerInstance>>;
+export default ViewPager;

package/build/typescript/ViewPager/index.d.ts

@@ -1,2 +1,3 @@
 export { default } from './ViewPagerWeb';
-export type { default as ViewPagerProps } from './ViewPagerProps';
+export type { default as ViewPagerProps, ViewPagerInstance } from './ViewPagerProps';
+export { useViewPagerPageState } from './PageStateContext';

package/build/typescript/ViewPager/index.native.d.ts

@@ -1 +1,2 @@
 export { default } from './ViewPagerNative';
+export { useViewPagerPageState } from './PageStateContext';

package/build/typescript/ViewPager/utils.d.ts

@@ -1,21 +1,5 @@
-import React from 'react';
-import ViewPagerProps, { Loading, PageComponent } from './ViewPagerProps';
-export interface PageState {
-    visited?: boolean;
-}
-export interface PageRenderOption {
-    enableVisibleHint: boolean;
-    enableNeighborPageRerender: boolean;
-    index: number;
-    loading: Loading;
-    pageComponent: PageComponent;
-    pageForceRerenderKey?: any;
-}
-export interface PageRenderer {
-    (children: ViewPagerProps['children']): React.ReactNode;
-}
-export declare const defaultEnableVisibleHint: boolean;
-export declare const defaultEnableNeighborPageRerender: boolean;
+import { Loading, PageComponent } from './ViewPagerProps';
+export declare const defaultInitialPage: number;
 export declare const defaultLoading: Loading;
+export declare const defaultOffscreenPageRerenderLimit: number;
 export declare const defaultPageComponent: PageComponent;
-export declare const usePageRenderer: ({ enableVisibleHint, index: currentIndex, loading, pageComponent: PageComponent, pageForceRerenderKey, enableNeighborPageRerender, }: PageRenderOption) => PageRenderer;

package/build/typescript/ViewabilityTrackerView/Viewability.d.ts

@@ -0,0 +1,3 @@
+export default interface Viewability {
+    visible: boolean;
+}

package/build/typescript/ViewabilityTrackerView/ViewabilityTrackerView.d.ts

@@ -0,0 +1,2 @@
+import type ViewabilityTrackerViewProps from './ViewabilityTrackerViewProps';
+export default function ViewabilityTrackerView(props: ViewabilityTrackerViewProps): JSX.Element;

package/build/typescript/ViewabilityTrackerView/ViewabilityTrackerViewProps.d.ts

@@ -0,0 +1,22 @@
+import type { ViewProps } from 'react-native';
+import type { OverridableComponentProps } from '@fountain-ui/core';
+import type Viewability from './Viewability';
+export default interface ViewabilityTrackerViewProps extends OverridableComponentProps<ViewProps, {
+    /**
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * @default 1000
+     */
+    measurementIntervalMillis?: number;
+    /**
+     *
+     */
+    onViewabilityChange?: (viewability: Viewability) => void;
+    /**
+     * @default 50
+     */
+    visiblePercentThreshold?: number;
+}> {
+}

package/build/typescript/ViewabilityTrackerView/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ViewabilityTrackerView';
+export type { default as ViewabilityTrackerViewProps } from './ViewabilityTrackerViewProps';

package/build/typescript/ViewabilityTrackerView/measureViewability.d.ts

@@ -0,0 +1,11 @@
+import type { View } from 'react-native';
+export interface ViewabilityDetail {
+    visiblePercent: number;
+}
+export interface MeasureViewabilityParameters {
+    view: View;
+    windowWidth: number;
+    windowHeight: number;
+    onViewabilityDetailMeasured: (detail: ViewabilityDetail) => void;
+}
+export default function measureViewability({ view, windowWidth, windowHeight, onViewabilityDetailMeasured, }: MeasureViewabilityParameters): void;

package/build/typescript/ViewabilityTrackerView/useViewabilityTracker.d.ts

@@ -0,0 +1,11 @@
+import type { RefObject } from 'react';
+import type { View } from 'react-native';
+import type Viewability from './Viewability';
+export interface ViewabilityTrackerConfig {
+    enabled: boolean;
+    measurementIntervalMillis: number;
+    onViewabilityChange?: (viewability: Viewability) => void;
+    viewRef: RefObject<View>;
+    visiblePercentThreshold: number;
+}
+export default function useViewabilityTracker(config: ViewabilityTrackerConfig): void;

package/build/typescript/hooks/index.d.ts

@@ -1,2 +1,4 @@
+export { default as useDeferredExecutor } from './useDeferredExecutor';
+export { default as useIsMounted } from './useIsMounted';
 export { default as useUnstableCollapsibleAppBar } from './useUnstableCollapsibleAppBar';
 export { default as useUnstableToggleDisplayStyle } from './useUnstableToggleDisplayStyle';

package/build/typescript/hooks/useDeferredExecutor.d.ts

@@ -0,0 +1,11 @@
+export interface Runnable {
+    (): void;
+}
+export interface DeferredExecute {
+    (runnable: Runnable, delay?: number): void;
+}
+export interface DeferredExecutor {
+    cancel: () => void;
+    execute: DeferredExecute;
+}
+export default function useDeferredExecutor(): DeferredExecutor;

package/build/typescript/hooks/useIsMounted.d.ts

@@ -0,0 +1,4 @@
+export interface UseIsMounted {
+    (): boolean;
+}
+export default function useIsMounted(): UseIsMounted;

package/build/typescript/hooks/useUnstableCollapsibleAppBar.d.ts

@@ -1,5 +1,5 @@
 import { Falsy, RegisteredStyle, ScrollViewProps, ViewProps, ViewStyle } from 'react-native';
-import Animated from 'react-native-reanimated';
+import type { SharedValue } from 'react-native-reanimated';
 declare type WebOnlyStyle = {
     boxShadow: any;
 };
@@ -13,12 +13,11 @@ export interface ContentInsets {
     right?: number;
 }
 export interface Options {
-    translucent?: boolean;
     shouldTranslateYReset?: boolean;
 }
 export interface CollapsibleAppBar {
     appBarStyle: ViewStyleProp;
-    vectorY: Animated.SharedValue<number>;
+    vectorY: SharedValue<number>;
     onAppBarLayout: OnLayoutCallback;
     onCollapsibleToolbarLayout: OnLayoutCallback;
     onScroll: OnScroll;

package/build/typescript/hooks/useUnstableToggleDisplayStyle.d.ts

@@ -1,4 +1,4 @@
-import Animated from 'react-native-reanimated';
-export default function useAnimatedDisplayStyle(vectorY: Animated.SharedValue<number>, threshold?: number, defaultDisplay?: 'flex' | 'none'): {
+import type { SharedValue } from 'react-native-reanimated';
+export default function useAnimatedDisplayStyle(vectorY: SharedValue<number>, threshold?: number, defaultDisplay?: 'flex' | 'none'): {
     display: "flex" | "none";
 };

package/build/typescript/index.d.ts

@@ -12,4 +12,6 @@ export { default as ComicViewer } from './ComicViewer';
 export * from './ComicViewer';
 export { default as StatusBarProvider, useStatusBarContext } from './StatusBarProvider';
 export * from './StatusBarProvider';
+export { default as ViewabilityTrackerView } from './ViewabilityTrackerView';
+export * from './ViewabilityTrackerView';
 export * from './hooks';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fountain-ui/lab",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.12",
   "private": false,
   "author": "Fountain-UI Team",
   "description": "Incubator for Fountain-UI React components.",
@@ -15,53 +15,38 @@
     "prepare": "bob build"
   },
   "dependencies": {
-    "@emotion/react": "^11.4.1",
-    "@emotion/styled": "^11.0.0",
-    "@fountain-ui/icons": "^2.0.0-beta.1",
-    "@fountain-ui/utils": "^2.0.0-beta.1",
+    "@emotion/react": "^11.10.0",
+    "@emotion/styled": "^11.10.0",
+    "@fountain-ui/icons": "^2.0.0-beta.6",
+    "@fountain-ui/utils": "^2.0.0-beta.3",
     "react-native-calendars": "1.1267.0"
   },
   "peerDependencies": {
-    "@fountain-ui/core": "^2.0.0-beta.1",
+    "@fountain-ui/core": "^2.0.0-beta.3",
     "@gorhom/bottom-sheet": "^4.1.3",
-    "@react-native-community/viewpager": "> 4.2.x",
     "date-fns": "^2.0.0",
     "react": "^16.8.0 || ^17.0.0",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react-native": "^0.63.0",
-    "react-native-snap-carousel": "^3.9.0",
-    "react-slick": "^0.25.0"
+    "react-native-gesture-handler": "^2.0.0",
+    "react-native-pager-view": "^4.0.0"
   },
   "peerDependenciesMeta": {
     "@gorhom/bottom-sheet": {
       "optional": true
     },
-    "@react-native-community/viewpager": {
-      "optional": true
-    },
     "react-dom": {
       "optional": true
     },
-    "react-native": {
-      "optional": true
-    },
-    "react-slick": {
-      "optional": true
-    },
-    "react-native-snap-carousel": {
+    "react-native-pager-view": {
       "optional": true
     }
   },
   "devDependencies": {
-    "@fountain-ui/core": "^2.0.0-beta.1",
     "@gorhom/bottom-sheet": "4.1.3",
-    "@react-native-community/viewpager": "^4.2.2",
-    "@types/react-native-snap-carousel": "^3.8.4",
-    "@types/react-slick": "^0.23.5",
     "date-fns": "^2.23.0",
-    "react-native-safe-area-context": "^3.3.2",
-    "react-native-snap-carousel": "^3.9.1",
-    "react-slick": "^0.28.1"
+    "react-native-pager-view": "^4.2.4",
+    "react-native-safe-area-context": "^3.3.2"
   },
   "react-native-builder-bob": {
     "source": "./src",
@@ -85,5 +70,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5883a0d99faaaf1233350572aaee88054151c102"
+  "gitHead": "efb9e6cc7cc65e52d1084a0c3664f419dc171240"
 }

package/src/AnimatedY/AnimatedY.tsx

@@ -1,7 +1,13 @@
-import React from 'react';
-import Animated, { Easing } from 'react-native-reanimated';
+import React, { useEffect } from 'react';
+import type { WithTimingConfig } from 'react-native-reanimated';
+import Animated, { Easing, useAnimatedStyle, useSharedValue, withTiming } from 'react-native-reanimated';
 import type AnimatedYProps from './AnimatedYProps';
 
+const ANIMATION_CONFIG: Readonly<WithTimingConfig> = {
+    duration: 150,
+    easing: Easing.out(Easing.exp),
+};
+
 export default function AnimatedY(props: AnimatedYProps) {
     const {
         children,
@@ -9,17 +15,14 @@ export default function AnimatedY(props: AnimatedYProps) {
         style,
     } = props;
 
-    const animatedY = Animated.useSharedValue(translateY);
-    const animatedStyle = Animated.useAnimatedStyle(() => ({
+    const animatedY = useSharedValue(translateY);
+    const animatedStyle = useAnimatedStyle(() => ({
         transform: [{ translateY: animatedY.value }],
-    }));
+    }), []);
 
-    React.useEffect(() => {
+    useEffect(() => {
         if (translateY >= 0) {
-            animatedY.value = Animated.withTiming(translateY, {
-                duration: 150,
-                easing: Easing.out(Easing.exp),
-            });
+            animatedY.value = withTiming(translateY, ANIMATION_CONFIG);
         }
     }, [translateY]);
 

package/src/Carousel/Carousel.tsx

@@ -0,0 +1,151 @@
+import React, { forwardRef, memo, useImperativeHandle, useMemo, useRef } from 'react';
+import { Animated } from 'react-native';
+import ViewabilityTrackerView from '../ViewabilityTrackerView';
+import type CarouselProps from './CarouselProps';
+import type { CarouselInstance } from './types';
+import {
+    useAutoplayController,
+    useDimensionChangeReaction,
+    useIndexController,
+    useItemVisibilityStore,
+    useLoopedData,
+    usePagingAnimation,
+} from './hooks';
+import { createDefaultItemStyle, createDefaultScrollAnimation } from './animation';
+import { InternalContext, RootView, ScrollViewGesture } from './components';
+
+const Carousel = forwardRef<CarouselInstance, CarouselProps>(function Carousel(props, ref) {
+    const {
+        autoplay = false,
+        autoplayInterval = 3000,
+        createItemStyle = createDefaultItemStyle,
+        createScrollAnimation = createDefaultScrollAnimation,
+        data: originalData,
+        disableSmartAutoplay = false,
+        initialIndex = 0,
+        itemHeight,
+        itemWidth,
+        loop = false,
+        onIndexChange,
+        renderItem,
+        scrollEnabled = true,
+        style,
+        windowSize = 5,
+    } = props;
+
+    const data = useLoopedData(originalData, loop);
+
+    const initialTx = itemWidth * initialIndex;
+    const controlledTx = useRef(new Animated.Value(initialTx)).current;
+    const offsetTx = useRef(new Animated.Value(0)).current;
+
+    const {
+        currentIndex,
+        getCurrentIndex,
+        lastIndex,
+        monitorElement,
+    } = useIndexController({
+        controlledTx,
+        initialIndex,
+        itemWidth,
+        numberOfOriginalData: originalData.length,
+        onIndexChange,
+    });
+
+    const itemVisibilityStore = useItemVisibilityStore({
+        currentIndex,
+        numberOfData: data.length,
+        windowSize,
+    });
+
+    const {
+        finalizeAnimation,
+        globalInterpolation,
+        startAnimation,
+    } = usePagingAnimation({
+        controlledTx,
+        createScrollAnimation,
+        getCurrentIndex,
+        itemWidth,
+        lastIndex,
+        loop,
+        numberOfData: data.length,
+        offsetTx,
+    });
+
+    const autoplayController = useAutoplayController({
+        enabled: autoplay,
+        intervalMillis: autoplayInterval,
+        startPagingAnimation: startAnimation,
+    });
+
+    useDimensionChangeReaction({
+        controlledTx,
+        currentIndex,
+        itemWidth,
+    });
+
+    useImperativeHandle(
+        ref,
+        () => ({
+            next: () => startAnimation('next'),
+            prev: () => startAnimation('prev'),
+            getCurrentIndex,
+        }),
+        [startAnimation, getCurrentIndex],
+    );
+
+    const contextValue = useMemo(() => ({
+        createItemStyle,
+        data,
+        globalInterpolation,
+        itemHeight,
+        itemWidth,
+        itemVisibilityStore,
+        loop,
+    }), [
+        createItemStyle,
+        data,
+        globalInterpolation,
+        itemHeight,
+        itemWidth,
+        itemVisibilityStore,
+        loop,
+    ]);
+
+    return (
+        <InternalContext.Provider value={contextValue}>
+            {monitorElement}
+
+            <ViewabilityTrackerView
+                enabled={autoplay && !disableSmartAutoplay}
+                measurementIntervalMillis={Math.max(3000, autoplayInterval)}
+                onViewabilityChange={({ visible }) => {
+                    if (visible) {
+                        autoplayController.resume();
+                    } else {
+                        autoplayController.pause();
+                    }
+                }}
+            >
+                <ScrollViewGesture
+                    autoplayController={autoplayController}
+                    finalizeAnimation={finalizeAnimation}
+                    offsetTx={offsetTx}
+                    scrollEnabled={scrollEnabled}
+                    startAnimation={startAnimation}
+                >
+                    <RootView
+                        data={data}
+                        itemHeight={itemHeight}
+                        originalData={originalData}
+                        renderItem={renderItem}
+                        style={style}
+                    />
+                </ScrollViewGesture>
+            </ViewabilityTrackerView>
+        </InternalContext.Provider>
+    );
+});
+
+export default memo(Carousel);