@sdata/web-vue 1.9.0 → 1.10.0

package/es/_components/virtual-list/virtual-list.vue.d.ts

@@ -1,133 +1,343 @@
-import { PropType, Ref } from 'vue';
-import { ScrollOptions, VirtualListProps } from './interface';
+import { type CSSProperties, type Component, PropType } from 'vue';
+import { type CacheSnapshot, type ClassValue, type DynamicScrollerExposed, type ItemSizeValue, type KeyFieldValue, type KeyValue, type RecycleScrollerExposed, type ScrollDirection } from 'vue-virtual-scroller';
+import type { ScrollbarProps } from '../../scrollbar';
+type ScrollerExpose = RecycleScrollerExposed<any, KeyValue> | DynamicScrollerExposed<any>;
+type ScrollerSlotProps = {
+    item: unknown;
+    index: number;
+    active: boolean;
+    itemWithSize?: Record<string, unknown>;
+};
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    height: {
-        type: PropType<VirtualListProps["height"]>;
-        default: number;
-    };
-    threshold: {
-        type: PropType<VirtualListProps["threshold"]>;
+    items: {
+        type: PropType<unknown[]>;
+        default: () => never[];
     };
-    isStaticItemHeight: {
-        type: BooleanConstructor;
+    height: {
+        type: PropType<number | string>;
+        default: undefined;
     };
-    estimatedItemHeight: {
-        type: NumberConstructor;
+    keyField: {
+        type: PropType<KeyFieldValue<any>>;
+        default: string;
     };
-    data: {
-        type: PropType<VirtualListProps["data"]>;
-        default: () => never[];
+    direction: {
+        type: PropType<ScrollDirection>;
+        default: string;
     };
-    itemKey: {
-        type: PropType<VirtualListProps["itemKey"]>;
+    listTag: {
+        type: StringConstructor;
         default: string;
     };
-    component: {
-        type: PropType<VirtualListProps["component"]>;
+    itemTag: {
+        type: StringConstructor;
         default: string;
     };
-    type: StringConstructor;
-    outerAttrs: ObjectConstructor;
-    innerAttrs: ObjectConstructor;
-}>, {
-    viewportRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
-    viewportHeight: Ref<number, number>;
-    totalHeight: import("vue").ComputedRef<number>;
-    startOffset: Ref<number, number>;
-    isVirtual: import("vue").ComputedRef<boolean>;
-    renderChildren: () => (import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }> | undefined)[];
-    handleResize: (entry: HTMLElement) => void;
-    handleScroll: (e: UIEvent) => void;
-    scrollTo: (options: ScrollOptions) => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("resize" | "scroll")[], "resize" | "scroll", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    height: {
-        type: PropType<VirtualListProps["height"]>;
-        default: number;
+    itemSize: {
+        type: PropType<ItemSizeValue<any>>;
+        default: undefined;
     };
-    threshold: {
-        type: PropType<VirtualListProps["threshold"]>;
+    gridItems: NumberConstructor;
+    itemSecondarySize: NumberConstructor;
+    minItemSize: {
+        type: PropType<number | string | null>;
+        default: undefined;
     };
-    isStaticItemHeight: {
+    sizeField: StringConstructor;
+    typeField: StringConstructor;
+    buffer: NumberConstructor;
+    shift: BooleanConstructor;
+    cache: PropType<CacheSnapshot>;
+    prerender: NumberConstructor;
+    emitUpdate: BooleanConstructor;
+    disableTransform: BooleanConstructor;
+    flowMode: BooleanConstructor;
+    hiddenPosition: NumberConstructor;
+    updateInterval: NumberConstructor;
+    skipHover: BooleanConstructor;
+    enabled: {
         type: BooleanConstructor;
+        default: boolean;
+    };
+    listClass: {
+        type: PropType<ClassValue>;
     };
-    estimatedItemHeight: {
-        type: NumberConstructor;
+    itemClass: {
+        type: PropType<ClassValue>;
     };
-    data: {
-        type: PropType<VirtualListProps["data"]>;
+    scrollbar: {
+        type: PropType<boolean | ScrollbarProps>;
+        default: boolean;
+    };
+}>, {
+    prefixCls: string;
+    hostClassNames: import("vue").ComputedRef<(string | undefined)[]>;
+    scrollbarHostRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    scrollerRef: import("vue").Ref<ScrollerExpose | undefined, ScrollerExpose | undefined>;
+    currentScroller: import("vue").ComputedRef<Component>;
+    isDynamicScroller: import("vue").ComputedRef<boolean>;
+    containerOuterStyle: import("vue").ComputedRef<{
+        height: string;
+    } | undefined>;
+    scrollerStyle: import("vue").ComputedRef<CSSProperties>;
+    scrollerProps: import("vue").ComputedRef<Record<string, unknown>>;
+    scrollerListeners: import("vue").ComputedRef<{
+        resize: () => void;
+        visible: () => void;
+        hidden?: undefined;
+        update?: undefined;
+        scrollStart?: undefined;
+        scrollEnd?: undefined;
+    } | {
+        resize: () => void;
+        visible: () => void;
+        hidden: () => void;
+        update: (startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => void;
+        scrollStart: () => void;
+        scrollEnd: () => void;
+    }>;
+    getSlotItemWithSize: (slotProps: ScrollerSlotProps) => Record<string, unknown> | undefined;
+    onScroll: (ev: Event) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    scroll: (_ev: Event) => true;
+    reachBottom: (_ev: Event) => true;
+    resize: () => true;
+    visible: () => true;
+    hidden: () => true;
+    update: (_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => true;
+    scrollStart: () => true;
+    scrollEnd: () => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    items: {
+        type: PropType<unknown[]>;
         default: () => never[];
     };
-    itemKey: {
-        type: PropType<VirtualListProps["itemKey"]>;
+    height: {
+        type: PropType<number | string>;
+        default: undefined;
+    };
+    keyField: {
+        type: PropType<KeyFieldValue<any>>;
         default: string;
     };
-    component: {
-        type: PropType<VirtualListProps["component"]>;
+    direction: {
+        type: PropType<ScrollDirection>;
         default: string;
     };
-    type: StringConstructor;
-    outerAttrs: ObjectConstructor;
-    innerAttrs: ObjectConstructor;
+    listTag: {
+        type: StringConstructor;
+        default: string;
+    };
+    itemTag: {
+        type: StringConstructor;
+        default: string;
+    };
+    itemSize: {
+        type: PropType<ItemSizeValue<any>>;
+        default: undefined;
+    };
+    gridItems: NumberConstructor;
+    itemSecondarySize: NumberConstructor;
+    minItemSize: {
+        type: PropType<number | string | null>;
+        default: undefined;
+    };
+    sizeField: StringConstructor;
+    typeField: StringConstructor;
+    buffer: NumberConstructor;
+    shift: BooleanConstructor;
+    cache: PropType<CacheSnapshot>;
+    prerender: NumberConstructor;
+    emitUpdate: BooleanConstructor;
+    disableTransform: BooleanConstructor;
+    flowMode: BooleanConstructor;
+    hiddenPosition: NumberConstructor;
+    updateInterval: NumberConstructor;
+    skipHover: BooleanConstructor;
+    enabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    listClass: {
+        type: PropType<ClassValue>;
+    };
+    itemClass: {
+        type: PropType<ClassValue>;
+    };
+    scrollbar: {
+        type: PropType<boolean | ScrollbarProps>;
+        default: boolean;
+    };
 }>> & Readonly<{
-    onResize?: ((...args: any[]) => any) | undefined;
-    onScroll?: ((...args: any[]) => any) | undefined;
+    onResize?: (() => any) | undefined;
+    onScroll?: ((_ev: Event) => any) | undefined;
+    onVisible?: (() => any) | undefined;
+    onUpdate?: ((_startIndex: number, _endIndex: number, _visibleStartIndex: number, _visibleEndIndex: number) => any) | undefined;
+    onHidden?: (() => any) | undefined;
+    onReachBottom?: ((_ev: Event) => any) | undefined;
+    onScrollStart?: (() => any) | undefined;
+    onScrollEnd?: (() => any) | undefined;
 }>, {
-    data: unknown[] | undefined;
+    shift: boolean;
     height: string | number;
-    itemKey: string | undefined;
-    component: keyof HTMLElementTagNameMap | undefined;
-    isStaticItemHeight: boolean;
+    direction: ScrollDirection;
+    emitUpdate: boolean;
+    disableTransform: boolean;
+    flowMode: boolean;
+    skipHover: boolean;
+    items: unknown[];
+    keyField: KeyFieldValue<any>;
+    listTag: string;
+    itemTag: string;
+    itemSize: ItemSizeValue<any>;
+    minItemSize: string | number | null;
+    enabled: boolean;
+    scrollbar: boolean | ScrollbarProps;
 }, {}, {
-    ResizeObserver: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "resize"[], "resize", import("vue").PublicProps, Readonly<{}> & Readonly<{
-        onResize?: ((...args: any[]) => any) | undefined;
-    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-    Filler: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-        height: {
-            type: NumberConstructor;
-        };
-        offset: {
-            type: NumberConstructor;
+    RecycleScroller: <TItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        emit: ((evt: "visible") => void) & ((evt: "hidden") => void) & ((evt: "resize") => void) & ((evt: "update", startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => void) & ((evt: "scrollStart") => void) & ((evt: "scrollEnd") => void);
+        slots: Readonly<{
+            default?: (props: import("vue-virtual-scroller").RecycleScrollerSlotProps<TItem>) => unknown;
+            before?: () => unknown;
+            after?: () => unknown;
+            empty?: () => unknown;
+        }> & {
+            default?: (props: import("vue-virtual-scroller").RecycleScrollerSlotProps<TItem>) => unknown;
+            before?: () => unknown;
+            after?: () => unknown;
+            empty?: () => unknown;
         };
-        disabled: {
-            type: BooleanConstructor;
-        };
-        type: StringConstructor;
-        outerAttrs: ObjectConstructor;
-        innerAttrs: ObjectConstructor;
-    }>, {
-        outerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
-        innerStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
-    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-        height: {
-            type: NumberConstructor;
+        attrs: any;
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            readonly onResize?: (() => any) | undefined | undefined;
+            readonly onVisible?: (() => any) | undefined | undefined;
+            readonly onHidden?: (() => any) | undefined | undefined;
+            readonly onUpdate?: ((startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => any) | undefined | undefined;
+            readonly onScrollStart?: (() => any) | undefined | undefined;
+            readonly onScrollEnd?: (() => any) | undefined | undefined;
+            items: TItem[];
+            keyField?: KeyFieldValue<any> | undefined;
+            direction?: ScrollDirection | undefined;
+            listTag?: string | undefined;
+            itemTag?: string | undefined;
+            itemSize?: ItemSizeValue<TItem> | undefined;
+            gridItems?: number | undefined;
+            itemSecondarySize?: number | undefined;
+            minItemSize?: number | string | null | undefined;
+            sizeField?: string | undefined;
+            typeField?: string | undefined;
+            buffer?: number | undefined;
+            pageMode?: boolean | undefined;
+            shift?: boolean | undefined;
+            cache?: CacheSnapshot | undefined;
+            prerender?: number | undefined;
+            emitUpdate?: boolean | undefined;
+            disableTransform?: boolean | undefined;
+            flowMode?: boolean | undefined;
+            hiddenPosition?: number | undefined;
+            updateInterval?: number | undefined;
+            skipHover?: boolean | undefined;
+            enabled?: boolean | undefined;
+            listClass?: ClassValue | undefined;
+            itemClass?: ClassValue | undefined;
+        } & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<RecycleScrollerExposed<TItem, KeyValue>>): void;
+        attrs: any;
+        slots: Readonly<{
+            default?: (props: import("vue-virtual-scroller").RecycleScrollerSlotProps<TItem>) => unknown;
+            before?: () => unknown;
+            after?: () => unknown;
+            empty?: () => unknown;
+        }> & {
+            default?: (props: import("vue-virtual-scroller").RecycleScrollerSlotProps<TItem>) => unknown;
+            before?: () => unknown;
+            after?: () => unknown;
+            empty?: () => unknown;
         };
-        offset: {
-            type: NumberConstructor;
+        emit: ((evt: "visible") => void) & ((evt: "hidden") => void) & ((evt: "resize") => void) & ((evt: "update", startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => void) & ((evt: "scrollStart") => void) & ((evt: "scrollEnd") => void);
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    DynamicScroller: <TItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        emit: ((evt: "visible") => void) & ((evt: "resize") => void);
+        slots: Readonly<{
+            default?: (props: import("vue-virtual-scroller").DynamicScrollerSlotProps<TItem, KeyValue>) => unknown;
+            before?: () => unknown;
+            after?: () => unknown;
+            empty?: () => unknown;
+        }> & {
+            default?: (props: import("vue-virtual-scroller").DynamicScrollerSlotProps<TItem, KeyValue>) => unknown;
+            before?: () => unknown;
+            after?: () => unknown;
+            empty?: () => unknown;
         };
-        disabled: {
-            type: BooleanConstructor;
+        attrs: any;
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            readonly onResize?: (() => any) | undefined | undefined;
+            readonly onVisible?: (() => any) | undefined | undefined;
+            items: TItem[];
+            keyField?: KeyFieldValue<any> | undefined;
+            direction?: ScrollDirection | undefined;
+            listTag?: string | undefined;
+            itemTag?: string | undefined;
+            minItemSize: number | string;
+            shift?: boolean | undefined;
+            cache?: CacheSnapshot | undefined;
+            disableTransform?: boolean | undefined;
+            flowMode?: boolean | undefined;
+            hiddenPosition?: number | undefined;
+            enabled?: boolean | undefined;
+        } & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<DynamicScrollerExposed<TItem>>): void;
+        attrs: any;
+        slots: Readonly<{
+            default?: (props: import("vue-virtual-scroller").DynamicScrollerSlotProps<TItem, KeyValue>) => unknown;
+            before?: () => unknown;
+            after?: () => unknown;
+            empty?: () => unknown;
+        }> & {
+            default?: (props: import("vue-virtual-scroller").DynamicScrollerSlotProps<TItem, KeyValue>) => unknown;
+            before?: () => unknown;
+            after?: () => unknown;
+            empty?: () => unknown;
         };
-        type: StringConstructor;
-        outerAttrs: ObjectConstructor;
-        innerAttrs: ObjectConstructor;
-    }>> & Readonly<{}>, {
-        disabled: boolean;
-    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-    RenderFunction: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-        renderFunc: {
-            type: PropType<import("../render-function").RenderFunc>;
-            required: true;
+        emit: ((evt: "visible") => void) & ((evt: "resize") => void);
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    DynamicScrollerItem: <TItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        emit: (evt: "resize", id: KeyValue) => void;
+        slots: Readonly<{
+            default?: () => unknown;
+        }> & {
+            default?: () => unknown;
         };
-    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-        renderFunc: {
-            type: PropType<import("../render-function").RenderFunc>;
-            required: true;
+        attrs: any;
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            readonly onResize?: ((id: KeyValue) => any) | undefined | undefined;
+            item: TItem;
+            watchData?: boolean | undefined;
+            active: boolean;
+            index?: number | undefined;
+            sizeDependencies?: (Record<string, unknown> | unknown[] | null) | undefined;
+            emitResize?: boolean | undefined;
+            enabled?: boolean | undefined;
+            tag?: string | undefined;
+        } & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: Readonly<{
+            default?: () => unknown;
+        }> & {
+            default?: () => unknown;
         };
-    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        emit: (evt: "resize", id: KeyValue) => void;
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
 }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;