@raxium/vue-addons-virtual 0.1.1

package/dist/VirtualList.vue.d.ts

@@ -0,0 +1,132 @@
+import type { Virtualizer } from '@tanstack/vue-virtual';
+import type { HTMLAttributes } from 'vue';
+import type { VirtualListProps } from '.';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<VirtualListProps<T> & {
+        unstyled?: boolean;
+        ui?: {
+            viewport?: {
+                class?: HTMLAttributes["class"];
+            };
+            scroll?: {
+                class?: HTMLAttributes["class"];
+            };
+        };
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        readonly virtualizer: {
+            options: {
+                count: number;
+                getScrollElement: () => Element | null;
+                estimateSize: (index: number) => number;
+                scrollToFn: (offset: number, options: {
+                    adjustments?: number;
+                    behavior?: "auto" | "smooth" | "instant";
+                }, instance: Virtualizer<Element, Element>) => void;
+                observeElementRect: (instance: Virtualizer<Element, Element>, cb: (rect: import("@tanstack/vue-virtual").Rect) => void) => void | (() => void);
+                observeElementOffset: (instance: Virtualizer<Element, Element>, cb: (offset: number, isScrolling: boolean) => void) => void | (() => void);
+                debug: boolean;
+                initialRect: {
+                    width: number;
+                    height: number;
+                };
+                onChange: (instance: Virtualizer<Element, Element>, sync: boolean) => void;
+                measureElement: (element: Element, entry: ResizeObserverEntry | undefined, instance: Virtualizer<Element, Element>) => number;
+                overscan: number;
+                horizontal: boolean;
+                paddingStart: number;
+                paddingEnd: number;
+                scrollPaddingStart: number;
+                scrollPaddingEnd: number;
+                initialOffset: number | (() => number);
+                getItemKey: (index: number) => string | number | bigint;
+                rangeExtractor: (range: import("@tanstack/vue-virtual").Range) => Array<number>;
+                scrollMargin: number;
+                gap: number;
+                indexAttribute: string;
+                initialMeasurementsCache: {
+                    key: string | number | bigint;
+                    index: number;
+                    start: number;
+                    end: number;
+                    size: number;
+                    lane: number;
+                }[];
+                lanes: number;
+                isScrollingResetDelay: number;
+                useScrollendEvent: boolean;
+                enabled: boolean;
+                isRtl: boolean;
+                useAnimationFrameWithResizeObserver: boolean;
+            };
+            scrollElement: Element | null;
+            targetWindow: (Window & typeof globalThis) | null;
+            isScrolling: boolean;
+            measurementsCache: {
+                key: string | number | bigint;
+                index: number;
+                start: number;
+                end: number;
+                size: number;
+                lane: number;
+            }[];
+            scrollRect: {
+                width: number;
+                height: number;
+            } | null;
+            scrollOffset: number | null;
+            scrollDirection: ("forward" | "backward") | null;
+            shouldAdjustScrollPositionOnItemSizeChange: ((item: import("@tanstack/vue-virtual").VirtualItem, delta: number, instance: Virtualizer<Element, Element>) => boolean) | undefined;
+            elementsCache: Map<string | number | bigint, Element> & Omit<Map<string | number | bigint, Element>, keyof Map<any, any>>;
+            range: {
+                startIndex: number;
+                endIndex: number;
+            } | null;
+            setOptions: (opts: import("@tanstack/vue-virtual").VirtualizerOptions<Element, Element>) => void;
+            _didMount: () => () => void;
+            _willUpdate: () => void;
+            calculateRange: {
+                (): {
+                    startIndex: number;
+                    endIndex: number;
+                } | null;
+                updateDeps(newDeps: [import("@tanstack/vue-virtual").VirtualItem[], number, number, number]): void;
+            };
+            getVirtualIndexes: {
+                (): number[];
+                updateDeps(newDeps: [(range: import("@tanstack/vue-virtual").Range) => number[], number, number, number | null, number | null]): void;
+            };
+            indexFromElement: (node: Element) => number;
+            measureElement: (node: Element | null) => void;
+            resizeItem: (index: number, size: number) => void;
+            getVirtualItems: {
+                (): import("@tanstack/vue-virtual").VirtualItem[];
+                updateDeps(newDeps: [number[], import("@tanstack/vue-virtual").VirtualItem[]]): void;
+            };
+            getVirtualItemForOffset: (offset: number) => import("@tanstack/vue-virtual").VirtualItem | undefined;
+            getOffsetForAlignment: (toOffset: number, align: "auto" | "end" | "start" | "center", itemSize?: number) => number;
+            getOffsetForIndex: (index: number, align?: "auto" | "end" | "start" | "center") => readonly [number, "auto"] | readonly [number, "start" | "center" | "end"] | undefined;
+            scrollToOffset: (toOffset: number, { align, behavior }?: import("@tanstack/vue-virtual").ScrollToOptions) => void;
+            scrollToIndex: (index: number, { align: initialAlign, behavior, }?: import("@tanstack/vue-virtual").ScrollToOptions) => void;
+            scrollBy: (delta: number, { behavior }?: import("@tanstack/vue-virtual").ScrollToOptions) => void;
+            getTotalSize: () => number;
+            measure: () => void;
+        } | null;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default: () => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/VirtualListImpl.js

@@ -0,0 +1,174 @@
+import { Fragment, cloneVNode, computed, createBlock, createElementBlock, createElementVNode, createPropsRestProxy, defineComponent, h, normalizeClass, normalizeStyle, openBlock, renderList, resolveDynamicComponent, unref, useTemplateRef } from "vue";
+import { cn } from "@raxium/themes/utils";
+import { useForwardProps } from "@raxium/vue-addons-shared";
+import { useVirtualizer } from "@tanstack/vue-virtual";
+import { merge } from "es-toolkit/compat";
+import { injectVirtualContext } from "./index.js";
+import { useDetectSlotNode } from "./useDetectSlotNode.js";
+const _hoisted_1 = [
+    "data-horizontal"
+];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "VirtualListImpl",
+    props: {
+        dataSource: {},
+        estimateSize: {
+            type: Function
+        },
+        scrollToFn: {
+            type: Function
+        },
+        observeElementRect: {
+            type: Function
+        },
+        observeElementOffset: {
+            type: Function
+        },
+        debug: {
+            type: Boolean
+        },
+        initialRect: {},
+        onChange: {
+            type: Function
+        },
+        measureElement: {
+            type: Function
+        },
+        overscan: {},
+        horizontal: {
+            type: Boolean
+        },
+        paddingStart: {},
+        paddingEnd: {},
+        scrollPaddingStart: {},
+        scrollPaddingEnd: {},
+        initialOffset: {
+            type: [
+                Number,
+                Function
+            ]
+        },
+        getItemKey: {
+            type: Function
+        },
+        rangeExtractor: {
+            type: Function
+        },
+        scrollMargin: {},
+        gap: {},
+        indexAttribute: {},
+        initialMeasurementsCache: {},
+        lanes: {},
+        isScrollingResetDelay: {},
+        useScrollendEvent: {
+            type: Boolean
+        },
+        isRtl: {
+            type: Boolean
+        },
+        useAnimationFrameWithResizeObserver: {
+            type: Boolean
+        },
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        ui: {}
+    },
+    setup (__props, { expose: __expose }) {
+        const props = createPropsRestProxy(__props, [
+            "class",
+            "dataSource",
+            "ui"
+        ]);
+        const virtualContext = injectVirtualContext();
+        const parentEl = useTemplateRef("parentEl");
+        virtualContext.parentEl = parentEl;
+        const forwarded = useForwardProps(props);
+        const virtualOptions = computed(()=>{
+            const _staticOptions = {
+                enabled: true,
+                count: virtualContext.enableInfinite.value ? __props.dataSource.length + 1 : __props.dataSource.length,
+                overscan: forwarded.value.overscan ?? 1,
+                getScrollElement: ()=>parentEl.value,
+                estimateSize: (index)=>forwarded.value.estimateSize?.(index) ?? 30
+            };
+            return merge({}, forwarded.value, _staticOptions);
+        });
+        const virtualizer = useVirtualizer(virtualOptions);
+        virtualContext.virtualizer = virtualizer;
+        const { itemVNode, infiniteVNode } = useDetectSlotNode();
+        const virtualizedItems = computed(()=>virtualizer.value.getVirtualItems().map((virtualItem)=>{
+                const _realIndex = virtualItem.index;
+                const renderNode = _realIndex < __props.dataSource.length ? itemVNode : infiniteVNode;
+                return {
+                    vItem: virtualItem,
+                    is: cloneVNode(renderNode ?? h("div"), {
+                        data: __props.dataSource[_realIndex],
+                        index: _realIndex,
+                        key: `${virtualItem.key}`,
+                        "data-index": _realIndex,
+                        "aria-setsize": __props.dataSource.length,
+                        "aria-posinset": _realIndex + 1,
+                        style: forwarded.value.horizontal ? {
+                            position: "absolute",
+                            top: 0,
+                            left: 0,
+                            transform: `translateX(${virtualItem.start}px)`,
+                            overflowAnchor: "none"
+                        } : {
+                            position: "absolute",
+                            top: 0,
+                            left: 0,
+                            transform: `translateY(${virtualItem.start}px)`,
+                            overflowAnchor: "none"
+                        }
+                    })
+                };
+            }));
+        const scrollAreaStyle = computed(()=>{
+            const totalSize = virtualizer.value.getTotalSize();
+            if (forwarded.value.horizontal) return {
+                width: `${totalSize}px`,
+                height: "100%",
+                position: "relative"
+            };
+            return {
+                height: `${totalSize}px`,
+                width: "100%",
+                position: "relative"
+            };
+        });
+        __expose({
+            get virtualizer () {
+                return virtualizer.value;
+            }
+        });
+        return (_ctx, _cache)=>(openBlock(), createElementBlock("div", {
+                ref_key: "parentEl",
+                ref: parentEl,
+                class: normalizeClass(unref(cn)("rui-virtual-list", __props.ui?.root, __props.class)),
+                "data-horizontal": unref(forwarded).horizontal ? true : void 0,
+                "data-scope": "virtual-list",
+                "data-part": "root"
+            }, [
+                createElementVNode("div", {
+                    class: normalizeClass(unref(cn)("rui-virtual-list_scroll", __props.ui?.scroll)),
+                    style: normalizeStyle(scrollAreaStyle.value),
+                    "data-scope": "virtual-list",
+                    "data-part": "scroll"
+                }, [
+                    (openBlock(true), createElementBlock(Fragment, null, renderList(virtualizedItems.value, ({ is, vItem })=>(openBlock(), createBlock(resolveDynamicComponent(is), {
+                            key: vItem.key
+                        }))), 128))
+                ], 6)
+            ], 10, _hoisted_1));
+    }
+});
+const VirtualListImpl = _sfc_main;
+export default VirtualListImpl;

package/dist/VirtualListImpl.vue.d.ts

@@ -0,0 +1,30 @@
+import type { HTMLAttributes } from 'vue';
+import type { VirtualListProps } from '.';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<VirtualListProps<T> & {
+        class?: HTMLAttributes["class"];
+        ui?: {
+            root?: HTMLAttributes["class"];
+            scroll?: HTMLAttributes["class"];
+        };
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        readonly virtualizer: import("@tanstack/vue-virtual").Virtualizer<Element, Element>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        default?: () => any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/VirtualListItem.js

@@ -0,0 +1,48 @@
+import { createElementBlock, defineComponent, mergeProps, openBlock, renderSlot, unref, useTemplateRef, watch } from "vue";
+import { cn } from "@raxium/themes/utils";
+import { injectVirtualContext } from "./VirtualRoot.js";
+const _hoisted_1 = [
+    "data-index"
+];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+    name: "VirtualListItem",
+    __name: "VirtualListItem",
+    props: {
+        class: {
+            type: [
+                Boolean,
+                null,
+                String,
+                Object,
+                Array
+            ]
+        },
+        data: {},
+        dynamic: {
+            type: Boolean
+        },
+        index: {}
+    },
+    setup (__props) {
+        const { virtualizer } = injectVirtualContext();
+        const el = useTemplateRef("el");
+        watch(el, (el)=>{
+            if (virtualizer?.value && el && __props.dynamic) virtualizer.value.measureElement(el);
+        });
+        return (_ctx, _cache)=>(openBlock(), createElementBlock("div", mergeProps(_ctx.$attrs, {
+                ref_key: "el",
+                ref: el,
+                "data-index": __props.index,
+                class: unref(cn)("rui-virtual-list-item", __props.class),
+                "data-scope": "virtual-list",
+                "data-part": "item"
+            }), [
+                renderSlot(_ctx.$slots, "default", {
+                    data: __props.data,
+                    index: __props.index
+                })
+            ], 16, _hoisted_1));
+    }
+});
+const VirtualListItem = _sfc_main;
+export default VirtualListItem;

package/dist/VirtualListItem.vue.d.ts

@@ -0,0 +1,29 @@
+import type { HTMLAttributes } from 'vue';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        class?: HTMLAttributes["class"];
+        data?: T;
+        dynamic?: boolean;
+        index?: number;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default: {
+            data: T;
+            index?: number;
+        };
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/VirtualRoot.d.ts

@@ -0,0 +1,7 @@
+import type { VirtualContext } from '.';
+declare const injectVirtualContext: <T extends VirtualContext | null | undefined = VirtualContext>(fallback?: T | undefined) => T extends null ? VirtualContext | null : VirtualContext;
+export { injectVirtualContext };
+declare const _default: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/VirtualRoot.js

@@ -0,0 +1,17 @@
+import { createContext } from "@raxium/vue-addons-shared";
+import { defineComponent, ref } from "vue";
+import { LOADING_STATE } from "./index.js";
+const [injectVirtualContext, provideVirtualContext] = createContext('VirtualContext');
+const VirtualRoot = defineComponent({
+    setup (_, { slots }) {
+        const enableInfinite = ref(false);
+        const infiniteState = ref(LOADING_STATE.IDLE);
+        provideVirtualContext({
+            enableInfinite,
+            infiniteState
+        });
+        return ()=>slots.default?.();
+    }
+});
+export default VirtualRoot;
+export { injectVirtualContext };

package/dist/index.css

@@ -0,0 +1,122 @@
+@layer theme {
+  @keyframes spin {
+    from {
+      transform: rotate(0deg);
+    }
+    to {
+      transform: rotate(360deg);
+    }
+  }
+}
+
+@layer components {
+  .rui-virtual-list, .rui-virtual-grid {
+    width: 100%;
+    height: 100%;
+    overflow: auto;
+    overflow-anchor: none;
+    overscroll-behavior: contain;
+  
+    & [data-part='scroll'] {
+      position: relative;
+    }
+  }
+  
+  
+  .rui-virtual-infinite {
+    width: 100%;
+    height: auto;
+    &[data-size='xs'] {
+      height: .75rem;
+    }
+    &[data-size='sm'] {
+      height: .875rem;
+    }
+    &[data-size='base'] {
+      height: 1rem;
+    }
+    &[data-size='lg'] {
+      height: 1.125rem;
+    }
+  
+    & [data-part='loading'] {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      &[data-size='xs'] {
+        padding: 0 .375rem
+      }
+      &[data-size='sm'] {
+        padding: 0 .5rem;
+      }
+      &[data-size='base'] {
+        padding: 0 .625rem;
+      }
+      &[data-size='lg'] {
+        padding: 0 .75rem;
+      }
+    }
+  
+    & [data-part='spinner'] {
+      animation: spin 1s linear infinite;
+      &[data-size='xs'] {
+        width: 1.25rem;
+        height: 1.25rem;
+      }
+      &[data-size='sm'] {
+        width: 1.5rem;
+        height: 1.5rem;
+      }
+      &[data-size='base'] {
+        width: 1.75rem;
+        height: 1.75rem;
+      }
+      &[data-size='lg'] {
+        width: 2rem;
+        height: 2rem;
+      }
+    }
+  
+    & [data-part='complete'] {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      &[data-size='xs'] {
+        padding: 0 .375rem;
+      }
+      &[data-size='sm'] {
+        padding: 0 .5rem;
+      }
+      &[data-size='base'] {
+        padding: 0 .625rem;
+      }
+      &[data-size='lg'] {
+        padding: 0 .75rem;
+      }
+    }
+  
+    & [data-part='error'] {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      &[data-size='xs'] {
+        padding: 0 .375rem;
+        gap: .25rem
+      }
+      &[data-size='sm'] {
+        padding: 0 .5rem;
+        gap: .375rem
+      }
+      &[data-size='base'] {
+        padding: 0 .625rem;
+        gap: .5rem
+      }
+      &[data-size='lg'] {
+        padding: 0 .75rem;
+        gap: .625rem
+      }
+    }
+  }
+}
+

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './props';
+export { default as VirtualGrid } from './VirtualGrid.vue';
+export { default as VirtualGridItem } from './VirtualGridItem.vue';
+export { default as VirtualInfiniteLoading } from './VirtualInfiniteLoading.vue';
+export { default as VirtualList } from './VirtualList.vue';
+export { default as VirtualListItem } from './VirtualListItem.vue';
+export { injectVirtualContext, default as VirtualRoot } from './VirtualRoot.tsx';

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./props.js";
+export { default as VirtualGrid } from "./VirtualGrid.js";
+export { default as VirtualGridItem } from "./VirtualGridItem.js";
+export { default as VirtualInfiniteLoading } from "./VirtualInfiniteLoading.js";
+export { default as VirtualList } from "./VirtualList.js";
+export { default as VirtualListItem } from "./VirtualListItem.js";
+export { default as VirtualRoot, injectVirtualContext } from "./VirtualRoot.js";

package/dist/props.d.ts

@@ -0,0 +1,38 @@
+import type { Virtualizer, VirtualizerOptions } from '@tanstack/vue-virtual';
+import type { Ref, ShallowRef } from 'vue';
+export interface VirtualContext {
+    parentEl?: Ref<Element | null | undefined>;
+    virtualizer?: ShallowRef<Virtualizer<Element, Element>>;
+    rowVirtualizer?: ShallowRef<Virtualizer<Element, Element>>;
+    columnVirtualizer?: ShallowRef<Virtualizer<Element, Element>>;
+    enableInfinite: Ref<boolean>;
+    infiniteState: Ref<LOADING_STATE>;
+}
+export interface VirtualListProps<T> extends Omit<VirtualizerOptions<Element, Element>, 'enabled' | 'count' | 'getScrollElement' | 'estimateSize' | 'scrollToFn' | 'observeElementRect' | 'observeElementOffset'> {
+    dataSource: Array<T>;
+    estimateSize?: VirtualizerOptions<Element, Element>['estimateSize'];
+    scrollToFn?: VirtualizerOptions<Element, Element>['scrollToFn'];
+    observeElementRect?: VirtualizerOptions<Element, Element>['observeElementRect'];
+    observeElementOffset?: VirtualizerOptions<Element, Element>['observeElementOffset'];
+}
+export interface VirtualGridProps<T> {
+    dataSource: Array<T>;
+    row?: number;
+    column?: number;
+    gap?: [number, number];
+    rowVirtualizerOptions?: Omit<VirtualListProps<T>, 'dataSource'>;
+    columnVirtualizerOptions?: Omit<VirtualListProps<T>, 'dataSource'>;
+}
+export declare enum LOADING_STATE {
+    IDLE = "idle",
+    LOADING = "loading",
+    LOADED = "loaded",
+    COMPLETE = "complete",
+    ERROR = "error"
+}
+export interface LoadingStateHandler {
+    loading: () => void;
+    loaded: () => void;
+    complete: () => void;
+    error: () => void;
+}

package/dist/props.js

@@ -0,0 +1,9 @@
+var props_LOADING_STATE = /*#__PURE__*/ function(LOADING_STATE) {
+    LOADING_STATE["IDLE"] = "idle";
+    LOADING_STATE["LOADING"] = "loading";
+    LOADING_STATE["LOADED"] = "loaded";
+    LOADING_STATE["COMPLETE"] = "complete";
+    LOADING_STATE["ERROR"] = "error";
+    return LOADING_STATE;
+}({});
+export { props_LOADING_STATE as LOADING_STATE };

package/dist/useDetectSlotNode.d.ts

@@ -0,0 +1,7 @@
+import type { VNode } from 'vue';
+export declare function useDetectSlotNode(): {
+    itemVNode: VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | null;
+    infiniteVNode: null;
+};

package/dist/useDetectSlotNode.js

@@ -0,0 +1,24 @@
+import { Fragment, useSlots } from "vue";
+import { injectVirtualContext } from "./VirtualRoot.js";
+function useDetectSlotNode() {
+    const slots = useSlots();
+    const defaultSlotNode = slots.default()[0];
+    const virtualContext = injectVirtualContext();
+    let itemVNode = null;
+    let infiniteVNode = null;
+    if (defaultSlotNode.type === Fragment && Array.isArray(defaultSlotNode.children)) defaultSlotNode.children.forEach((child)=>{
+        if (child) {
+            const _cname = child.type.name;
+            if ('VirtualInfiniteLoading' === _cname) {
+                infiniteVNode = child;
+                virtualContext.enableInfinite.value = true;
+            } else if ('VirtualListItem' === _cname || 'VirtualGridItem' === _cname) itemVNode = child;
+        }
+    });
+    else itemVNode = defaultSlotNode;
+    return {
+        itemVNode,
+        infiniteVNode
+    };
+}
+export { useDetectSlotNode };