virtua 0.48.8 → 0.49.0

package/lib/vue/VList.d.ts

@@ -1,126 +1,26 @@
 /** @jsxImportSource vue */
-import { type ComponentOptionsMixin, type SlotsType, type VNode, type PropType } from "vue";
-import { type VirtualizerHandle } from "./Virtualizer.js";
-import { type ItemProps } from "./utils.js";
-import { type CacheSnapshot } from "../core/index.js";
-interface VListHandle extends VirtualizerHandle {
+import { type VNode, type PublicProps } from "vue";
+import { VirtualizerProps, type VirtualizerHandle } from "./Virtualizer.js";
+/**
+ * Methods of {@link VList}.
+ */
+export interface VListHandle extends VirtualizerHandle {
 }
-export declare const VList: import("vue").DefineComponent<{
-    /**
-     * The data items rendered by this component.
-     */
-    data: {
-        type: ArrayConstructor;
-        required: true;
-    };
-    /**
-     * Extra item space in pixels to render before/after the viewport. The minimum value is 0. Lower value will give better performance but you can increase to avoid showing blank items in fast scrolling.
-     * @defaultValue 200
-     */
-    bufferSize: NumberConstructor;
-    /**
-     * Item size hint for unmeasured items in pixels. It will help to reduce scroll jump when items are measured if used properly.
-     *
-     * - If not set, initial item sizes will be automatically estimated from measured sizes. This is recommended for most cases.
-     * - If set, you can opt out estimation and use the value as initial item size.
-     */
-    itemSize: NumberConstructor;
-    /**
-     * While true is set, scroll position will be maintained from the end not usual start when items are added to/removed from start. It's recommended to set false if you add to/remove from mid/end of the list because it can cause unexpected behavior. This prop is useful for reverse infinite scrolling.
-     */
-    shift: BooleanConstructor;
-    /**
-     * If true, rendered as a horizontally scrollable list. Otherwise rendered as a vertically scrollable list.
-     */
-    horizontal: BooleanConstructor;
-    /**
-     * A prop for SSR. If set, the specified amount of items will be mounted in the initial rendering regardless of the container size until hydrated. The minimum value is 0.
-     */
-    ssrCount: NumberConstructor;
-    /**
-     * A function that provides properties/attributes for item element
-     *
-     * **This prop will be merged into `item` prop in the future**
-     */
-    itemProps: PropType<ItemProps>;
-    /**
-     * List of indexes that should be always mounted, even when off screen.
-     */
-    keepMounted: PropType<readonly number[]>;
-    /**
-     * You can restore cache by passing a {@link CacheSnapshot} on mount. This is useful when you want to restore scroll position after navigation. The snapshot can be obtained from {@link VirtualizerHandle.cache}.
-     *
-     * **The length of items should be the same as when you take the snapshot, otherwise restoration may not work as expected.**
-     */
-    cache: PropType<CacheSnapshot>;
-}, VListHandle, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
-    /**
-     * Callback invoked whenever scroll offset changes.
-     * @param offset Current scrollTop, or scrollLeft if horizontal: true.
-     */
-    scroll: (offset: number) => void;
-    /**
-     * Callback invoked when scrolling stops.
-     */
-    scrollEnd: () => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    /**
-     * The data items rendered by this component.
-     */
-    data: {
-        type: ArrayConstructor;
-        required: true;
+/**
+ * Props of {@link VList}.
+ */
+export interface VListProps<T = unknown> extends PublicProps, Pick<VirtualizerProps<T>, "data" | "bufferSize" | "itemSize" | "shift" | "horizontal" | "cache" | "ssrCount" | "itemProps" | "onScroll" | "onScrollEnd" | "keepMounted"> {
+}
+interface VListInstance<T = unknown> extends VListHandle {
+    $props: VListProps<T>;
+    $slots: {
+        default: (arg: {
+            item: T;
+            index: number;
+        }) => VNode[];
     };
-    /**
-     * Extra item space in pixels to render before/after the viewport. The minimum value is 0. Lower value will give better performance but you can increase to avoid showing blank items in fast scrolling.
-     * @defaultValue 200
-     */
-    bufferSize: NumberConstructor;
-    /**
-     * Item size hint for unmeasured items in pixels. It will help to reduce scroll jump when items are measured if used properly.
-     *
-     * - If not set, initial item sizes will be automatically estimated from measured sizes. This is recommended for most cases.
-     * - If set, you can opt out estimation and use the value as initial item size.
-     */
-    itemSize: NumberConstructor;
-    /**
-     * While true is set, scroll position will be maintained from the end not usual start when items are added to/removed from start. It's recommended to set false if you add to/remove from mid/end of the list because it can cause unexpected behavior. This prop is useful for reverse infinite scrolling.
-     */
-    shift: BooleanConstructor;
-    /**
-     * If true, rendered as a horizontally scrollable list. Otherwise rendered as a vertically scrollable list.
-     */
-    horizontal: BooleanConstructor;
-    /**
-     * A prop for SSR. If set, the specified amount of items will be mounted in the initial rendering regardless of the container size until hydrated. The minimum value is 0.
-     */
-    ssrCount: NumberConstructor;
-    /**
-     * A function that provides properties/attributes for item element
-     *
-     * **This prop will be merged into `item` prop in the future**
-     */
-    itemProps: PropType<ItemProps>;
-    /**
-     * List of indexes that should be always mounted, even when off screen.
-     */
-    keepMounted: PropType<readonly number[]>;
-    /**
-     * You can restore cache by passing a {@link CacheSnapshot} on mount. This is useful when you want to restore scroll position after navigation. The snapshot can be obtained from {@link VirtualizerHandle.cache}.
-     *
-     * **The length of items should be the same as when you take the snapshot, otherwise restoration may not work as expected.**
-     */
-    cache: PropType<CacheSnapshot>;
-}>> & {
-    onScroll?: ((offset: number) => any) | undefined;
-    onScrollEnd?: (() => any) | undefined;
-}, {
-    shift: boolean;
-    horizontal: boolean;
-}, SlotsType<{
-    default: (arg: {
-        item: any;
-        index: number;
-    }) => VNode[];
-}>>;
+}
+export declare const VList: {
+    new <T = unknown>(props: VListProps<T>): VListInstance<T>;
+};
 export {};

package/lib/vue/Virtualizer.d.ts

@@ -1,228 +1,145 @@
 /** @jsxImportSource vue */
-import { type VNode, type ComponentOptionsMixin, type SlotsType, type PropType, type NativeElements } from "vue";
+import { type VNode, type PublicProps, type NativeElements } from "vue";
 import { type ScrollToIndexOpts, type CacheSnapshot } from "../core/index.js";
 import { type ItemProps } from "./utils.js";
-export interface VirtualizerHandle {
-    /**
-     * Get current {@link CacheSnapshot}.
-     */
-    readonly cache: CacheSnapshot;
-    /**
-     * Get current scrollTop, or scrollLeft if horizontal: true.
-     */
-    readonly scrollOffset: number;
-    /**
-     * Get current scrollHeight, or scrollWidth if horizontal: true.
-     */
-    readonly scrollSize: number;
-    /**
-     * Get current offsetHeight, or offsetWidth if horizontal: true.
-     */
-    readonly viewportSize: number;
-    /**
-     * Find nearest item index from offset.
-     * @param offset offset in pixels from the start of the scroll container
-     */
-    findItemIndex(offset: number): number;
-    /**
-     * Get item offset from start.
-     * @param index index of item
-     */
-    getItemOffset(index: number): number;
-    /**
-     * Get item size.
-     * @param index index of item
-     */
-    getItemSize(index: number): number;
-    /**
-     * Scroll to the item specified by index.
-     * @param index index of item
-     * @param opts options
-     */
-    scrollToIndex(index: number, opts?: ScrollToIndexOpts): void;
-    /**
-     * Scroll to the given offset.
-     * @param offset offset from start
-     */
-    scrollTo(offset: number): void;
-    /**
-     * Scroll by the given offset.
-     * @param offset offset from current position
-     */
-    scrollBy(offset: number): void;
-}
-export declare const Virtualizer: import("vue").DefineComponent<{
+/**
+ * Props of {@link Virtualizer}.
+ */
+export interface VirtualizerProps<T = unknown> extends PublicProps {
     /**
      * The data items rendered by this component.
      */
-    data: {
-        type: ArrayConstructor;
-        required: true;
-    };
+    data: T[];
     /**
      * Extra item space in pixels to render before/after the viewport. The minimum value is 0. Lower value will give better performance but you can increase to avoid showing blank items in fast scrolling.
      * @defaultValue 200
      */
-    bufferSize: NumberConstructor;
+    bufferSize?: number;
     /**
      * Item size hint for unmeasured items in pixels. It will help to reduce scroll jump when items are measured if used properly.
      *
      * - If not set, initial item sizes will be automatically estimated from measured sizes. This is recommended for most cases.
      * - If set, you can opt out estimation and use the value as initial item size.
      */
-    itemSize: NumberConstructor;
+    itemSize?: number;
     /**
      * While true is set, scroll position will be maintained from the end not usual start when items are added to/removed from start. It's recommended to set false if you add to/remove from mid/end of the list because it can cause unexpected behavior. This prop is useful for reverse infinite scrolling.
      */
-    shift: BooleanConstructor;
+    shift?: boolean;
     /**
      * If true, rendered as a horizontally scrollable list. Otherwise rendered as a vertically scrollable list.
      */
-    horizontal: BooleanConstructor;
+    horizontal?: boolean;
     /**
      * The offset to the scrollable parent before virtualizer in pixels. If you put an element before virtualizer, you have to set its height to this prop.
      */
-    startMargin: {
-        type: NumberConstructor;
-        default: number;
-    };
+    startMargin?: number;
     /**
      * A prop for SSR. If set, the specified amount of items will be mounted in the initial rendering regardless of the container size until hydrated. The minimum value is 0.
      */
-    ssrCount: NumberConstructor;
+    ssrCount?: number;
     /**
      * Reference to the scrollable element. The default will get the direct parent element of virtualizer.
      */
-    scrollRef: PropType<HTMLElement>;
+    scrollRef?: HTMLElement;
     /**
      * Component or element type for container element.
      * @defaultValue "div"
      */
-    as: {
-        type: PropType<keyof NativeElements>;
-        default: string;
-    };
+    as?: keyof NativeElements;
     /**
      * Component or element type for item element.
      * @defaultValue "div"
      */
-    item: {
-        type: PropType<keyof NativeElements>;
-        default: string;
-    };
+    item?: keyof NativeElements;
     /**
      * A function that provides properties/attributes for item element
      *
      * **This prop will be merged into `item` prop in the future**
      */
-    itemProps: PropType<ItemProps>;
+    itemProps?: ItemProps<T>;
     /**
      * List of indexes that should be always mounted, even when off screen.
      */
-    keepMounted: PropType<readonly number[]>;
+    keepMounted?: readonly number[];
     /**
      * You can restore cache by passing a {@link CacheSnapshot} on mount. This is useful when you want to restore scroll position after navigation. The snapshot can be obtained from {@link VirtualizerHandle.cache}.
      *
      * **The length of items should be the same as when you take the snapshot, otherwise restoration may not work as expected.**
      */
-    cache: PropType<CacheSnapshot>;
-}, VirtualizerHandle, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    cache?: CacheSnapshot;
     /**
      * Callback invoked whenever scroll offset changes.
      * @param offset Current scrollTop, or scrollLeft if horizontal: true.
      */
-    scroll: (offset: number) => void;
+    onScroll?: (offset: number) => void;
     /**
      * Callback invoked when scrolling stops.
      */
-    scrollEnd: () => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    /**
-     * The data items rendered by this component.
-     */
-    data: {
-        type: ArrayConstructor;
-        required: true;
+    onScrollEnd?: () => void;
+}
+interface VirtualizerInstance<T = unknown> extends VirtualizerHandle {
+    $props: VirtualizerProps<T>;
+    $slots: {
+        default: (arg: {
+            item: T;
+            index: number;
+        }) => VNode[];
     };
+}
+/**
+ * Methods of {@link Virtualizer}.
+ */
+export interface VirtualizerHandle {
     /**
-     * Extra item space in pixels to render before/after the viewport. The minimum value is 0. Lower value will give better performance but you can increase to avoid showing blank items in fast scrolling.
-     * @defaultValue 200
-     */
-    bufferSize: NumberConstructor;
-    /**
-     * Item size hint for unmeasured items in pixels. It will help to reduce scroll jump when items are measured if used properly.
-     *
-     * - If not set, initial item sizes will be automatically estimated from measured sizes. This is recommended for most cases.
-     * - If set, you can opt out estimation and use the value as initial item size.
-     */
-    itemSize: NumberConstructor;
-    /**
-     * While true is set, scroll position will be maintained from the end not usual start when items are added to/removed from start. It's recommended to set false if you add to/remove from mid/end of the list because it can cause unexpected behavior. This prop is useful for reverse infinite scrolling.
+     * Get current {@link CacheSnapshot}.
      */
-    shift: BooleanConstructor;
+    readonly cache: CacheSnapshot;
     /**
-     * If true, rendered as a horizontally scrollable list. Otherwise rendered as a vertically scrollable list.
+     * Get current scrollTop, or scrollLeft if horizontal: true.
      */
-    horizontal: BooleanConstructor;
+    readonly scrollOffset: number;
     /**
-     * The offset to the scrollable parent before virtualizer in pixels. If you put an element before virtualizer, you have to set its height to this prop.
+     * Get current scrollHeight, or scrollWidth if horizontal: true.
      */
-    startMargin: {
-        type: NumberConstructor;
-        default: number;
-    };
+    readonly scrollSize: number;
     /**
-     * A prop for SSR. If set, the specified amount of items will be mounted in the initial rendering regardless of the container size until hydrated. The minimum value is 0.
+     * Get current offsetHeight, or offsetWidth if horizontal: true.
      */
-    ssrCount: NumberConstructor;
+    readonly viewportSize: number;
     /**
-     * Reference to the scrollable element. The default will get the direct parent element of virtualizer.
+     * Find nearest item index from offset.
+     * @param offset offset in pixels from the start of the scroll container
      */
-    scrollRef: PropType<HTMLElement>;
+    findItemIndex(offset: number): number;
     /**
-     * Component or element type for container element.
-     * @defaultValue "div"
+     * Get item offset from start.
+     * @param index index of item
      */
-    as: {
-        type: PropType<keyof NativeElements>;
-        default: string;
-    };
+    getItemOffset(index: number): number;
     /**
-     * Component or element type for item element.
-     * @defaultValue "div"
+     * Get item size.
+     * @param index index of item
      */
-    item: {
-        type: PropType<keyof NativeElements>;
-        default: string;
-    };
+    getItemSize(index: number): number;
     /**
-     * A function that provides properties/attributes for item element
-     *
-     * **This prop will be merged into `item` prop in the future**
+     * Scroll to the item specified by index.
+     * @param index index of item
+     * @param opts options
      */
-    itemProps: PropType<ItemProps>;
+    scrollToIndex(index: number, opts?: ScrollToIndexOpts): void;
     /**
-     * List of indexes that should be always mounted, even when off screen.
+     * Scroll to the given offset.
+     * @param offset offset from start
      */
-    keepMounted: PropType<readonly number[]>;
+    scrollTo(offset: number): void;
     /**
-     * You can restore cache by passing a {@link CacheSnapshot} on mount. This is useful when you want to restore scroll position after navigation. The snapshot can be obtained from {@link VirtualizerHandle.cache}.
-     *
-     * **The length of items should be the same as when you take the snapshot, otherwise restoration may not work as expected.**
+     * Scroll by the given offset.
+     * @param offset offset from current position
      */
-    cache: PropType<CacheSnapshot>;
-}>> & {
-    onScroll?: ((offset: number) => any) | undefined;
-    onScrollEnd?: (() => any) | undefined;
-}, {
-    shift: boolean;
-    horizontal: boolean;
-    startMargin: number;
-    as: keyof import("vue").IntrinsicElementAttributes;
-    item: keyof import("vue").IntrinsicElementAttributes;
-}, SlotsType<{
-    default: (arg: {
-        item: any;
-        index: number;
-    }) => VNode[];
-}>>;
+    scrollBy(offset: number): void;
+}
+export declare const Virtualizer: {
+    new <T = unknown>(props: VirtualizerProps<T>): VirtualizerInstance<T>;
+};
+export {};

package/lib/vue/WindowVirtualizer.d.ts

@@ -1,161 +1,107 @@
 /** @jsxImportSource vue */
-import { type VNode, type ComponentOptionsMixin, type SlotsType, type PropType, type NativeElements } from "vue";
+import { type VNode, type PublicProps, type IntrinsicElementAttributes } from "vue";
 import { type ScrollToIndexOpts, type CacheSnapshot } from "../core/index.js";
-export interface WindowVirtualizerHandle {
-    /**
-     * Get current {@link CacheSnapshot}.
-     */
-    readonly cache: CacheSnapshot;
-    /**
-     * Get current scrollTop, or scrollLeft if horizontal: true.
-     */
-    readonly scrollOffset: number;
-    /**
-     * Get current offsetHeight, or offsetWidth if horizontal: true.
-     */
-    readonly viewportSize: number;
-    /**
-     * Find nearest item index from offset.
-     * @param offset offset in pixels from the start of the scroll container
-     */
-    findItemIndex(offset: number): number;
-    /**
-     * Get item offset from start.
-     * @param index index of item
-     */
-    getItemOffset(index: number): number;
-    /**
-     * Get item size.
-     * @param index index of item
-     */
-    getItemSize(index: number): number;
-    /**
-     * Scroll to the item specified by index.
-     * @param index index of item
-     * @param opts options
-     */
-    scrollToIndex(index: number, opts?: ScrollToIndexOpts): void;
-}
-export declare const WindowVirtualizer: import("vue").DefineComponent<{
+/**
+ * Props of {@link WindowVirtualizer}.
+ */
+export interface WindowVirtualizerProps<T = unknown> extends PublicProps {
     /**
      * The data items rendered by this component.
      */
-    data: {
-        type: ArrayConstructor;
-        required: true;
-    };
+    data: T[];
     /**
      * Extra item space in pixels to render before/after the viewport. The minimum value is 0. Lower value will give better performance but you can increase to avoid showing blank items in fast scrolling.
      * @defaultValue 200
      */
-    bufferSize: NumberConstructor;
+    bufferSize?: number;
     /**
      * Item size hint for unmeasured items in pixels. It will help to reduce scroll jump when items are measured if used properly.
      *
      * - If not set, initial item sizes will be automatically estimated from measured sizes. This is recommended for most cases.
      * - If set, you can opt out estimation and use the value as initial item size.
      */
-    itemSize: NumberConstructor;
+    itemSize?: number;
     /**
      * While true is set, scroll position will be maintained from the end not usual start when items are added to/removed from start. It's recommended to set false if you add to/remove from mid/end of the list because it can cause unexpected behavior. This prop is useful for reverse infinite scrolling.
      */
-    shift: BooleanConstructor;
+    shift?: boolean;
     /**
      * If true, rendered as a horizontally scrollable list. Otherwise rendered as a vertically scrollable list.
      */
-    horizontal: BooleanConstructor;
+    horizontal?: boolean;
     /**
      * Component or element type for container element.
      * @defaultValue "div"
      */
-    as: {
-        type: PropType<keyof NativeElements>;
-        default: string;
-    };
+    as?: keyof IntrinsicElementAttributes;
     /**
      * Component or element type for item element.
      * @defaultValue "div"
      */
-    item: {
-        type: PropType<keyof NativeElements>;
-        default: string;
-    };
+    item?: keyof IntrinsicElementAttributes;
     /**
      * You can restore cache by passing a {@link CacheSnapshot} on mount. This is useful when you want to restore scroll position after navigation. The snapshot can be obtained from {@link WindowVirtualizerHandle.cache}.
      *
      * **The length of items should be the same as when you take the snapshot, otherwise restoration may not work as expected.**
      */
-    cache: PropType<CacheSnapshot>;
-}, void, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    cache?: CacheSnapshot;
     /**
      * Callback invoked whenever scroll offset changes.
      */
-    scroll: () => void;
+    onScroll?: () => void;
     /**
      * Callback invoked when scrolling stops.
      */
-    scrollEnd: () => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    /**
-     * The data items rendered by this component.
-     */
-    data: {
-        type: ArrayConstructor;
-        required: true;
+    onScrollEnd?: () => void;
+}
+interface WindowVirtualizerInstance<T = unknown> extends WindowVirtualizerHandle {
+    $props: WindowVirtualizerProps<T>;
+    $slots: {
+        default: (arg: {
+            item: T;
+            index: number;
+        }) => VNode[];
     };
+}
+/**
+ * Methods of {@link WindowVirtualizer}.
+ */
+export interface WindowVirtualizerHandle {
     /**
-     * Extra item space in pixels to render before/after the viewport. The minimum value is 0. Lower value will give better performance but you can increase to avoid showing blank items in fast scrolling.
-     * @defaultValue 200
+     * Get current {@link CacheSnapshot}.
      */
-    bufferSize: NumberConstructor;
+    readonly cache: CacheSnapshot;
     /**
-     * Item size hint for unmeasured items in pixels. It will help to reduce scroll jump when items are measured if used properly.
-     *
-     * - If not set, initial item sizes will be automatically estimated from measured sizes. This is recommended for most cases.
-     * - If set, you can opt out estimation and use the value as initial item size.
+     * Get current scrollTop, or scrollLeft if horizontal: true.
      */
-    itemSize: NumberConstructor;
+    readonly scrollOffset: number;
     /**
-     * While true is set, scroll position will be maintained from the end not usual start when items are added to/removed from start. It's recommended to set false if you add to/remove from mid/end of the list because it can cause unexpected behavior. This prop is useful for reverse infinite scrolling.
+     * Get current offsetHeight, or offsetWidth if horizontal: true.
      */
-    shift: BooleanConstructor;
+    readonly viewportSize: number;
     /**
-     * If true, rendered as a horizontally scrollable list. Otherwise rendered as a vertically scrollable list.
+     * Find nearest item index from offset.
+     * @param offset offset in pixels from the start of the scroll container
      */
-    horizontal: BooleanConstructor;
+    findItemIndex(offset: number): number;
     /**
-     * Component or element type for container element.
-     * @defaultValue "div"
+     * Get item offset from start.
+     * @param index index of item
      */
-    as: {
-        type: PropType<keyof NativeElements>;
-        default: string;
-    };
+    getItemOffset(index: number): number;
     /**
-     * Component or element type for item element.
-     * @defaultValue "div"
+     * Get item size.
+     * @param index index of item
      */
-    item: {
-        type: PropType<keyof NativeElements>;
-        default: string;
-    };
+    getItemSize(index: number): number;
     /**
-     * You can restore cache by passing a {@link CacheSnapshot} on mount. This is useful when you want to restore scroll position after navigation. The snapshot can be obtained from {@link WindowVirtualizerHandle.cache}.
-     *
-     * **The length of items should be the same as when you take the snapshot, otherwise restoration may not work as expected.**
+     * Scroll to the item specified by index.
+     * @param index index of item
+     * @param opts options
      */
-    cache: PropType<CacheSnapshot>;
-}>> & {
-    onScroll?: (() => any) | undefined;
-    onScrollEnd?: (() => any) | undefined;
-}, {
-    shift: boolean;
-    horizontal: boolean;
-    as: keyof import("vue").IntrinsicElementAttributes;
-    item: keyof import("vue").IntrinsicElementAttributes;
-}, SlotsType<{
-    default: (arg: {
-        item: any;
-        index: number;
-    }) => VNode[];
-}>>;
+    scrollToIndex(index: number, opts?: ScrollToIndexOpts): void;
+}
+export declare const WindowVirtualizer: {
+    new <T = unknown>(props: WindowVirtualizerProps<T>): WindowVirtualizerInstance<T>;
+};
+export {};