virtua 0.52.9 → 0.53.0

package/lib/angular/VList.d.ts

@@ -44,7 +44,9 @@ export declare class VList<T> implements OnInit, VListHandle {
      */
     readonly ssrCount: import("@angular/core").InputSignal<number | undefined>;
     /**
-     * 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.
+     * Set true only when items are added to or removed from the start of the list, such as when older items are loaded in reverse infinite scrolling. In that case, the scroll position is maintained from the end of the list instead of the start.
+     *
+     * **Do not set true in any other case, as it can cause unexpected behavior.**
      */
     readonly shift: import("@angular/core").InputSignal<boolean>;
     /**

package/lib/angular/VMasonry.d.ts

@@ -0,0 +1,114 @@
+import { type OnInit } from "@angular/core";
+import { type CacheSnapshot, type ScrollToIndexOpts } from "../core/index.js";
+import * as i0 from "@angular/core";
+/**
+ * Methods of {@link VMasonry}.
+ */
+export interface VMasonryHandle {
+    /**
+     * Get current {@link CacheSnapshot}.
+     */
+    readonly cache: CacheSnapshot;
+    /**
+     * Get current scrollTop.
+     */
+    readonly scrollOffset: number;
+    /**
+     * Get current scrollHeight.
+     */
+    readonly scrollSize: number;
+    /**
+     * Get current clientHeight.
+     */
+    readonly viewportSize: 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;
+}
+/**
+ * Virtualized masonry component. See {@link VMasonryHandle}.
+ *
+ * The host element is the scrollable viewport of the masonry.
+ */
+export declare class VMasonry<T> implements OnInit, VMasonryHandle {
+    /**
+     * The data items rendered by this component.
+     */
+    readonly data: import("@angular/core").InputSignal<readonly T[]>;
+    /**
+     * Function that returns the key of an item in the list. It's recommended to specify whenever possible for performance.
+     * @default defaultGetKey (returns index of item)
+     */
+    readonly getKey: import("@angular/core").InputSignal<(data: T, index: number) => string | number>;
+    /**
+     * The number of lanes (columns) which items are laid out into. Each item is placed into the shortest lane in order. It must be an integer and the minimum value is 1.
+     */
+    readonly lanes: import("@angular/core").InputSignal<number>;
+    /**
+     * The gap between the items and the lanes in pixels, which is not included in the sizes.
+     * @defaultValue 0
+     */
+    readonly gap: import("@angular/core").InputSignal<number | undefined>;
+    /**
+     * 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.
+     */
+    readonly itemSize: import("@angular/core").InputSignal<number | undefined>;
+    /**
+     * 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
+     */
+    readonly bufferSize: import("@angular/core").InputSignal<number | undefined>;
+    /**
+     * 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 VMasonryHandle.cache}.
+     *
+     * **The length of items should be the same as when you take the snapshot, otherwise restoration may not work as expected.**
+     */
+    readonly cacheProp: import("@angular/core").InputSignal<CacheSnapshot | undefined>;
+    /**
+     * Emitted whenever scroll offset changes. The value is current scrollTop.
+     */
+    readonly scrolled: import("@angular/core").OutputEmitterRef<number>;
+    /**
+     * Emitted when scrolling stops.
+     */
+    readonly scrollEnded: import("@angular/core").OutputEmitterRef<void>;
+    constructor();
+    ngOnInit(): void;
+    get cache(): CacheSnapshot;
+    get scrollOffset(): number;
+    get scrollSize(): number;
+    get viewportSize(): number;
+    getItemOffset(index: number): number;
+    getItemSize(index: number): number;
+    scrollToIndex(index: number, opts?: ScrollToIndexOpts): void;
+    scrollTo(offset: number): void;
+    scrollBy(offset: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VMasonry<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VMasonry<any>, "virtua-vmasonry", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "getKey": { "alias": "getKey"; "required": false; "isSignal": true; }; "lanes": { "alias": "lanes"; "required": true; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "bufferSize": { "alias": "bufferSize"; "required": false; "isSignal": true; }; "cacheProp": { "alias": "cache"; "required": false; "isSignal": true; }; }, { "scrolled": "scrolled"; "scrollEnded": "scrollEnded"; }, ["template"], never, true, never>;
+}

package/lib/angular/Virtualizer.d.ts

@@ -95,7 +95,9 @@ export declare class Virtualizer<T> implements OnInit, VirtualizerHandle {
      */
     readonly ssrCount: import("@angular/core").InputSignal<number | undefined>;
     /**
-     * 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.
+     * Set true only when items are added to or removed from the start of the list, such as when older items are loaded in reverse infinite scrolling. In that case, the scroll position is maintained from the end of the list instead of the start.
+     *
+     * **Do not set true in any other case, as it can cause unexpected behavior.**
      */
     readonly shift: import("@angular/core").InputSignal<boolean>;
     /**

package/lib/angular/WindowVirtualizer.d.ts

@@ -72,7 +72,9 @@ export declare class WindowVirtualizer<T> implements OnInit, WindowVirtualizerHa
      */
     readonly ssrCount: import("@angular/core").InputSignal<number | undefined>;
     /**
-     * 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.
+     * Set true only when items are added to or removed from the start of the list, such as when older items are loaded in reverse infinite scrolling. In that case, the scroll position is maintained from the end of the list instead of the start.
+     *
+     * **Do not set true in any other case, as it can cause unexpected behavior.**
      */
     readonly shift: import("@angular/core").InputSignal<boolean>;
     /**

package/lib/angular/index.d.ts

@@ -6,3 +6,4 @@ export { Virtualizer, type VirtualizerHandle } from "./Virtualizer.js";
 export { WindowVirtualizer, type WindowVirtualizerHandle, } from "./WindowVirtualizer.js";
 export { VGrid, type VGridHandle } from "./VGrid.js";
 export type { GridSize, GridSpan } from "../core/index.js";
+export { VMasonry, type VMasonryHandle } from "./VMasonry.js";