@ng-native/components 0.0.1 → 0.1.0

package/dist/virtual-list.d.ts

@@ -0,0 +1,530 @@
+import { TemplateRef } from '@angular/core';
+import { type NativeSyntheticEvent } from '@ng-native/fabric';
+import { type KeyboardShouldPersistTaps } from './keyboard-taps.ts';
+import { ScrollViewProps } from './scroll-view-props.ts';
+import * as i0 from "@angular/core";
+/** One rendered row: the item, its index, and a stable style object for its slot. */
+export interface VirtualRow<T> {
+    readonly index: number;
+    /**
+     * A key that a row keeps while its item stays in the window, and that passes to a row arriving
+     * once it has left. `track row.slot` recycles rows: the view of a row scrolling out is reused for
+     * the one scrolling in, with only its bindings updated, rather than one destroyed and one created
+     * each time. A slot follows its item, not its position, so an insert above the window moves no
+     * row to another item.
+     */
+    readonly slot: number;
+    /**
+     * The item's identity, from `keyExtractor`, or the item itself without one. `track row.key`
+     * gives each item a view of its own for as long as it is in the window and never recycles one,
+     * which is what a row holding state of its own, or animating, needs.
+     */
+    readonly key: unknown;
+    readonly item: T;
+    readonly style: Record<string, unknown>;
+    /**
+     * A slot kept rendered but hidden, still bound to the last item it showed, so the next row of
+     * its type to arrive reuses its views instead of building them. Always last in the window.
+     */
+    readonly parked?: true;
+}
+/** A row height: one for every row, or one per item. */
+export type VirtualItemHeight<T> = number | ((item: T, index: number) => number);
+/**
+ * Keep what is on screen where it is when rows are added or removed before it, as
+ * `ScrollView`'s `maintainVisibleContentPosition` does in React Native.
+ */
+export interface VirtualListVisiblePosition {
+    /** Rows before this index are never what the position is held by. Defaults to 0. */
+    readonly minIndexForVisible?: number;
+    /**
+     * Within this many points of the start, show what arrived instead of holding position: a feed
+     * at its top scrolls to the new posts, a chat at its newest message follows the next one.
+     */
+    readonly autoscrollToTopThreshold?: number;
+}
+/** What a separator template is given: the rows either side of it, as FlatList's `leadingItem`. */
+export interface VirtualListSeparatorContext<T> {
+    readonly $implicit: T;
+    readonly leadingItem: T;
+    readonly trailingItem: T;
+    readonly leadingIndex: number;
+}
+/**
+ * Marks the template drawn between two rows: `<ng-template virtualListSeparator let-leading>`.
+ * FlatList's `ItemSeparatorComponent`.
+ */
+export declare class VirtualListSeparator<T = unknown> {
+    readonly template: TemplateRef<VirtualListSeparatorContext<T>>;
+    static ngTemplateContextGuard<T>(_directive: VirtualListSeparator<T>, context: unknown): context is VirtualListSeparatorContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualListSeparator<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VirtualListSeparator<any>, "ng-template[virtualListSeparator]", never, {}, {}, never, never, true, never>;
+}
+/** One separator the list is drawing: its slot, and what its template is told. */
+interface Gap<T> {
+    readonly index: number;
+    readonly style: Record<string, unknown>;
+    readonly context: VirtualListSeparatorContext<T>;
+}
+/**
+ * Windowed list: a native scroll view whose content is sized to the full list, with only the
+ * visible slice rendered. Commits as `RCTScrollView`.
+ *
+ * RN's FlatList, SectionList and VirtualizedList are a large React component tree, and none of
+ * it is reachable. This is the small equivalent. Angular's own `@for` does the rendering, so
+ * tracking, reuse and destruction all behave normally, and the loop stays in the caller's
+ * template:
+ *
+ * ```html
+ * <virtual-list #list [items]="rows()" [itemHeight]="44" (endReached)="loadMore()">
+ *   <text listHeader>Header</text>
+ *   @for (row of list.window(); track row.slot) {
+ *     <view [virtualListRow]="row"><text>{{ row.item.label }}</text></view>
+ *   }
+ *   <text listFooter>Footer</text>
+ * </virtual-list>
+ * ```
+ *
+ * With `itemHeight`, every row's size is known up front and each is absolutely positioned at its
+ * offset. Without it, rows size themselves, as a feed's posts and a chat's messages do: the window
+ * is laid out in normal flow after a spacer standing in for the rows above it, so native places
+ * every row correctly in the frame it first appears, and each row's layout tells the list its
+ * height for sizing what is not rendered. Until a row has been measured it counts as
+ * `estimatedItemHeight`. Measurements are kept by `keyExtractor`, so they follow their item across
+ * inserts, removals and moves. `virtualListRow` on each row's view applies its style and reports
+ * its layout; `[style]="row.style"` still works for fixed heights, which need no measuring.
+ *
+ * Content marked `listHeader` and `listFooter` renders above and below the rows in normal flow,
+ * as FlatList's header and footer components do. A `<refresh-control>` projects like any child.
+ *
+ * `<ng-template virtualListSeparator let-leading let-trailing="trailingItem">` is drawn between
+ * each pair of rows and not after the last, as FlatList's `ItemSeparatorComponent` is. It is drawn
+ * inside the leading row's slot, at its trailing edge, so `itemHeight` includes it the way
+ * `getItemLayout`'s `length` includes it in RN; a measured row has it drawn over its trailing edge
+ * once its height is known. The slot it sits in lets touches through to the row underneath.
+ *
+ * `horizontal` swaps the axis: rows are placed by `left` and sized by `width`, and the offset is
+ * read from `contentOffset.x`. `inverted` is a scale of -1 on the list and on each row, which is
+ * how FlatList does it too - the list scrolls from the bottom and each row is flipped back the
+ * right way up, so a chat transcript needs no reversed array.
+ *
+ * `stickyIndices` pins a row to the leading edge while the rows under it scroll past, which is
+ * FlatList's `stickyHeaderIndices` counted without the header. `stickyHeader` pins the
+ * `listHeader` content the same way, FlatList's index 0 when it has a `ListHeaderComponent`, and
+ * the first sticky row pushes it off as RN's sticky headers push each other. Neither is native:
+ * RN's `ScrollView.js` translates a sticky child against the scroll offset in JavaScript, and a
+ * row here follows the offset the same way while it is the current one - by its `top` when
+ * absolutely positioned, by a transform when in flow.
+ *
+ * What is on screen stays on screen when a measured row above it turns out taller or shorter than
+ * its estimate: the offset is corrected by the difference. `maintainVisibleContentPosition` does
+ * the same for rows inserted or removed above it, which a feed receiving new posts and a chat
+ * loading older messages above the ones being read both need.
+ *
+ * ponytail: viewability is `itemVisiblePercentThreshold` only: `minimumViewTime` and
+ * `waitForInteraction` are timing policy on top of the same measurement, and nothing has needed
+ * them. A separator is not told `highlighted`, which RN drives from the row's press state. A
+ * sticky header follows the scroll a commit behind native, where RN's is on the native driver. A
+ * held position is restored by a `scrollTo` after the commit, not in the mount as native
+ * `maintainVisibleContentPosition` is, so a correction made mid-fling lands where the last scroll
+ * event said the list was.
+ */
+export declare class VirtualList<T> extends ScrollViewProps {
+    readonly items: import("@angular/core").InputSignal<readonly T[]>;
+    /**
+     * A fixed height, or a function for variable ones, when every row's size is known up front. The
+     * function form builds a cumulative offset table and binary-searches it, which is what section
+     * lists need: a header row and an item row are different heights, so uniform maths cannot place
+     * them. Leave it unset for rows that size themselves.
+     */
+    readonly itemHeight: import("@angular/core").InputSignal<VirtualItemHeight<T> | undefined>;
+    /**
+     * What a row that sizes itself counts as until it has been measured. The closer it is, the more
+     * honest the scroll bar is and the less a jump to an unmeasured row has to correct.
+     */
+    readonly estimatedItemHeight: import("@angular/core").InputSignal<VirtualItemHeight<T>>;
+    /**
+     * An item's identity, as FlatList's `keyExtractor`: what a measured height, a slot and a held
+     * position follow across an insert. Without it an item is its own key, which is enough for items
+     * that are replaced, not copied, when they change.
+     */
+    readonly keyExtractor: import("@angular/core").InputSignal<((item: T, index: number) => unknown) | undefined>;
+    /**
+     * What kind of row an item is, when rows of different kinds share the list: a text post and a
+     * photo post, a message and a date divider. A slot is only ever recycled into a row of the same
+     * type, so its views are reused rather than torn down for another kind's, as UIKit's reuse
+     * identifiers and FlashList's `getItemType` do.
+     */
+    readonly itemType: import("@angular/core").InputSignal<((item: T, index: number) => unknown) | undefined>;
+    /** Keep what is on screen still when rows are inserted or removed before it. */
+    readonly maintainVisibleContentPosition: import("@angular/core").InputSignal<VirtualListVisiblePosition | undefined>;
+    /** Rows rendered beyond each edge of the viewport, to cover fling gaps. */
+    readonly overscan: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    /** How close to the end, in viewport heights, `(endReached)` fires. RN's default is 2. */
+    readonly endReachedThreshold: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    /** Lay the rows out along x instead of y, and scroll that way. */
+    readonly horizontal: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Start at the end and scroll backwards, with every row flipped back the right way up. */
+    readonly inverted: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Rows that pin to the leading edge while the ones under them scroll past. Ascending; a row is
+     * pinned from the moment it would leave until the next sticky row pushes it off.
+     */
+    readonly stickyIndices: import("@angular/core").InputSignal<readonly number[]>;
+    /** Pin the `listHeader` content to the leading edge until the first sticky row pushes it off. */
+    readonly stickyHeader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** What a tap in the list does while a text input has the keyboard up. See `ScrollView`. */
+    readonly keyboardShouldPersistTaps: import("@angular/core").InputSignal<KeyboardShouldPersistTaps>;
+    /** How much of a row must be on screen to count as viewable. RN's default is 0, meaning any. */
+    readonly itemVisiblePercentThreshold: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    /**
+     * The scroll position is within `endReachedThreshold` of the end: once per item count, and again
+     * after the list has scrolled away from the end and come back.
+     */
+    readonly endReached: import("@angular/core").OutputEmitterRef<{
+        distanceFromEnd: number;
+    }>;
+    /** Which rows are on screen, and what changed since last time. */
+    readonly viewableItemsChanged: import("@angular/core").OutputEmitterRef<{
+        viewable: readonly VirtualRow<T>[];
+        entered: readonly number[];
+        left: readonly number[];
+    }>;
+    private readonly viewport;
+    /** The leading edge of the viewport in content space, which sticky rows and viewability need. */
+    private readonly offset;
+    private readonly headerHeight;
+    /** What native reported the content measures along the axis, once it has. */
+    private contentSize;
+    /** The item count `endReached` last fired for, cleared once the list is away from the end. */
+    private endReachedFor;
+    /** Slot styles are cached so a scroll does not hand Fabric new prop objects for stable rows. */
+    private readonly slots;
+    /** A separator's slot style, per row slot style, so it is as stable as the row's own. */
+    private readonly gapStyles;
+    /** The same for a measured row's separator, by key, while its place and size stay put. */
+    private readonly measuredGaps;
+    protected readonly separator: import("@angular/core").Signal<VirtualListSeparator<T> | undefined>;
+    private readonly refreshControl;
+    /** See ScrollView: inside Android's swipe layout the list must see a drag first. */
+    protected readonly nestedScroll: import("@angular/core").Signal<true | undefined>;
+    /**
+     * Whether native moves sticky rows. Each then stays at its own place in the list and native
+     * translates it on every frame the list scrolls, as RN's `ScrollViewStickyHeader` does; a
+     * translate committed from each scroll event lands a frame or more late, and on a fast fling
+     * the row shudders and comes away from the edge.
+     */
+    private readonly nativeSticky;
+    /** The offset once scrolling pauses, which the settled translate of a native-moved row is from. */
+    private readonly settled;
+    private settleTimer;
+    /** What native is moving, by row view, with the transform kept beside the translate. */
+    private readonly drives;
+    private readonly canvasView;
+    /** Whether the scroll offset is needed as a signal, which only pinning needs. */
+    private readonly pinning;
+    /** Rows size themselves and are laid out in flow, rather than placed at a known offset. */
+    readonly measuring: import("@angular/core").Signal<boolean>;
+    /** Heights native has reported, by key. */
+    private readonly measured;
+    /** Bumped when a measurement changes, which is what re-sizes the list. */
+    private readonly measuredVersion;
+    /** Each item's key, or null when items are their own. */
+    private readonly keys;
+    private keyAt;
+    /**
+     * Each row's size and where it starts, for variable heights; uniform rows need no index at all.
+     * Built once per change of items. A measurement changes it in place and bumps
+     * `measuredVersion`, which is what everything that reads it depends on, so a row laying out
+     * costs a walk of the tree rather than a rebuild of every offset.
+     */
+    private readonly table;
+    /** Where each key is, so a measurement finds its row without a search. */
+    private readonly indexOfKey;
+    /** The index, with a dependency on its measurements for whoever is reading it. */
+    private layout;
+    /** The list's own total extent along its axis. */
+    private readonly extent;
+    protected readonly canvas: import("@angular/core").Signal<{
+        width: number;
+        flexDirection: string;
+        height?: undefined;
+    } | {
+        height: number;
+        width?: undefined;
+        flexDirection?: undefined;
+    }>;
+    /**
+     * `scaleY: -1` on the list, and the same on every row.
+     *
+     * The list ends up scrolled from the far end with its rows in reverse, and the second flip puts
+     * each row's own content back the right way up. It is what `FlatList` does, and it is why an
+     * inverted list needs no reversed array and no reversed maths.
+     */
+    protected readonly flip: import("@angular/core").Signal<Readonly<Record<string, number>>[] | undefined>;
+    /**
+     * The flip as a style's transform: CSS text, which the engine turns into the list native reads.
+     * A style binding validates its values as the DOM's, and warns on a list in development.
+     */
+    private readonly flipText;
+    /** A row in flow, flipped back when the list is inverted. One object, so rows never re-clone. */
+    private readonly flowStyle;
+    /** Top of a row. */
+    private topOf;
+    private heightOf;
+    /** First row whose bottom is past `y`. */
+    private indexAt;
+    /** The row the viewport's leading edge is in, taken at each scroll. */
+    private anchor;
+    /** The last offset seen. A field rather than a signal: reading it renders nothing. */
+    private lastOffset;
+    /**
+     * A correction to make once the commit that needs it is on its way to native: an offset in the
+     * rows' own space, after the header, or the very start of the list.
+     */
+    private pendingScroll;
+    /** What moves the rows: which items, and where each one is. */
+    private readonly placement;
+    /**
+     * The first *visible* row, not the first rendered one, and not the raw scroll offset. A fling
+     * produces a scroll event per frame, and setting a signal on each one costs a change-detection
+     * pass even when the visible rows are identical. Deriving the index in the handler means most
+     * scroll events change nothing and cost nothing.
+     *
+     * Linked to the rows' placement, because that is when the row on screen can move without the
+     * user scrolling: an insert above it, or a row above it measuring differently from its estimate.
+     * The index follows the anchored row there, and the offset follows it too.
+     */
+    private readonly visible;
+    /** Take the anchor at a row, keeping the viewport where it is. */
+    private anchorAt;
+    /**
+     * Where the row on screen went when the rows moved under it, and the offset that keeps it where
+     * the user left it. An insert or a removal is only held when the caller asked for it; a row
+     * above measuring differently always is, since nothing the user did moved anything.
+     */
+    private reanchor;
+    /**
+     * The row under the offset native is still at, in rows that have just replaced the old ones, as
+     * a filter replaces them. Native keeps its offset whatever the items became, so the window is
+     * worked out from that, not from the old row's index, which in the new rows sits somewhere else.
+     * When the new rows end before that offset, the list is scrolled back to their end: native
+     * would otherwise stay scrolled past it, showing nothing until the next drag.
+     */
+    private atOffset;
+    /**
+     * The index to hold the viewport at, -1 to let it move, or the start of the list when an
+     * insert lands within the autoscroll threshold of it.
+     */
+    private heldIndex;
+    /** Scroll to what arrived at the start, rather than holding the viewport past it. */
+    private showStart;
+    /**
+     * The anchored row's new index, or the first row after it that survived when it did not. Only
+     * the rows that were rendered are searched for a successor: past those the viewport has moved
+     * on, and holding it by something off screen would be holding it by nothing the user saw.
+     */
+    private successorOf;
+    /** Make a queued correction, after the commit that moved the rows has gone to native. */
+    private flushScroll;
+    constructor();
+    /** The rows to render, and the edges of the run they sit in. */
+    private readonly span;
+    readonly window: import("@angular/core").Signal<VirtualRow<T>[]>;
+    /**
+     * What stands in for the rows above the window when rows are in flow: their total extent, less
+     * a pinned row's, which is rendered in flow ahead of the window.
+     */
+    protected readonly spacer: import("@angular/core").Signal<{
+        width: number;
+        height?: undefined;
+    } | {
+        height: number;
+        width?: undefined;
+    }>;
+    /** The rows from `first` up to `last`, and the pinned row above them if there is one. */
+    private rowsFor;
+    /**
+     * A pinned row native moves stays at its own place, so the rows between it and the window are
+     * made up before the window rather than after the row: new props on a view native is moving
+     * put its transform back for a frame.
+     */
+    private leadWindow;
+    private styleFor;
+    /** A pinned row in flow, moved from where flow put it to the leading edge by a transform. */
+    private pinnedFlowStyle;
+    /**
+     * A sticky row native moves: at its own place, with the translate native had reached when
+     * scrolling paused, so the props agree with what is on screen.
+     */
+    private stickyStyle;
+    /** Each sticky row, and the one after it, which pushes it off. */
+    private readonly nextSticky;
+    /** Where a sticky row stops, pushed off by the next: that row's top, less this row's size. */
+    private stopOf;
+    /**
+     * How native moves a rendered row, or null when it does not: along the scroll view's own
+     * offset, which counts the header, from the row's top until the next sticky row pushes it off.
+     */
+    private stickyDrive;
+    /**
+     * Hand each rendered sticky row's view to native to move, and let go of the rest. The rows'
+     * views are the canvas's element children in window order, after the spacer, which is how
+     * `@for` over `window()` leaves them.
+     */
+    private driveStickyRows;
+    /** Which recycling slot each rendered item holds, by key: its type, and the row it last drew. */
+    private readonly recycled;
+    /** Slots that have left the window and are kept hidden, by the type of row that held them. */
+    private readonly parked;
+    private nextSlot;
+    /** Note the row a slot is drawing, for parking it once it leaves. */
+    private hold;
+    /**
+     * Park the slots of the items that have left the window, for the items arriving.
+     *
+     * Parked rather than freed: a slot missing from the window is destroyed by `@for`, so a slot is
+     * only reused if a row of its type arrives in the same pass as it left. Kept rendered and
+     * hidden, it waits for the next row of its type however many passes later, which is what a
+     * reuse queue of cells does in UIKit.
+     */
+    private releaseRecycled;
+    /**
+     * Keep a few hidden slots of each type once this pass has taken what it needs, dropping the
+     * oldest: `@for` destroys the views of a slot that leaves the window for good.
+     */
+    private trimParked;
+    /** A parked row for a slot that never drew, which only a slot taken and left in one pass is. */
+    private placeholder;
+    private recycledSlot;
+    /**
+     * A row laid itself out; what `virtualListRow` calls. Only a row that sizes itself is measured,
+     * and a height that has not changed changes nothing.
+     */
+    measureRow(row: VirtualRow<T>, layout: {
+        width?: number;
+        height?: number;
+    } | undefined): void;
+    /** Drop the measurements of items long gone, so churn cannot grow the map without bound. */
+    private forgetDeparted;
+    /** A separator for every rendered row but the list's last, in its leading row's slot. */
+    protected readonly gaps: import("@angular/core").Signal<Gap<T>[]>;
+    /** The row's own slot, laid out to put the separator at its trailing edge. */
+    private gapStyle;
+    /**
+     * A measured row's slot, over the row itself: nothing until its height is known, since drawing
+     * it at the estimate would put a line through the middle of a row that turns out taller.
+     */
+    private measuredGapStyle;
+    /**
+     * The header's translation while it is pinned: the scroll position, held back at zero by an
+     * overscroll and at the first sticky row, which pushes it off.
+     */
+    protected readonly headerStyle: import("@angular/core").Signal<{
+        transform: string;
+        zIndex?: undefined;
+    } | {
+        zIndex: number;
+        transform: string;
+    } | {
+        zIndex: number;
+        transform?: undefined;
+    } | undefined>;
+    /**
+     * The footer, flipped back like every row when the list is inverted, as FlatList inverts its
+     * header and footer cells too; otherwise both read upside down.
+     */
+    protected readonly footerStyle: import("@angular/core").Signal<{
+        transform: string;
+    } | undefined>;
+    /**
+     * The sticky row currently holding the leading edge: the last one at or before the offset.
+     * Null when the list has scrolled back above the first of them.
+     */
+    private readonly pinnedIndex;
+    /** Which rows are on screen far enough to count, by the caller's threshold. */
+    private viewableAt;
+    /** The last set announced, so the output fires on a change rather than on every frame. */
+    private announced;
+    /**
+     * Announce a change in what is on screen.
+     *
+     * Deliberately not a `computed` over a signal offset. A fling produces a scroll event per
+     * frame, and writing a signal on each one costs a change-detection pass whether or not anything
+     * moved into view; comparing here costs an array walk over the window and emits only when the
+     * set really changed.
+     */
+    private announceViewable;
+    /**
+     * Scroll so that a row is at the start of the viewport, less `viewOffset`. The window moves
+     * there at once, and the row is held there while the rows around it are measured.
+     */
+    scrollToIndex(options: {
+        index: number;
+        animated?: boolean;
+        viewOffset?: number;
+    }): void;
+    /** Scroll to an offset along the list's own axis: x when it is horizontal, y otherwise. */
+    scrollToOffset(options: {
+        offset: number;
+        animated?: boolean;
+    }): void;
+    scrollToEnd(options?: {
+        animated?: boolean;
+    }): void;
+    private slotStyle;
+    protected onScroll(event: NativeSyntheticEvent<{
+        contentOffset?: {
+            x?: number;
+            y?: number;
+        };
+    }>): void;
+    /** RN's sticky header commits its translate after 64 ms without a scroll event, as this does. */
+    private settleAfterPause;
+    protected onLayout(event: NativeSyntheticEvent<{
+        layout?: {
+            width?: number;
+            height?: number;
+        };
+    }>): void;
+    /** The header's extent along the axis, which every row sits after. */
+    protected onHeaderLayout(event: NativeSyntheticEvent<{
+        layout?: {
+            width?: number;
+            height?: number;
+        };
+    }>): void;
+    /**
+     * The header grew or shrank - a typing indicator in a chat's, a banner in a feed's - and every
+     * row moved with it. Held like an insert when the caller asked for that and the viewport is
+     * past the header, among the rows; at the start the user is looking at the header, and it is
+     * left to push the rows along. Made at once rather than after a render, because a layout arrives
+     * outside change detection and nothing else may be about to render.
+     */
+    private holdPastHeader;
+    protected onContentSize(event: NativeSyntheticEvent<{
+        width?: number;
+        height?: number;
+    }>): void;
+    private checkEnd;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualList<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VirtualList<any>, "virtual-list", ["virtualList"], { "items": { "alias": "items"; "required": true; "isSignal": true; }; "itemHeight": { "alias": "itemHeight"; "required": false; "isSignal": true; }; "estimatedItemHeight": { "alias": "estimatedItemHeight"; "required": false; "isSignal": true; }; "keyExtractor": { "alias": "keyExtractor"; "required": false; "isSignal": true; }; "itemType": { "alias": "itemType"; "required": false; "isSignal": true; }; "maintainVisibleContentPosition": { "alias": "maintainVisibleContentPosition"; "required": false; "isSignal": true; }; "overscan": { "alias": "overscan"; "required": false; "isSignal": true; }; "endReachedThreshold": { "alias": "endReachedThreshold"; "required": false; "isSignal": true; }; "horizontal": { "alias": "horizontal"; "required": false; "isSignal": true; }; "inverted": { "alias": "inverted"; "required": false; "isSignal": true; }; "stickyIndices": { "alias": "stickyIndices"; "required": false; "isSignal": true; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "keyboardShouldPersistTaps": { "alias": "keyboardShouldPersistTaps"; "required": false; "isSignal": true; }; "itemVisiblePercentThreshold": { "alias": "itemVisiblePercentThreshold"; "required": false; "isSignal": true; }; }, { "endReached": "endReached"; "viewableItemsChanged": "viewableItemsChanged"; }, ["separator", "refreshControl"], ["refresh-control", "[listHeader]", "*", "[listFooter]"], true, never>;
+}
+/**
+ * Put on each row's view: `<view [virtualListRow]="row">`. Applies the row's style, and reports
+ * the row's layout to the list, which is how a list of rows that size themselves learns how tall
+ * each one is.
+ */
+export declare class VirtualListRow<T = unknown> {
+    readonly row: import("@angular/core").InputSignal<VirtualRow<T>>;
+    private readonly list;
+    protected onLayout(event: NativeSyntheticEvent<{
+        layout?: {
+            width?: number;
+            height?: number;
+        };
+    }>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualListRow<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VirtualListRow<any>, "[virtualListRow]", never, { "row": { "alias": "virtualListRow"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};