@mpxjs/webpack-plugin 2.10.16 → 2.10.17-beta.10

package/lib/runtime/components/react/dist/mpx-recycle-view.jsx

@@ -0,0 +1,307 @@
+import React, { forwardRef, useRef, useState, useEffect, useMemo, createElement, useImperativeHandle, useCallback } from 'react';
+import { SectionList, RefreshControl } from 'react-native';
+import useInnerProps, { getCustomEvent } from './getInnerListeners';
+import { extendObject, useLayout, useTransformStyle } from './utils';
+const getGeneric = (generichash, generickey) => {
+    if (!generichash || !generickey)
+        return null;
+    const GenericComponent = global.__mpxGenericsMap?.[generichash]?.[generickey]?.();
+    if (!GenericComponent)
+        return null;
+    return forwardRef((props, ref) => {
+        return createElement(GenericComponent, extendObject({}, {
+            ref: ref
+        }, props));
+    });
+};
+const getListHeaderComponent = (generichash, generickey, data) => {
+    if (!generichash || !generickey)
+        return undefined;
+    const ListHeaderComponent = getGeneric(generichash, generickey);
+    return ListHeaderComponent ? createElement(ListHeaderComponent, { listHeaderData: data }) : null;
+};
+const getSectionHeaderRenderer = (generichash, generickey) => {
+    if (!generichash || !generickey)
+        return undefined;
+    return (sectionData) => {
+        if (!sectionData.section.hasSectionHeader)
+            return null;
+        const SectionHeaderComponent = getGeneric(generichash, generickey);
+        return SectionHeaderComponent ? createElement(SectionHeaderComponent, { itemData: sectionData.section.headerData }) : null;
+    };
+};
+const getItemRenderer = (generichash, generickey) => {
+    if (!generichash || !generickey)
+        return undefined;
+    return ({ item }) => {
+        const ItemComponent = getGeneric(generichash, generickey);
+        return ItemComponent ? createElement(ItemComponent, { itemData: item }) : null;
+    };
+};
+const RecycleView = forwardRef((props = {}, ref) => {
+    const { enhanced = false, bounces = true, scrollEventThrottle = 0, height, width, listData, generichash, style = {}, itemHeight = {}, sectionHeaderHeight = {}, listHeaderHeight = {}, listHeaderData = null, useListHeader = false, 'genericrecycle-item': genericrecycleItem, 'genericsection-header': genericsectionHeader, 'genericlist-header': genericListHeader, 'enable-var': enableVar, 'external-var-context': externalVarContext, 'parent-font-size': parentFontSize, 'parent-width': parentWidth, 'parent-height': parentHeight, 'enable-sticky': enableSticky = false, 'enable-back-to-top': enableBackToTop = false, 'end-reached-threshold': onEndReachedThreshold = 0.1, 'refresher-enabled': refresherEnabled, 'show-scrollbar': showScrollbar = true, 'refresher-triggered': refresherTriggered } = props;
+    const [refreshing, setRefreshing] = useState(!!refresherTriggered);
+    const scrollViewRef = useRef(null);
+    const indexMap = useRef({});
+    const reverseIndexMap = useRef({});
+    // 缓存 getGeneric 的结果，避免每次都创建新的组件引用
+    const genericComponentsCache = useRef({});
+    const getCachedGeneric = useCallback((generichash, generickey) => {
+        if (!generichash || !generickey)
+            return null;
+        const cacheKey = `${generichash}_${generickey}`;
+        if (!genericComponentsCache.current[cacheKey]) {
+            genericComponentsCache.current[cacheKey] = getGeneric(generichash, generickey);
+        }
+        return genericComponentsCache.current[cacheKey];
+    }, []);
+    // 使用 ref 存储最新的 props，避免渲染函数引用变化导致组件重新挂载
+    const propsRef = useRef({ generichash, genericrecycleItem, genericsectionHeader, genericListHeader, listHeaderData, useListHeader });
+    propsRef.current = { generichash, genericrecycleItem, genericsectionHeader, genericListHeader, listHeaderData, useListHeader };
+    // 创建稳定的渲染函数引用，使用 getCachedGeneric 确保组件引用稳定
+    const stableItemRenderer = useCallback(({ item }) => {
+        const { generichash: hash, genericrecycleItem: key } = propsRef.current;
+        const ItemComponent = getCachedGeneric(hash, key);
+        return ItemComponent ? createElement(ItemComponent, { itemData: item }) : null;
+    }, [getCachedGeneric]);
+    const stableSectionHeaderRenderer = useCallback((sectionData) => {
+        if (!sectionData.section.hasSectionHeader)
+            return null;
+        const { generichash: hash, genericsectionHeader: key } = propsRef.current;
+        const SectionHeaderComponent = getCachedGeneric(hash, key);
+        return SectionHeaderComponent ? createElement(SectionHeaderComponent, { itemData: sectionData.section.headerData }) : null;
+    }, [getCachedGeneric]);
+    // 创建稳定的 ListHeader 渲染函数，与 section-header 和 item 的处理方式一致
+    const getStableListHeader = useCallback(() => {
+        const { generichash: hash, genericListHeader: key, listHeaderData: data, useListHeader: use } = propsRef.current;
+        if (!use || !hash || !key)
+            return null;
+        const ListHeaderComponent = getCachedGeneric(hash, key);
+        return ListHeaderComponent ? createElement(ListHeaderComponent, { listHeaderData: data }) : null;
+    }, [getCachedGeneric]);
+    const { hasSelfPercent, setWidth, setHeight } = useTransformStyle(style, { enableVar, externalVarContext, parentFontSize, parentWidth, parentHeight });
+    const { layoutRef, layoutStyle, layoutProps } = useLayout({ props, hasSelfPercent, setWidth, setHeight, nodeRef: scrollViewRef });
+    useEffect(() => {
+        if (refreshing !== refresherTriggered) {
+            setRefreshing(!!refresherTriggered);
+        }
+    }, [refresherTriggered]);
+    const onRefresh = () => {
+        const { bindrefresherrefresh } = props;
+        bindrefresherrefresh &&
+            bindrefresherrefresh(getCustomEvent('refresherrefresh', {}, { layoutRef }, props));
+    };
+    const onEndReached = () => {
+        const { bindscrolltolower } = props;
+        bindscrolltolower &&
+            bindscrolltolower(getCustomEvent('scrolltolower', {}, { layoutRef }, props));
+    };
+    const onScroll = (event) => {
+        const { bindscroll } = props;
+        bindscroll &&
+            bindscroll(getCustomEvent('scroll', event.nativeEvent, { layoutRef }, props));
+    };
+    // 通过sectionIndex和rowIndex获取原始索引
+    const getOriginalIndex = (sectionIndex, rowIndex) => {
+        const key = `${sectionIndex}_${rowIndex}`;
+        return reverseIndexMap.current[key] ?? -1; // 如果找不到，返回-1
+    };
+    const scrollToIndex = ({ index, animated, viewOffset = 0, viewPosition = 0 }) => {
+        if (scrollViewRef.current) {
+            // 通过索引映射表快速定位位置
+            const position = indexMap.current[index];
+            const [sectionIndex, itemIndex] = position.split('_');
+            scrollViewRef.current.scrollToLocation?.({
+                itemIndex: itemIndex === 'header' ? 0 : Number(itemIndex) + 1,
+                sectionIndex: Number(sectionIndex) || 0,
+                animated,
+                viewOffset,
+                viewPosition
+            });
+        }
+    };
+    const getItemHeight = ({ sectionIndex, rowIndex }) => {
+        if (!itemHeight) {
+            return 0;
+        }
+        if (itemHeight.getter) {
+            const item = convertedListData[sectionIndex].data[rowIndex];
+            // 使用getOriginalIndex获取原始索引
+            const originalIndex = getOriginalIndex(sectionIndex, rowIndex);
+            return itemHeight.getter?.(item, originalIndex) || 0;
+        }
+        else {
+            return itemHeight.value || 0;
+        }
+    };
+    const getSectionHeaderHeight = ({ sectionIndex }) => {
+        const item = convertedListData[sectionIndex];
+        const { hasSectionHeader } = item;
+        // 使用getOriginalIndex获取原始索引
+        const originalIndex = getOriginalIndex(sectionIndex, 'header');
+        if (!hasSectionHeader)
+            return 0;
+        if (sectionHeaderHeight.getter) {
+            return sectionHeaderHeight.getter?.(item, originalIndex) || 0;
+        }
+        else {
+            return sectionHeaderHeight.value || 0;
+        }
+    };
+    const convertedListData = useMemo(() => {
+        const sections = [];
+        let currentSection = null;
+        // 清空之前的索引映射
+        indexMap.current = {};
+        // 清空反向索引映射
+        reverseIndexMap.current = {};
+        listData.forEach((item, index) => {
+            if (item.isSectionHeader) {
+                // 如果已经存在一个 section，先把它添加到 sections 中
+                if (currentSection) {
+                    sections.push(currentSection);
+                }
+                // 创建新的 section
+                currentSection = {
+                    headerData: item,
+                    data: [],
+                    hasSectionHeader: true,
+                    _originalItemIndex: index
+                };
+                // 为 section header 添加索引映射
+                const sectionIndex = sections.length;
+                indexMap.current[index] = `${sectionIndex}_header`;
+                // 添加反向索引映射
+                reverseIndexMap.current[`${sectionIndex}_header`] = index;
+            }
+            else {
+                // 如果没有当前 section，创建一个默认的
+                if (!currentSection) {
+                    // 创建默认section (无header的section)
+                    currentSection = {
+                        headerData: null,
+                        data: [],
+                        hasSectionHeader: false,
+                        _originalItemIndex: -1
+                    };
+                }
+                // 将 item 添加到当前 section 的 data 中
+                const itemIndex = currentSection.data.length;
+                currentSection.data.push(extendObject({}, item, {
+                    _originalItemIndex: index
+                }));
+                let sectionIndex;
+                // 为 item 添加索引映射 - 存储格式为: "sectionIndex_itemIndex"
+                if (!currentSection.hasSectionHeader && sections.length === 0) {
+                    // 在默认section中(第一个且无header)
+                    sectionIndex = 0;
+                    indexMap.current[index] = `${sectionIndex}_${itemIndex}`;
+                }
+                else {
+                    // 在普通section中
+                    sectionIndex = sections.length;
+                    indexMap.current[index] = `${sectionIndex}_${itemIndex}`;
+                }
+                // 添加反向索引映射
+                reverseIndexMap.current[`${sectionIndex}_${itemIndex}`] = index;
+            }
+        });
+        // 添加最后一个 section
+        if (currentSection) {
+            sections.push(currentSection);
+        }
+        return sections;
+    }, [listData]);
+    const { getItemLayout } = useMemo(() => {
+        const layouts = [];
+        let offset = 0;
+        if (useListHeader) {
+            // 计算列表头部的高度
+            offset += listHeaderHeight.getter?.() || listHeaderHeight.value || 0;
+        }
+        // 遍历所有 sections
+        convertedListData.forEach((section, sectionIndex) => {
+            // 添加 section header 的位置信息
+            const headerHeight = getSectionHeaderHeight({ sectionIndex });
+            layouts.push({
+                length: headerHeight,
+                offset,
+                index: layouts.length
+            });
+            offset += headerHeight;
+            // 添加该 section 中所有 items 的位置信息
+            section.data.forEach((item, itemIndex) => {
+                const contenteight = getItemHeight({ sectionIndex, rowIndex: itemIndex });
+                layouts.push({
+                    length: contenteight,
+                    offset,
+                    index: layouts.length
+                });
+                offset += contenteight;
+            });
+            // 添加该 section 尾部位置信息
+            // 因为即使 sectionList 没传 renderSectionFooter，getItemLayout 中的 index 的计算也会包含尾部节点
+            layouts.push({
+                length: 0,
+                offset,
+                index: layouts.length
+            });
+        });
+        return {
+            itemLayouts: layouts,
+            getItemLayout: (data, index) => layouts[index]
+        };
+    }, [convertedListData, useListHeader, itemHeight.value, itemHeight.getter, sectionHeaderHeight.value, sectionHeaderHeight.getter, listHeaderHeight.value, listHeaderHeight.getter]);
+    const scrollAdditionalProps = extendObject({
+        alwaysBounceVertical: false,
+        alwaysBounceHorizontal: false,
+        scrollEventThrottle: scrollEventThrottle,
+        scrollsToTop: enableBackToTop,
+        showsHorizontalScrollIndicator: showScrollbar,
+        onEndReachedThreshold,
+        ref: scrollViewRef,
+        bounces: false,
+        stickySectionHeadersEnabled: enableSticky,
+        onScroll: onScroll,
+        onEndReached: onEndReached
+    }, layoutProps);
+    if (enhanced) {
+        Object.assign(scrollAdditionalProps, {
+            bounces
+        });
+    }
+    if (refresherEnabled) {
+        Object.assign(scrollAdditionalProps, {
+            refreshing: refreshing
+        });
+    }
+    useImperativeHandle(ref, () => {
+        return {
+            ...props,
+            scrollToIndex
+        };
+    });
+    const innerProps = useInnerProps(extendObject({}, props, scrollAdditionalProps), [
+        'id',
+        'show-scrollbar',
+        'lower-threshold',
+        'refresher-triggered',
+        'refresher-enabled',
+        'bindrefresherrefresh'
+    ], { layoutRef });
+    return createElement(SectionList, extendObject({
+        style: [{ height, width }, style, layoutStyle],
+        sections: convertedListData,
+        renderItem: stableItemRenderer,
+        getItemLayout: getItemLayout,
+        ListHeaderComponent: getStableListHeader(),
+        renderSectionHeader: stableSectionHeaderRenderer,
+        refreshControl: refresherEnabled
+            ? React.createElement(RefreshControl, {
+                onRefresh: onRefresh,
+                refreshing: refreshing
+            })
+            : undefined
+    }, innerProps));
+});
+export default RecycleView;

package/lib/runtime/components/react/dist/mpx-rich-text/html.d.ts

@@ -0,0 +1 @@
+export declare const generateHTML: (html: string) => string;

package/lib/runtime/components/react/dist/mpx-rich-text/index.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+/**
+ * ✔ nodes
+ */
+import { View, ViewProps, ViewStyle } from 'react-native';
+import { HandlerRef } from '../useNodesRef';
+type Node = {
+    type: 'node' | 'text';
+    name?: string;
+    attrs?: any;
+    children?: Array<Node>;
+    text: string;
+};
+interface _RichTextProps extends ViewProps {
+    style?: ViewStyle;
+    nodes: string | Array<Node>;
+    'enable-var'?: boolean;
+    'external-var-context'?: Record<string, any>;
+    'parent-font-size'?: number;
+    'parent-width'?: number;
+    'parent-height'?: number;
+}
+declare const _RichText: import("react").ForwardRefExoticComponent<_RichTextProps & import("react").RefAttributes<HandlerRef<View, _RichTextProps>>>;
+export default _RichText;

package/lib/runtime/components/react/dist/mpx-rich-text/index.jsx

@@ -66,5 +66,5 @@ const _RichText = forwardRef((props, ref) => {
     }
     return finalComponent;
 });
-_RichText.displayName = 'mpx-rich-text';
+_RichText.displayName = 'MpxRichText';
 export default _RichText;

package/lib/runtime/components/react/dist/mpx-root-portal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ✔ enable
+ */
+import { ReactNode } from 'react';
+interface RootPortalProps {
+    enable?: boolean;
+    children: ReactNode;
+    [x: string]: any;
+}
+declare const _RootPortal: {
+    (props: RootPortalProps): import("react").FunctionComponentElement<import("./mpx-portal/index").PortalProps>;
+    displayName: string;
+};
+export default _RootPortal;

package/lib/runtime/components/react/dist/mpx-scroll-view.d.ts

@@ -0,0 +1,54 @@
+import { View, NativeSyntheticEvent, NativeScrollEvent, ViewStyle } from 'react-native';
+import { ReactNode } from 'react';
+import { HandlerRef } from './useNodesRef';
+import { GestureHandler } from './utils';
+interface ScrollViewProps {
+    children?: ReactNode;
+    enhanced?: boolean;
+    bounces?: boolean;
+    style?: ViewStyle;
+    'scroll-x'?: boolean;
+    'scroll-y'?: boolean;
+    'enable-back-to-top'?: boolean;
+    'show-scrollbar'?: boolean;
+    'paging-enabled'?: boolean;
+    'upper-threshold'?: number;
+    'lower-threshold'?: number;
+    'scroll-with-animation'?: boolean;
+    'refresher-triggered'?: boolean;
+    'refresher-enabled'?: boolean;
+    'refresher-default-style'?: 'black' | 'white' | 'none';
+    'refresher-background'?: string;
+    'refresher-threshold'?: number;
+    'scroll-top'?: number;
+    'scroll-left'?: number;
+    'enable-offset'?: boolean;
+    'scroll-into-view'?: string;
+    'enable-trigger-intersection-observer'?: boolean;
+    'enable-var'?: boolean;
+    'external-var-context'?: Record<string, any>;
+    'parent-font-size'?: number;
+    'parent-width'?: number;
+    'parent-height'?: number;
+    'enable-sticky'?: boolean;
+    'wait-for'?: Array<GestureHandler>;
+    'simultaneous-handlers'?: Array<GestureHandler>;
+    'scroll-event-throttle'?: number;
+    'scroll-into-view-offset'?: number;
+    bindscrolltoupper?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    bindscrolltolower?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    bindscroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    bindrefresherrefresh?: (event: NativeSyntheticEvent<unknown>) => void;
+    binddragstart?: (event: NativeSyntheticEvent<DragEvent>) => void;
+    binddragging?: (event: NativeSyntheticEvent<DragEvent>) => void;
+    binddragend?: (event: NativeSyntheticEvent<DragEvent>) => void;
+    bindtouchstart?: (event: NativeSyntheticEvent<TouchEvent>) => void;
+    bindtouchmove?: (event: NativeSyntheticEvent<TouchEvent>) => void;
+    bindtouchend?: (event: NativeSyntheticEvent<TouchEvent>) => void;
+    bindscrollend?: (event: NativeSyntheticEvent<TouchEvent>) => void;
+    __selectRef?: (selector: string, nodeType: 'node' | 'component', all?: boolean) => HandlerRef<any, any>;
+}
+declare const _ScrollView: import("react").ForwardRefExoticComponent<ScrollViewProps & import("react").RefAttributes<HandlerRef<import("react").ForwardRefExoticComponent<import("react-native").ScrollViewProps & {
+    children?: ReactNode;
+} & import("react-native-gesture-handler").NativeViewGestureHandlerProps & import("react").RefAttributes<import("react").ComponentType<any>>> & import("react-native").ScrollView & View, ScrollViewProps>>>;
+export default _ScrollView;

package/lib/runtime/components/react/dist/mpx-scroll-view.jsx

@@ -48,8 +48,6 @@ const _ScrollView = forwardRef((scrollViewProps = {}, ref) => {
     const scrollOffset = useRef(new RNAnimated.Value(0)).current;
     const simultaneousHandlers = flatGesture(originSimultaneousHandlers);
     const waitForHandlers = flatGesture(waitFor);
-    const snapScrollTop = useRef(0);
-    const snapScrollLeft = useRef(0);
     const [refreshing, setRefreshing] = useState(false);
     const [enableScroll, setEnableScroll] = useState(true);
     const enableScrollValue = useSharedValue(true);
@@ -127,14 +125,12 @@ const _ScrollView = forwardRef((scrollViewProps = {}, ref) => {
         warn('scroll-x and scroll-y cannot be set to true at the same time, Mpx will use the value of scroll-y as the criterion');
     }
     useEffect(() => {
-        if (snapScrollTop.current !== scrollTop || snapScrollLeft.current !== scrollLeft) {
-            initialTimeout.current = setTimeout(() => {
-                scrollToOffset(scrollLeft, scrollTop);
-            }, 0);
-            return () => {
-                initialTimeout.current && clearTimeout(initialTimeout.current);
-            };
-        }
+        initialTimeout.current = setTimeout(() => {
+            scrollToOffset(scrollLeft, scrollTop);
+        }, 0);
+        return () => {
+            initialTimeout.current && clearTimeout(initialTimeout.current);
+        };
     }, [scrollTop, scrollLeft]);
     useEffect(() => {
         if (scrollIntoView && __selectRef) {
@@ -316,10 +312,6 @@ const _ScrollView = forwardRef((scrollViewProps = {}, ref) => {
     function scrollToOffset(x = 0, y = 0, animated = scrollWithAnimation) {
         if (scrollViewRef.current) {
             scrollViewRef.current.scrollTo({ x, y, animated });
-            scrollOptions.current.scrollLeft = x;
-            scrollOptions.current.scrollTop = y;
-            snapScrollLeft.current = x;
-            snapScrollTop.current = y;
         }
     }
     function onScrollTouchMove(e) {

package/lib/runtime/components/react/dist/mpx-simple-text.d.ts

@@ -0,0 +1,7 @@
+import { TextProps } from 'react-native';
+import { JSX } from 'react';
+declare const SimpleText: {
+    (props: TextProps): JSX.Element;
+    displayName: string;
+};
+export default SimpleText;

package/lib/runtime/components/react/dist/mpx-simple-view.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { ViewProps } from 'react-native';
+declare const SimpleView: {
+    (simpleViewProps: ViewProps): JSX.Element;
+    displayName: string;
+};
+export default SimpleView;

package/lib/runtime/components/react/dist/mpx-slider.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import { View, ViewStyle } from 'react-native';
+import { HandlerRef } from './useNodesRef';
+export interface SliderProps {
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    value?: number;
+    color?: string;
+    'selected-color'?: string;
+    activeColor?: string;
+    backgroundColor?: string;
+    'block-size'?: number;
+    'block-color'?: string;
+    name?: string;
+    bindchange?: (event: any) => void;
+    catchchange?: (event: any) => void;
+    bindchanging?: (event: any) => void;
+    catchchanging?: (event: any) => void;
+    style?: ViewStyle & Record<string, any>;
+    'enable-offset'?: boolean;
+    'enable-var'?: boolean;
+    'external-var-context'?: Record<string, any>;
+    'parent-font-size'?: number;
+    'parent-width'?: number;
+    'parent-height'?: number;
+}
+declare const Slider: import("react").ForwardRefExoticComponent<SliderProps & import("react").RefAttributes<HandlerRef<View, SliderProps>>>;
+export default Slider;

package/lib/runtime/components/react/dist/mpx-sticky-header.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { View, NativeSyntheticEvent, ViewStyle } from 'react-native';
+import { HandlerRef } from './useNodesRef';
+interface StickyHeaderProps {
+    children?: ReactNode;
+    style?: ViewStyle;
+    padding?: [number, number, number, number];
+    'offset-top'?: number;
+    'enable-var'?: boolean;
+    'external-var-context'?: Record<string, any>;
+    'parent-font-size'?: number;
+    'parent-width'?: number;
+    'parent-height'?: number;
+    bindstickontopchange?: (e: NativeSyntheticEvent<unknown>) => void;
+}
+declare const _StickyHeader: import("react").ForwardRefExoticComponent<StickyHeaderProps & import("react").RefAttributes<HandlerRef<View, StickyHeaderProps>>>;
+export default _StickyHeader;

package/lib/runtime/components/react/dist/mpx-sticky-section.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { View, ViewStyle } from 'react-native';
+import { HandlerRef } from './useNodesRef';
+interface StickySectionProps {
+    children?: ReactNode;
+    style?: ViewStyle;
+    'offset-top'?: number;
+    'enable-var'?: boolean;
+    'external-var-context'?: Record<string, any>;
+    'parent-font-size'?: number;
+    'parent-width'?: number;
+    'parent-height'?: number;
+}
+declare const _StickySection: import("react").ForwardRefExoticComponent<StickySectionProps & import("react").RefAttributes<HandlerRef<View, StickySectionProps>>>;
+export default _StickySection;

package/lib/runtime/components/react/dist/mpx-swiper-item.d.ts

@@ -0,0 +1,18 @@
+import { View } from 'react-native';
+import { ReactNode } from 'react';
+import { HandlerRef } from './useNodesRef';
+interface SwiperItemProps {
+    'item-id'?: string;
+    'enable-offset'?: boolean;
+    'enable-var': boolean;
+    'external-var-context'?: Record<string, any>;
+    'parent-font-size'?: number;
+    'parent-width'?: number;
+    'parent-height'?: number;
+    children?: ReactNode;
+    style?: Object;
+    customStyle: Object;
+    itemIndex: number;
+}
+declare const _SwiperItem: import("react").ForwardRefExoticComponent<SwiperItemProps & import("react").RefAttributes<HandlerRef<View, SwiperItemProps>>>;
+export default _SwiperItem;

package/lib/runtime/components/react/dist/mpx-swiper.d.ts

@@ -0,0 +1,63 @@
+import { View, NativeSyntheticEvent } from 'react-native';
+import React, { ReactNode } from 'react';
+import { HandlerRef } from './useNodesRef';
+import { GestureHandler } from './utils';
+/**
+ * ✔ indicator-dots
+ * ✔ indicator-color
+ * ✔ indicator-width
+ * ✔ indicator-height
+ * ✔ indicator-radius
+ * ✔ indicator-spacing
+ * ✔ indicator-margin
+ * ✔ indicator-active-color
+ * ✔ autoplay
+ * ✔ current
+ * ✔ interval
+ * ✔ duration
+ * ✔ circular
+ * ✔ vertical
+ * ✔ previous-margin
+ * ✔ next-margin
+ * ✔ easing-function  ="easeOutCubic"
+ * ✘ display-multiple-items
+ * ✘ snap-to-edge
+ */
+type EaseType = 'default' | 'linear' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic';
+interface SwiperProps {
+    children?: ReactNode;
+    circular?: boolean;
+    current?: number;
+    interval?: number;
+    autoplay?: boolean;
+    duration?: number;
+    scale?: boolean;
+    'indicator-dots'?: boolean;
+    'indicator-color'?: string;
+    'indicator-width'?: number;
+    'indicator-height'?: number;
+    'indicator-spacing'?: number;
+    'indicator-radius'?: number;
+    'indicator-margin'?: number;
+    'indicator-active-color'?: string;
+    vertical?: boolean;
+    style: {
+        [key: string]: any;
+    };
+    'easing-function'?: EaseType;
+    'previous-margin'?: string;
+    'next-margin'?: string;
+    'enable-offset'?: boolean;
+    'enable-var': boolean;
+    'parent-font-size'?: number;
+    'parent-width'?: number;
+    'parent-height'?: number;
+    'external-var-context'?: Record<string, any>;
+    'wait-for'?: Array<GestureHandler>;
+    'simultaneous-handlers'?: Array<GestureHandler>;
+    disableGesture?: boolean;
+    'display-multiple-items'?: number;
+    bindchange?: (event: NativeSyntheticEvent<TouchEvent> | unknown) => void;
+}
+declare const SwiperWrapper: React.ForwardRefExoticComponent<SwiperProps & React.RefAttributes<HandlerRef<View, SwiperProps>>>;
+export default SwiperWrapper;