@vunk/plus 1.14.0 → 1.16.0

package/vue-virtual-scroller/src/components/DynamicScroller.vue.d.ts

@@ -0,0 +1,52 @@
+import type { CacheSnapshot, DynamicScrollerExposed, DynamicScrollerSlotProps, KeyFieldValue, KeyValue, ScrollDirection } from '../types';
+declare const __VLS_export: <TItem>(__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<{
+        items: TItem[];
+        keyField?: KeyFieldValue<any>;
+        direction?: ScrollDirection;
+        listTag?: string;
+        itemTag?: string;
+        minItemSize: number | string;
+        shift?: boolean;
+        cache?: CacheSnapshot;
+        disableTransform?: boolean;
+        flowMode?: boolean;
+        hiddenPosition?: number;
+        enabled?: boolean;
+        /**
+         * Mirror of `RecycleScroller`'s `pageMode`: render against an outer scroll
+         * parent (page or ancestor) instead of giving the scroller its own
+         * scrollable box.
+         */
+        pageMode?: boolean;
+        /**
+         * Override the auto-detected scroll-parent used when `pageMode` is on.
+         * Accepts an HTMLElement or `Window`. When omitted, the closest scrollable
+         * ancestor is used. See issue #928.
+         */
+        scrollParent?: HTMLElement | Window;
+    } & {
+        onVisible?: (() => any) | undefined;
+        onResize?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<DynamicScrollerExposed<TItem>>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: DynamicScrollerSlotProps<TItem, KeyValue>) => unknown;
+        before?: () => unknown;
+        after?: () => unknown;
+        empty?: () => unknown;
+    };
+    emit: ((evt: "visible") => void) & ((evt: "resize") => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<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/vue-virtual-scroller/src/components/DynamicScrollerItem.vue.d.ts

@@ -0,0 +1,36 @@
+import type { KeyValue } from '../types';
+declare const __VLS_export: <TItem>(__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<{
+        item: TItem;
+        watchData?: boolean;
+        active: boolean;
+        index?: number;
+        /**
+         * @deprecated `sizeDependencies` is a legacy fallback for environments without
+         * `ResizeObserver` and will be removed in the next major release.
+         */
+        sizeDependencies?: Record<string, unknown> | unknown[] | null;
+        emitResize?: boolean;
+        enabled?: boolean;
+        tag?: string;
+    } & {
+        onResize?: ((id: KeyValue) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: () => unknown;
+    };
+    emit: (evt: "resize", id: KeyValue) => void;
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<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/vue-virtual-scroller/src/components/ItemView.vue.d.ts

@@ -0,0 +1,24 @@
+import type { RecycleScrollerSlotProps, View } from '../types';
+declare const __VLS_export: <TItem, TKey>(__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<{
+        view: View<TItem, TKey>;
+        itemTag: string;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: RecycleScrollerSlotProps<TItem>) => unknown;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<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/vue-virtual-scroller/src/components/RecycleScroller.vue.d.ts

@@ -0,0 +1,65 @@
+import type { CacheSnapshot, ClassValue, ItemSizeValue, KeyFieldValue, KeyValue, RecycleScrollerExposed, RecycleScrollerSlotProps, ScrollDirection } from '../types';
+declare const __VLS_export: <TItem>(__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<{
+        items: TItem[];
+        keyField?: KeyFieldValue<any>;
+        direction?: ScrollDirection;
+        listTag?: string;
+        itemTag?: string;
+        itemSize?: ItemSizeValue<TItem>;
+        gridItems?: number;
+        itemSecondarySize?: number;
+        minItemSize?: number | string | null;
+        sizeField?: string;
+        typeField?: string;
+        buffer?: number;
+        pageMode?: boolean;
+        /**
+         * Override the auto-detected scroll-parent used when `pageMode` is on.
+         * Accepts an HTMLElement (typically an `overflow:auto` ancestor) or
+         * `Window`. When omitted, the scroller walks the DOM for the nearest
+         * scrollable ancestor. See issue #928.
+         */
+        scrollParent?: HTMLElement | Window;
+        shift?: boolean;
+        cache?: CacheSnapshot;
+        prerender?: number;
+        emitUpdate?: boolean;
+        disableTransform?: boolean;
+        flowMode?: boolean;
+        hiddenPosition?: number;
+        updateInterval?: number;
+        itemsLimit?: number;
+        skipHover?: boolean;
+        enabled?: boolean;
+        listClass?: ClassValue;
+        itemClass?: ClassValue;
+    } & {
+        onVisible?: (() => any) | undefined;
+        onHidden?: (() => any) | undefined;
+        onResize?: (() => any) | undefined;
+        onUpdate?: ((startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => any) | undefined;
+        onScrollStart?: (() => any) | undefined;
+        onScrollEnd?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<RecycleScrollerExposed<TItem, KeyValue>>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: RecycleScrollerSlotProps<TItem>) => unknown;
+        before?: () => unknown;
+        after?: () => unknown;
+        empty?: () => unknown;
+    };
+    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?: NonNullable<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/vue-virtual-scroller/src/components/ResizeObserver.vue.d.ts

@@ -0,0 +1,7 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    notify: () => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onNotify?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/vue-virtual-scroller/src/components/WindowScroller.vue.d.ts

@@ -0,0 +1,54 @@
+import type { CacheSnapshot, ClassValue, ItemSizeValue, KeyFieldValue, KeyValue, RecycleScrollerSlotProps, ScrollDirection, WindowScrollerExposed } from '../types';
+declare const __VLS_export: <TItem>(__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<{
+        items: TItem[];
+        keyField?: KeyFieldValue<any>;
+        direction?: ScrollDirection;
+        listTag?: string;
+        itemTag?: string;
+        itemSize?: ItemSizeValue<TItem>;
+        gridItems?: number;
+        itemSecondarySize?: number;
+        minItemSize?: number | string | null;
+        sizeField?: string;
+        typeField?: string;
+        buffer?: number;
+        shift?: boolean;
+        cache?: CacheSnapshot;
+        prerender?: number;
+        emitUpdate?: boolean;
+        disableTransform?: boolean;
+        flowMode?: boolean;
+        hiddenPosition?: number;
+        updateInterval?: number;
+        itemsLimit?: number;
+        enabled?: boolean;
+        listClass?: ClassValue;
+        itemClass?: ClassValue;
+    } & {
+        onVisible?: (() => any) | undefined;
+        onHidden?: (() => any) | undefined;
+        onResize?: (() => any) | undefined;
+        onUpdate?: ((startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<WindowScrollerExposed<TItem, KeyValue>>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: RecycleScrollerSlotProps<TItem>) => unknown;
+        before?: () => unknown;
+        after?: () => unknown;
+        empty?: () => unknown;
+    };
+    emit: ((evt: "visible") => void) & ((evt: "hidden") => void) & ((evt: "resize") => void) & ((evt: "update", startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<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/vue-virtual-scroller/src/composables/dynamicScrollerMeasureQueue.d.ts

@@ -0,0 +1,19 @@
+import type { KeyValue } from '../types';
+export interface DynamicScrollerMeasureTask {
+    read: () => unknown;
+    write: (value: unknown) => void;
+    done: () => void;
+}
+export interface DynamicScrollerMeasureQueue {
+    schedule: (id: KeyValue, task: DynamicScrollerMeasureTask) => void;
+    cancel: (id: KeyValue) => void;
+}
+export interface DynamicScrollerMeasureQueueOptions {
+    queueFlush?: (flush: () => void) => void;
+    overflowQueueFlush?: (flush: () => void) => void;
+    maxTasksPerFlush?: number;
+}
+/**
+ * Batch DOM reads so dynamic measurements do not interleave read/write work per row.
+ */
+export declare function createDynamicScrollerMeasureQueue(options?: DynamicScrollerMeasureQueueOptions): DynamicScrollerMeasureQueue;

package/vue-virtual-scroller/src/composables/dynamicScrollerMeasurement.d.ts

@@ -0,0 +1,41 @@
+import type { ComputedRef, MaybeRefOrGetter } from 'vue';
+import type { KeyValue, ScrollDirection, VScrollData } from '../types';
+import type { DynamicScrollerMeasureQueue } from './dynamicScrollerMeasureQueue';
+export interface DynamicScrollerUpdatePayload {
+    force: boolean;
+}
+export interface DynamicScrollerMeasurementContext {
+    vscrollData: VScrollData;
+    resizeObserver: ResizeObserver | undefined;
+    measureQueue: DynamicScrollerMeasureQueue;
+    direction: ComputedRef<ScrollDirection>;
+    undefinedMap: Record<string | number, boolean | undefined>;
+    undefinedSizeCount: {
+        value: number;
+    };
+    onVscrollUpdate: (callback: (payload: DynamicScrollerUpdatePayload) => void) => () => void;
+}
+export interface DynamicScrollerItemControllerOptions<TItem = unknown> {
+    item: TItem;
+    watchData: boolean;
+    active: boolean;
+    index?: number;
+    /**
+     * @deprecated `sizeDependencies` is a legacy fallback for environments without
+     * `ResizeObserver` and will be removed in the next major release.
+     */
+    sizeDependencies?: Record<string, unknown> | unknown[] | null;
+    emitResize: boolean;
+}
+export interface DynamicScrollerItemControllerCallbacks {
+    onResize?: (id: KeyValue) => void;
+}
+export interface DynamicScrollerItemController {
+    id: ComputedRef<KeyValue>;
+    size: ComputedRef<number>;
+    finalActive: ComputedRef<boolean>;
+    updateSize: () => void;
+    mount: () => void;
+    unmount: () => void;
+}
+export declare function createDynamicScrollerItemController(options: MaybeRefOrGetter<DynamicScrollerItemControllerOptions<any>>, el: MaybeRefOrGetter<HTMLElement | undefined>, context: DynamicScrollerMeasurementContext, callbacks?: MaybeRefOrGetter<DynamicScrollerItemControllerCallbacks | undefined>): DynamicScrollerItemController;

package/vue-virtual-scroller/src/composables/scrollerOptions.d.ts

@@ -0,0 +1,66 @@
+import type { ComputedRef, MaybeRefOrGetter } from 'vue';
+/**
+ * Shared lifecycle callbacks exposed by headless scroller composables.
+ */
+export interface ScrollerCallbacks {
+    onResize?: () => void;
+    onVisible?: () => void;
+    onHidden?: () => void;
+    onUpdate?: (startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => void;
+}
+/**
+ * Shared activation flag for headless scroller composables.
+ */
+export interface ScrollerOptionEnabled {
+    /**
+     * When `false`, the composable mounts in a passive state: no watchers,
+     * observers, scroll/resize listeners, RAFs, or timers are attached, and
+     * exported reactive sources stay at their inert defaults. Toggling back
+     * to `true` re-arms the scroller without remounting the consumer.
+     *
+     * Useful for call sites that want a stable composable invocation but
+     * conditionally render virtualized output (e.g. an opt-in `virtualize`
+     * prop on a wrapping component).
+     *
+     * @default true
+     */
+    enabled?: MaybeRefOrGetter<boolean>;
+}
+/**
+ * Common single-object inputs for headless scroller composables.
+ *
+ * `scrollParent` overrides the auto-detected scroll parent used by page mode
+ * (issue #928). Accepts an `HTMLElement` to listen and measure against, or
+ * `Window` to force the page itself as the viewport. When omitted, the
+ * scroller walks the DOM via `getScrollParent` for the nearest overflow:auto
+ * ancestor and falls back to `window`.
+ */
+export interface ScrollerOptionElements {
+    el?: MaybeRefOrGetter<HTMLElement | undefined>;
+    before?: MaybeRefOrGetter<HTMLElement | undefined>;
+    after?: MaybeRefOrGetter<HTMLElement | undefined>;
+    scrollParent?: MaybeRefOrGetter<HTMLElement | Window | undefined>;
+}
+/**
+ * Common single-object callback hooks for headless scroller composables.
+ */
+export interface ScrollerOptionCallbacks extends ScrollerCallbacks {
+}
+/**
+ * Normalized element refs and callback hooks resolved from either object or legacy positional inputs.
+ */
+export interface NormalizedScrollerInputs {
+    el: ComputedRef<HTMLElement | undefined>;
+    before: ComputedRef<HTMLElement | undefined>;
+    after: ComputedRef<HTMLElement | undefined>;
+    scrollParent: ComputedRef<HTMLElement | Window | undefined>;
+    callbacks: ScrollerCallbacks;
+}
+/**
+ * Cache single-object scroller options so getter-based callers do not rebuild the object on every access.
+ */
+export declare function resolveScrollerOptions<TOptions>(options: MaybeRefOrGetter<TOptions>): ComputedRef<TOptions>;
+/**
+ * Resolve shared scroller inputs while keeping `items` and DOM refs as separate reactive sources.
+ */
+export declare function normalizeScrollerInputs<TOptions extends ScrollerOptionElements & ScrollerOptionCallbacks>(options: MaybeRefOrGetter<TOptions>, el?: MaybeRefOrGetter<HTMLElement | undefined>, before?: MaybeRefOrGetter<HTMLElement | undefined>, after?: MaybeRefOrGetter<HTMLElement | undefined>, callbacks?: ScrollerCallbacks): NormalizedScrollerInputs;

package/vue-virtual-scroller/src/composables/useDynamicScroller.d.ts

@@ -0,0 +1,109 @@
+import type { ComputedRef, CSSProperties, Directive, MaybeRefOrGetter, Ref } from 'vue';
+import type { CacheSnapshot, DefaultKeyField, DynamicScrollerView, ItemKey, ItemWithSize, KeyFieldValue, KeyValue, ScrollDirection, ValidKeyField, VScrollData } from '../types';
+import type { DynamicScrollerItemControllerCallbacks, DynamicScrollerItemControllerOptions, DynamicScrollerMeasurementContext } from './dynamicScrollerMeasurement';
+import type { ScrollerOptionEnabled } from './scrollerOptions';
+import type { UseRecycleScrollerReturn } from './useRecycleScroller';
+export interface UseDynamicScrollerItemViewBindingOptions<TItem = unknown, TKey = KeyValue> {
+    view: DynamicScrollerView<TItem, TKey>;
+    watchData?: boolean;
+    /**
+     * @deprecated `sizeDependencies` is a legacy fallback for environments without
+     * `ResizeObserver` and will be removed in the next major release.
+     */
+    sizeDependencies?: Record<string, unknown> | unknown[] | null;
+    emitResize?: boolean;
+    onResize?: DynamicScrollerItemControllerCallbacks['onResize'];
+}
+interface UseDynamicScrollerItemLegacyBindingOptions<TItem = unknown> extends Omit<DynamicScrollerItemControllerOptions<TItem>, 'watchData' | 'emitResize'> {
+    watchData?: boolean;
+    emitResize?: boolean;
+    onResize?: DynamicScrollerItemControllerCallbacks['onResize'];
+}
+export type UseDynamicScrollerItemBindingOptions<TItem = unknown, TKey = KeyValue> = UseDynamicScrollerItemViewBindingOptions<TItem, TKey> | UseDynamicScrollerItemLegacyBindingOptions<TItem>;
+export interface UseDynamicScrollerOptions<TItem = unknown> extends ScrollerOptionEnabled {
+    items: MaybeRefOrGetter<TItem[]>;
+    keyField: KeyFieldValue<TItem>;
+    direction?: ScrollDirection;
+    minItemSize: number | string;
+    el: MaybeRefOrGetter<HTMLElement | undefined>;
+    before?: MaybeRefOrGetter<HTMLElement | undefined>;
+    after?: MaybeRefOrGetter<HTMLElement | undefined>;
+    /**
+     * Override the auto-detected scroll-parent used by page mode. Accepts an
+     * `HTMLElement` (typically an `overflow:auto` ancestor) or `Window`. When
+     * omitted, the scroller walks the DOM for the nearest scrollable ancestor.
+     * See issue #928.
+     */
+    scrollParent?: MaybeRefOrGetter<HTMLElement | Window | undefined>;
+    buffer?: number;
+    pageMode?: boolean;
+    shift?: boolean;
+    cache?: CacheSnapshot;
+    disableTransform?: boolean;
+    flowMode?: boolean;
+    hiddenPosition?: number;
+    prerender?: number;
+    emitUpdate?: boolean;
+    updateInterval?: number;
+    onResize?: () => void;
+    onVisible?: () => void;
+    onHidden?: () => void;
+    onUpdate?: (startIndex: number, endIndex: number, visibleStartIndex: number, visibleEndIndex: number) => void;
+}
+type UseDynamicScrollerRecycleReturn<TItem, TKey> = UseRecycleScrollerReturn<ItemWithSize<TItem, TKey>, TKey>;
+type UseDynamicScrollerSizes<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['sizes'];
+type UseDynamicScrollerReady<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['ready'];
+type UseDynamicScrollerPool<TItem, TKey> = Ref<Array<DynamicScrollerView<TItem, TKey>>>;
+type UseDynamicScrollerVisiblePool<TItem, TKey> = ComputedRef<Array<DynamicScrollerView<TItem, TKey>>>;
+type UseDynamicScrollerHandleResize<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['handleResize'];
+type UseDynamicScrollerHandleVisibilityChange<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['handleVisibilityChange'];
+type UseDynamicScrollerGetScroll<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['getScroll'];
+type UseDynamicScrollerFindItemIndex<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['findItemIndex'];
+type UseDynamicScrollerGetItemOffset<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['getItemOffset'];
+type UseDynamicScrollerScrollToItem<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['scrollToItem'];
+type UseDynamicScrollerScrollToPosition<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['scrollToPosition'];
+type UseDynamicScrollerSortViews<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['sortViews'];
+type UseDynamicScrollerTotalSize<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['totalSize'];
+type UseDynamicScrollerUpdateVisibleItems<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['updateVisibleItems'];
+type UseDynamicScrollerCacheSnapshot<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['cacheSnapshot'];
+type UseDynamicScrollerRestoreCache<TItem, TKey> = UseDynamicScrollerRecycleReturn<TItem, TKey>['restoreCache'];
+type ResolvedDynamicScrollerItems<TOptions extends UseDynamicScrollerOptions<any>> = TOptions['items'] extends MaybeRefOrGetter<infer TItems extends any[]> ? TItems : never;
+type InferredDynamicScrollerItem<TOptions extends UseDynamicScrollerOptions<any>> = ResolvedDynamicScrollerItems<TOptions>[number];
+type InferredDynamicScrollerKeyField<TOptions extends UseDynamicScrollerOptions<any>> = Extract<TOptions['keyField'], KeyFieldValue<InferredDynamicScrollerItem<TOptions>>>;
+export interface UseDynamicScrollerReturn<TItem = unknown, TKey = ItemKey<TItem>> {
+    vscrollData: VScrollData;
+    itemsWithSize: ComputedRef<Array<ItemWithSize<TItem, TKey>>>;
+    simpleArray: ComputedRef<boolean>;
+    resizeObserver: ResizeObserver | undefined;
+    measurementContext: DynamicScrollerMeasurementContext;
+    vDynamicScrollerItem: Directive<HTMLElement, UseDynamicScrollerItemBindingOptions<TItem, TKey>>;
+    pool: UseDynamicScrollerPool<TItem, TKey>;
+    visiblePool: UseDynamicScrollerVisiblePool<TItem, TKey>;
+    totalSize: UseDynamicScrollerTotalSize<TItem, TKey>;
+    startSpacerSize: UseDynamicScrollerRecycleReturn<TItem, TKey>['startSpacerSize'];
+    endSpacerSize: UseDynamicScrollerRecycleReturn<TItem, TKey>['endSpacerSize'];
+    ready: UseDynamicScrollerReady<TItem, TKey>;
+    sizes: UseDynamicScrollerSizes<TItem, TKey>;
+    forceUpdate: (clear?: boolean) => void;
+    scrollToItem: UseDynamicScrollerScrollToItem<TItem, TKey>;
+    scrollToPosition: UseDynamicScrollerScrollToPosition<TItem, TKey>;
+    getScroll: UseDynamicScrollerGetScroll<TItem, TKey>;
+    findItemIndex: UseDynamicScrollerFindItemIndex<TItem, TKey>;
+    getItemOffset: UseDynamicScrollerGetItemOffset<TItem, TKey>;
+    updateVisibleItems: UseDynamicScrollerUpdateVisibleItems<TItem, TKey>;
+    handleResize: UseDynamicScrollerHandleResize<TItem, TKey>;
+    handleVisibilityChange: UseDynamicScrollerHandleVisibilityChange<TItem, TKey>;
+    sortViews: UseDynamicScrollerSortViews<TItem, TKey>;
+    cacheSnapshot: UseDynamicScrollerCacheSnapshot<TItem, TKey>;
+    restoreCache: UseDynamicScrollerRestoreCache<TItem, TKey>;
+    getItemSize: (item: TItem, index?: number) => number;
+    getViewStyle: (view: DynamicScrollerView<TItem, TKey>) => CSSProperties;
+    scrollToBottom: () => void;
+    onScrollerResize: () => void;
+    onScrollerVisible: () => void;
+}
+export declare function useDynamicScroller<TItem, TKeyField extends KeyFieldValue<TItem> = DefaultKeyField<TItem>>(options: MaybeRefOrGetter<UseDynamicScrollerOptions<TItem> & {
+    keyField: ValidKeyField<TItem, TKeyField>;
+}>): UseDynamicScrollerReturn<TItem, ItemKey<TItem, TKeyField>>;
+export declare function useDynamicScroller<TOptions extends UseDynamicScrollerOptions<any>>(options: MaybeRefOrGetter<TOptions>): UseDynamicScrollerReturn<InferredDynamicScrollerItem<TOptions>, ItemKey<InferredDynamicScrollerItem<TOptions>, InferredDynamicScrollerKeyField<TOptions>>>;
+export {};

package/vue-virtual-scroller/src/composables/useDynamicScrollerItem.d.ts

@@ -0,0 +1,21 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { KeyValue } from '../types';
+import type { DynamicScrollerItemControllerOptions } from './dynamicScrollerMeasurement';
+import type { ScrollerOptionEnabled } from './scrollerOptions';
+import { createDynamicScrollerItemController } from './dynamicScrollerMeasurement';
+export interface UseDynamicScrollerItemOptions<TItem = unknown> extends DynamicScrollerItemControllerOptions<TItem>, ScrollerOptionEnabled {
+    el: MaybeRefOrGetter<HTMLElement | undefined>;
+    onResize?: (id: KeyValue) => void;
+}
+export interface UseDynamicScrollerItemLegacyOptions<TItem = unknown> extends DynamicScrollerItemControllerOptions<TItem>, ScrollerOptionEnabled {
+}
+export interface UseDynamicScrollerItemReturn {
+    id: ReturnType<typeof createDynamicScrollerItemController>['id'];
+    size: ReturnType<typeof createDynamicScrollerItemController>['size'];
+    finalActive: ReturnType<typeof createDynamicScrollerItemController>['finalActive'];
+    updateSize: ReturnType<typeof createDynamicScrollerItemController>['updateSize'];
+}
+export declare function useDynamicScrollerItem<TItem>(options: MaybeRefOrGetter<UseDynamicScrollerItemOptions<TItem>>): UseDynamicScrollerItemReturn;
+export declare function useDynamicScrollerItem<TItem>(options: MaybeRefOrGetter<UseDynamicScrollerItemLegacyOptions<TItem>>, el: MaybeRefOrGetter<HTMLElement | undefined>, callbacks?: {
+    onResize?: (id: KeyValue) => void;
+}): UseDynamicScrollerItemReturn;

package/vue-virtual-scroller/src/composables/useIdState.d.ts

@@ -0,0 +1,7 @@
+type IdPropFn = (vm: any) => string | number;
+export declare function useIdState({ idProp, }?: {
+    idProp?: IdPropFn | string;
+}): {
+    idState: import("vue").Ref<unknown, unknown>;
+};
+export {};

package/vue-virtual-scroller/src/composables/useRecycleScroller.d.ts

@@ -0,0 +1,65 @@
+import type { ComputedRef, CSSProperties, MaybeRefOrGetter, Ref } from 'vue';
+import type { CacheSnapshot, DefaultKeyField, ItemKey, ItemSizeValue, KeyFieldValue, ScrollDirection, ScrollState, ScrollToOptions, Sizes, ValidKeyField, ValidSizeField, View } from '../types';
+import type { ScrollerCallbacks, ScrollerOptionCallbacks, ScrollerOptionElements, ScrollerOptionEnabled } from './scrollerOptions';
+export interface UseRecycleScrollerOptions<TItem = unknown, TSizeField extends string = 'size'> extends ScrollerOptionElements, ScrollerOptionCallbacks, ScrollerOptionEnabled {
+    items: MaybeRefOrGetter<TItem[]>;
+    keyField: KeyFieldValue<TItem>;
+    direction?: ScrollDirection;
+    itemSize: ItemSizeValue<TItem>;
+    gridItems?: number;
+    itemSecondarySize?: number;
+    minItemSize: number | string | null;
+    sizeField?: ValidSizeField<TItem, TSizeField>;
+    typeField: string;
+    buffer: number;
+    pageMode: boolean;
+    shift?: boolean;
+    cache?: CacheSnapshot;
+    prerender: number;
+    emitUpdate: boolean;
+    disableTransform?: boolean;
+    flowMode?: boolean;
+    /**
+     * Park recycled hidden views at custom main-axis position.
+     */
+    hiddenPosition?: number;
+    updateInterval: number;
+    /**
+     * Maximum views this scroller may render before reporting a missing scroll boundary.
+     * Positive values override the global limit for this instance.
+     */
+    itemsLimit?: number;
+}
+export interface UseRecycleScrollerReturn<TItem = unknown, TKey = ItemKey<TItem>> {
+    pool: Ref<Array<View<TItem, TKey>>>;
+    visiblePool: ComputedRef<Array<View<TItem, TKey>>>;
+    totalSize: Ref<number>;
+    startSpacerSize: Ref<number>;
+    endSpacerSize: Ref<number>;
+    ready: Ref<boolean>;
+    sizes: ComputedRef<Sizes | never[]>;
+    simpleArray: ComputedRef<boolean>;
+    scrollToItem: (index: number, options?: ScrollToOptions) => void;
+    scrollToPosition: (position: number, options?: ScrollToOptions) => void;
+    getScroll: () => ScrollState;
+    findItemIndex: (offset: number) => number;
+    getItemOffset: (index: number) => number;
+    getItemSize: (index: number) => number;
+    getViewStyle: (view: View<TItem, TKey>) => CSSProperties;
+    cacheSnapshot: ComputedRef<CacheSnapshot>;
+    restoreCache: (snapshot: CacheSnapshot | null | undefined) => boolean;
+    updateVisibleItems: (itemsChanged: boolean, checkPositionDiff?: boolean) => {
+        continuous: boolean;
+    };
+    handleResize: () => void;
+    handleVisibilityChange: (isVisible: boolean, entry: IntersectionObserverEntry) => void;
+    sortViews: () => void;
+}
+type ResolvedRecycleScrollerItems<TOptions extends UseRecycleScrollerOptions<any, any>> = TOptions['items'] extends MaybeRefOrGetter<infer TItems extends any[]> ? TItems : never;
+type InferredRecycleScrollerItem<TOptions extends UseRecycleScrollerOptions<any, any>> = ResolvedRecycleScrollerItems<TOptions>[number];
+type InferredRecycleScrollerKeyField<TOptions extends UseRecycleScrollerOptions<any, any>> = Extract<TOptions['keyField'], KeyFieldValue<InferredRecycleScrollerItem<TOptions>>>;
+export declare function useRecycleScroller<TItem, TKeyField extends KeyFieldValue<TItem> = DefaultKeyField<TItem>, TSizeField extends string = 'size'>(options: MaybeRefOrGetter<UseRecycleScrollerOptions<TItem, TSizeField> & {
+    keyField: ValidKeyField<TItem, TKeyField>;
+}>, el?: MaybeRefOrGetter<HTMLElement | undefined>, before?: MaybeRefOrGetter<HTMLElement | undefined>, after?: MaybeRefOrGetter<HTMLElement | undefined>, callbacks?: ScrollerCallbacks): UseRecycleScrollerReturn<TItem, ItemKey<TItem, TKeyField>>;
+export declare function useRecycleScroller<TOptions extends UseRecycleScrollerOptions<any, any>>(options: MaybeRefOrGetter<TOptions>, el?: MaybeRefOrGetter<HTMLElement | undefined>, before?: MaybeRefOrGetter<HTMLElement | undefined>, after?: MaybeRefOrGetter<HTMLElement | undefined>, callbacks?: ScrollerCallbacks): UseRecycleScrollerReturn<InferredRecycleScrollerItem<TOptions>, ItemKey<InferredRecycleScrollerItem<TOptions>, InferredRecycleScrollerKeyField<TOptions>>>;
+export {};

package/vue-virtual-scroller/src/composables/useTableColumnWidths.d.ts

@@ -0,0 +1,28 @@
+import type { ComputedRef, CSSProperties, MaybeRefOrGetter } from 'vue';
+import type { ScrollerOptionEnabled } from './scrollerOptions';
+/**
+ * Options for table column width locking.
+ */
+export interface UseTableColumnWidthsOptions extends ScrollerOptionEnabled {
+    table: MaybeRefOrGetter<HTMLTableElement | undefined>;
+    dependencies?: MaybeRefOrGetter<unknown[] | Record<string, unknown> | null>;
+    /**
+     * @deprecated Use `enabled: false` (the inverse) for parity with sibling
+     * scroller composables. `disabled` continues to work for backward compat.
+     */
+    disabled?: MaybeRefOrGetter<boolean>;
+}
+/**
+ * Public state returned by `useTableColumnWidths`.
+ */
+export interface UseTableColumnWidthsReturn {
+    columnWidths: ComputedRef<number[]>;
+    hasLockedWidths: ComputedRef<boolean>;
+    tableStyle: ComputedRef<CSSProperties | undefined>;
+    scheduleMeasure: () => void;
+    clear: () => void;
+}
+/**
+ * Measure native table columns and expose locked widths for a `<colgroup>`.
+ */
+export declare function useTableColumnWidths(options: UseTableColumnWidthsOptions): UseTableColumnWidthsReturn;

package/vue-virtual-scroller/src/composables/useWindowScroller.d.ts

@@ -0,0 +1,17 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { DefaultKeyField, ItemKey, KeyFieldValue, ValidKeyField } from '../types';
+import type { ScrollerCallbacks } from './scrollerOptions';
+import type { UseRecycleScrollerOptions, UseRecycleScrollerReturn } from './useRecycleScroller';
+export interface UseWindowScrollerOptions<TItem = unknown, TSizeField extends string = 'size'> extends Omit<UseRecycleScrollerOptions<TItem, TSizeField>, 'pageMode'> {
+    pageMode?: boolean;
+}
+export interface UseWindowScrollerReturn<TItem = unknown, TKey = ItemKey<TItem>> extends UseRecycleScrollerReturn<TItem, TKey> {
+}
+type ResolvedWindowScrollerItems<TOptions extends UseWindowScrollerOptions<any, any>> = TOptions['items'] extends MaybeRefOrGetter<infer TItems extends any[]> ? TItems : never;
+type InferredWindowScrollerItem<TOptions extends UseWindowScrollerOptions<any, any>> = ResolvedWindowScrollerItems<TOptions>[number];
+type InferredWindowScrollerKeyField<TOptions extends UseWindowScrollerOptions<any, any>> = Extract<TOptions['keyField'], KeyFieldValue<InferredWindowScrollerItem<TOptions>>>;
+export declare function useWindowScroller<TItem, TKeyField extends KeyFieldValue<TItem> = DefaultKeyField<TItem>, TSizeField extends string = 'size'>(options: MaybeRefOrGetter<UseWindowScrollerOptions<TItem, TSizeField> & {
+    keyField: ValidKeyField<TItem, TKeyField>;
+}>, el?: MaybeRefOrGetter<HTMLElement | undefined>, before?: MaybeRefOrGetter<HTMLElement | undefined>, after?: MaybeRefOrGetter<HTMLElement | undefined>, callbacks?: ScrollerCallbacks): UseWindowScrollerReturn<TItem, ItemKey<TItem, TKeyField>>;
+export declare function useWindowScroller<TOptions extends UseWindowScrollerOptions<any, any>>(options: MaybeRefOrGetter<TOptions>, el?: MaybeRefOrGetter<HTMLElement | undefined>, before?: MaybeRefOrGetter<HTMLElement | undefined>, after?: MaybeRefOrGetter<HTMLElement | undefined>, callbacks?: ScrollerCallbacks): UseWindowScrollerReturn<InferredWindowScrollerItem<TOptions>, ItemKey<InferredWindowScrollerItem<TOptions>, InferredWindowScrollerKeyField<TOptions>>>;
+export {};

package/vue-virtual-scroller/src/config.d.ts

@@ -0,0 +1,7 @@
+export interface VirtualScrollerConfig {
+    itemsLimit: number;
+    installComponents?: boolean;
+    componentsPrefix?: string;
+}
+declare const config: VirtualScrollerConfig;
+export default config;

package/vue-virtual-scroller/src/directives/observeVisibility.d.ts

@@ -0,0 +1,8 @@
+import type { Directive } from 'vue';
+type ObserveVisibilityCallback = (isVisible: boolean, entry: IntersectionObserverEntry) => void;
+interface ObserveVisibilityValue {
+    callback: ObserveVisibilityCallback;
+    intersection?: IntersectionObserverInit;
+}
+export declare const ObserveVisibility: Directive<Element, ObserveVisibilityCallback | ObserveVisibilityValue>;
+export {};