ropav 0.2.0 → 0.3.0

package/dist/utils/virtualizer-geometry.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Geometry primitives for the virtualizer, ported from React Aria's `Point`, `Size` and `Rect`.
+ *
+ * Pure arithmetic with no DOM and no framework in it, kept as its own unit rather than reached
+ * for through a windowing library, so the geometry a layout produces is readable here rather than
+ * inside a dependency.
+ *
+ * One deliberate omission. React Aria's `Rect.intersects` widens itself under
+ * `NODE_ENV === "test"`, dropping the `area > 0` guard so a collection with no measured size
+ * still reports every item as visible. That branch exists because jsdom has no layout; it makes
+ * the test environment disagree with the browser about what is on screen. Here the guard always
+ * applies, and a test that needs a window mocks the container's size instead.
+ */
+/** A corner of a rectangle, named from top to bottom and left to right. */
+export type RectCorner = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
+export declare class Point {
+    /** The x-coordinate of the point. */
+    x: number;
+    /** The y-coordinate of the point. */
+    y: number;
+    constructor(x?: number, y?: number);
+    copy(): Point;
+    equals(point: Point): boolean;
+    isOrigin(): boolean;
+}
+export declare class Size {
+    width: number;
+    height: number;
+    /** Negative dimensions are clamped to zero, as React Aria has it. */
+    constructor(width?: number, height?: number);
+    get area(): number;
+    copy(): Size;
+    equals(other: Size): boolean;
+}
+export declare class Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    get area(): number;
+    get bottomLeft(): Point;
+    get bottomRight(): Point;
+    get maxX(): number;
+    get maxY(): number;
+    get topLeft(): Point;
+    get topRight(): Point;
+    containsPoint(point: Point): boolean;
+    containsRect(rect: Rect): boolean;
+    copy(): Rect;
+    equals(rect: Rect): boolean;
+    /**
+     * The first corner of this rectangle, top to bottom and left to right, that sits inside the
+     * given rectangle — or `null` when none does.
+     */
+    getCornerInRect(rect: Rect): RectCorner | null;
+    /** The intersection with another rectangle, or an all-zero rectangle when there is none. */
+    intersection(other: Rect): Rect;
+    /**
+     * Whether this rectangle intersects another.
+     *
+     * An empty rectangle intersects nothing, which is what keeps a collection that has not been
+     * measured yet from reporting every one of its items as visible.
+     */
+    intersects(rect: Rect): boolean;
+    pointEquals(point: Point | Rect): boolean;
+    sizeEquals(size: Size | Rect): boolean;
+    union(other: Rect): Rect;
+}

package/dist/utils/virtualizer-geometry.js

@@ -0,0 +1,125 @@
+//#region src/utils/virtualizer-geometry.ts
+var Point = class Point {
+	/** The x-coordinate of the point. */
+	x;
+	/** The y-coordinate of the point. */
+	y;
+	constructor(x = 0, y = 0) {
+		this.x = x;
+		this.y = y;
+	}
+	copy() {
+		return new Point(this.x, this.y);
+	}
+	equals(point) {
+		return this.x === point.x && this.y === point.y;
+	}
+	isOrigin() {
+		return this.x === 0 && this.y === 0;
+	}
+};
+var Size = class Size {
+	width;
+	height;
+	/** Negative dimensions are clamped to zero, as React Aria has it. */
+	constructor(width = 0, height = 0) {
+		this.width = Math.max(width, 0);
+		this.height = Math.max(height, 0);
+	}
+	get area() {
+		return this.width * this.height;
+	}
+	copy() {
+		return new Size(this.width, this.height);
+	}
+	equals(other) {
+		return this.width === other.width && this.height === other.height;
+	}
+};
+var Rect = class Rect {
+	x;
+	y;
+	width;
+	height;
+	constructor(x = 0, y = 0, width = 0, height = 0) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+	}
+	get area() {
+		return this.width * this.height;
+	}
+	get bottomLeft() {
+		return new Point(this.x, this.maxY);
+	}
+	get bottomRight() {
+		return new Point(this.maxX, this.maxY);
+	}
+	get maxX() {
+		return this.x + this.width;
+	}
+	get maxY() {
+		return this.y + this.height;
+	}
+	get topLeft() {
+		return new Point(this.x, this.y);
+	}
+	get topRight() {
+		return new Point(this.maxX, this.y);
+	}
+	containsPoint(point) {
+		return this.x <= point.x && this.y <= point.y && this.maxX >= point.x && this.maxY >= point.y;
+	}
+	containsRect(rect) {
+		return this.x <= rect.x && this.y <= rect.y && this.maxX >= rect.maxX && this.maxY >= rect.maxY;
+	}
+	copy() {
+		return new Rect(this.x, this.y, this.width, this.height);
+	}
+	equals(rect) {
+		return rect.x === this.x && rect.y === this.y && rect.width === this.width && rect.height === this.height;
+	}
+	/**
+	* The first corner of this rectangle, top to bottom and left to right, that sits inside the
+	* given rectangle — or `null` when none does.
+	*/
+	getCornerInRect(rect) {
+		for (const corner of [
+			"topLeft",
+			"topRight",
+			"bottomLeft",
+			"bottomRight"
+		]) if (rect.containsPoint(this[corner])) return corner;
+		return null;
+	}
+	/** The intersection with another rectangle, or an all-zero rectangle when there is none. */
+	intersection(other) {
+		if (!this.intersects(other)) return new Rect(0, 0, 0, 0);
+		const x = Math.max(this.x, other.x);
+		const y = Math.max(this.y, other.y);
+		return new Rect(x, y, Math.min(this.maxX, other.maxX) - x, Math.min(this.maxY, other.maxY) - y);
+	}
+	/**
+	* Whether this rectangle intersects another.
+	*
+	* An empty rectangle intersects nothing, which is what keeps a collection that has not been
+	* measured yet from reporting every one of its items as visible.
+	*/
+	intersects(rect) {
+		return this.area > 0 && rect.area > 0 && this.x <= rect.x + rect.width && rect.x <= this.x + this.width && this.y <= rect.y + rect.height && rect.y <= this.y + this.height;
+	}
+	pointEquals(point) {
+		return this.x === point.x && this.y === point.y;
+	}
+	sizeEquals(size) {
+		return this.width === size.width && this.height === size.height;
+	}
+	union(other) {
+		const x = Math.min(this.x, other.x);
+		const y = Math.min(this.y, other.y);
+		return new Rect(x, y, Math.max(this.maxX, other.maxX) - x, Math.max(this.maxY, other.maxY) - y);
+	}
+};
+//#endregion
+export { Point, Rect, Size };

package/dist/utils/virtualizer-layout-info.d.ts

@@ -0,0 +1,56 @@
+import type { Rect } from "./virtualizer-geometry";
+/**
+ * What a layout hands the virtualizer for one element, ported from React Aria's `LayoutInfo`
+ * and `layoutInfoToStyle`.
+ *
+ * A layout never renders anything. It produces these descriptions — position, size and a little
+ * style — and the virtualizer turns each one into a wrapper element around the item's own markup.
+ */
+/** A collection key. Same shape as the collection's own key type. */
+export type VirtualizerKey = string | number;
+export declare class LayoutInfo {
+    /** Matches the `type` of the collection node this describes. */
+    type: string;
+    /** Matches the `key` of the collection node this describes. */
+    key: VirtualizerKey;
+    /** The key of the enclosing layout info, when this one is nested. */
+    parentKey: VirtualizerKey | null;
+    /** Content the layout generated itself, rather than reading from the collection. */
+    content: unknown;
+    /** Where the element sits and how big it is. */
+    rect: Rect;
+    /**
+     * Whether `rect`'s size is a guess. An estimated element is measured the first time it lands
+     * in the DOM, and the layout is redone with what came back.
+     */
+    estimatedSize: boolean;
+    /** Whether the element stays put while the collection scrolls past it. */
+    isSticky: boolean;
+    opacity: number;
+    transform: string | null;
+    zIndex: number;
+    /** Whether content is allowed to spill outside the element's own box. */
+    allowOverflow: boolean;
+    constructor(type: string, key: VirtualizerKey, rect: Rect);
+    copy(): LayoutInfo;
+}
+/** The style of one virtualizer wrapper. Values carry their unit, see below. */
+export type LayoutInfoStyle = Record<string, string | number | undefined>;
+/**
+ * The inline style for the wrapper around an item.
+ *
+ * Two things differ from React Aria on purpose, neither of them visible in the result:
+ *
+ * Lengths are written with `px` rather than left as bare numbers. React appends the unit itself
+ * for dimensional properties; Vue writes `String(value)` straight onto the style object, so a
+ * bare number would come out as an invalid declaration and be dropped.
+ *
+ * There is no memoisation. React caches the style object per layout info in a `WeakMap` to keep
+ * its element from re-rendering; here the style is read inside the render of a wrapper that is
+ * already keyed by the item, so a cache would only add a way for a stale parent offset to
+ * survive.
+ *
+ * `direction` is not taken: the inline axis is always `left`. RTL needs a locale layer that does
+ * not exist yet, and getting it wrong silently is worse than not offering it.
+ */
+export declare const layoutInfoToStyle: (layoutInfo: LayoutInfo, parent?: LayoutInfo | null) => LayoutInfoStyle;

package/dist/utils/virtualizer-layout-info.js

@@ -0,0 +1,86 @@
+//#region src/utils/virtualizer-layout-info.ts
+var LayoutInfo = class LayoutInfo {
+	/** Matches the `type` of the collection node this describes. */
+	type;
+	/** Matches the `key` of the collection node this describes. */
+	key;
+	/** The key of the enclosing layout info, when this one is nested. */
+	parentKey;
+	/** Content the layout generated itself, rather than reading from the collection. */
+	content;
+	/** Where the element sits and how big it is. */
+	rect;
+	/**
+	* Whether `rect`'s size is a guess. An estimated element is measured the first time it lands
+	* in the DOM, and the layout is redone with what came back.
+	*/
+	estimatedSize;
+	/** Whether the element stays put while the collection scrolls past it. */
+	isSticky;
+	opacity;
+	transform;
+	zIndex;
+	/** Whether content is allowed to spill outside the element's own box. */
+	allowOverflow;
+	constructor(type, key, rect) {
+		this.type = type;
+		this.key = key;
+		this.parentKey = null;
+		this.content = null;
+		this.rect = rect;
+		this.estimatedSize = false;
+		this.isSticky = false;
+		this.opacity = 1;
+		this.transform = null;
+		this.zIndex = 0;
+		this.allowOverflow = false;
+	}
+	copy() {
+		const copy = new LayoutInfo(this.type, this.key, this.rect.copy());
+		copy.parentKey = this.parentKey;
+		copy.content = this.content;
+		copy.estimatedSize = this.estimatedSize;
+		copy.isSticky = this.isSticky;
+		copy.opacity = this.opacity;
+		copy.transform = this.transform;
+		copy.zIndex = this.zIndex;
+		copy.allowOverflow = this.allowOverflow;
+		return copy;
+	}
+};
+var px = (value) => Number.isFinite(value) ? `${value}px` : void 0;
+/**
+* The inline style for the wrapper around an item.
+*
+* Two things differ from React Aria on purpose, neither of them visible in the result:
+*
+* Lengths are written with `px` rather than left as bare numbers. React appends the unit itself
+* for dimensional properties; Vue writes `String(value)` straight onto the style object, so a
+* bare number would come out as an invalid declaration and be dropped.
+*
+* There is no memoisation. React caches the style object per layout info in a `WeakMap` to keep
+* its element from re-rendering; here the style is read inside the render of a wrapper that is
+* already keyed by the item, so a cache would only add a way for a stale parent offset to
+* survive.
+*
+* `direction` is not taken: the inline axis is always `left`. RTL needs a locale layer that does
+* not exist yet, and getting it wrong silently is worse than not offering it.
+*/
+var layoutInfoToStyle = (layoutInfo, parent) => {
+	const offsetParent = Boolean(parent && !(parent.allowOverflow && layoutInfo.isSticky)) ? parent : null;
+	return {
+		contain: "size layout style",
+		display: layoutInfo.isSticky ? "inline-block" : void 0,
+		height: px(layoutInfo.rect.height),
+		left: px(layoutInfo.rect.x - (offsetParent?.rect.x ?? 0)),
+		opacity: layoutInfo.opacity,
+		overflow: layoutInfo.allowOverflow ? "visible" : "hidden",
+		position: layoutInfo.isSticky ? "sticky" : "absolute",
+		top: px(layoutInfo.rect.y - (offsetParent?.rect.y ?? 0)),
+		transform: layoutInfo.transform ?? void 0,
+		width: px(layoutInfo.rect.width),
+		zIndex: layoutInfo.zIndex
+	};
+};
+//#endregion
+export { LayoutInfo, layoutInfoToStyle };

package/dist/utils/virtualizer-layout.d.ts

@@ -0,0 +1,114 @@
+import type { DropTarget, ItemDropTarget } from "./dnd-types";
+import type { Rect, Size } from "./virtualizer-geometry";
+import type { LayoutInfo, VirtualizerKey } from "./virtualizer-layout-info";
+/**
+ * The contract between a virtualizer and its layout, ported from React Aria's `Layout`.
+ *
+ * A layout answers three questions — what is inside a rectangle, where does one key sit, and how
+ * big is the whole content — and the virtualizer renders from the answers. Everything else is
+ * optional.
+ */
+/**
+ * What kind of element a node describes.
+ *
+ * The set matches React Aria's node types, because the layouts branch on them: a section is
+ * measured by its children, a header and a loader by their own option, an item by the row size.
+ */
+export type VirtualizerNodeType = "cell" | "column" | "header" | "headerrow" | "item" | "loader" | "row" | "rowgroup" | "section" | "separator";
+/**
+ * One entry of the collection a layout walks.
+ *
+ * React Aria gets these by rendering the collection into a hidden tree first, so the parent knows
+ * every node before the first paint. That pass does not exist here — rendering is what creates
+ * DOM — so the nodes are built from the data the collection was given, and `childKeys` is what
+ * carries the shape a table needs (header → header row → columns, body → rows → cells).
+ */
+export interface VirtualizerNode {
+    key: VirtualizerKey;
+    type: VirtualizerNodeType;
+    /** The enclosing node, or `null` at the root. */
+    parentKey: VirtualizerKey | null;
+    /** Position among siblings, zero-based. Drives `aria-posinset` and `aria-rowindex`. */
+    index: number;
+    /** Children in order. Empty for a leaf. */
+    childKeys: VirtualizerKey[];
+    /** Text the node is matched on by typeahead. */
+    textValue?: string;
+    isDisabled?: boolean;
+    /** The datum this node was built from, handed back to whoever renders the node. */
+    content?: unknown;
+}
+/** The collection a layout reads. Deliberately smaller than React Aria's `Collection`. */
+export interface VirtualizerCollection {
+    /** How many nodes of type `item`/`row` there are — what `aria-setsize` reports. */
+    readonly itemCount: number;
+    /** Every node, in document order. */
+    readonly keys: VirtualizerKey[];
+    readonly rootKeys: VirtualizerKey[];
+    getNode: (key: VirtualizerKey) => VirtualizerNode | undefined;
+    getChildNodes: (key: VirtualizerKey) => VirtualizerNode[];
+}
+/**
+ * Why a layout is being asked to run again.
+ *
+ * A layout reads these to decide how much of itself to throw away: a size change invalidates
+ * every measurement, while a scroll usually invalidates nothing.
+ */
+export interface InvalidationContext<Options = unknown> {
+    contentChanged?: boolean;
+    offsetChanged?: boolean;
+    sizeChanged?: boolean;
+    itemSizeChanged?: boolean;
+    layoutOptions?: Options;
+}
+/** What a layout may ask of the virtualizer it is attached to. */
+export interface VirtualizerLayoutHost {
+    readonly collection: VirtualizerCollection;
+    readonly persistedKeys: Set<VirtualizerKey>;
+    /** The visible rectangle in content coordinates. */
+    readonly visibleRect: Rect;
+    /** The size of the scroll container, which is not the same as the visible rectangle. */
+    readonly size: Size;
+    isPersistedKey: (key: VirtualizerKey) => boolean;
+}
+export declare abstract class Layout<Options = unknown> {
+    /** Set by the virtualizer when the layout is attached. */
+    host: VirtualizerLayoutHost | null;
+    /** Every layout info inside `rect`, parents before children. */
+    abstract getVisibleLayoutInfos(rect: Rect): LayoutInfo[];
+    abstract getLayoutInfo(key: VirtualizerKey): LayoutInfo | null;
+    abstract getContentSize(): Size;
+    /** Called before either getter, so the layout can compute whatever it needs. */
+    update(context: InvalidationContext<Options>): void;
+    /**
+     * Whether a new visible rectangle invalidates the layout. Size changes do by default; a layout
+     * that positions something against the scroll offset returns `true` always.
+     */
+    shouldInvalidate(newRect: Rect, oldRect: Rect): boolean;
+    /** Whether new options invalidate the layout. Identity by default. */
+    shouldInvalidateLayoutOptions(newOptions: Options, oldOptions: Options): boolean;
+    /** Records a measured size. Returns whether it changed anything. */
+    updateItemSize?(key: VirtualizerKey, size: Size): boolean;
+    /**
+     * Resolves a pointer position to a drop target, making the layout its own
+     * {@link DropTargetDelegate}.
+     *
+     * Optional, and the reason it has to be: the DOM-based delegate searches for elements, and
+     * outside the window there are none. A layout knows where every row *would* be, rendered or
+     * not, so a windowed collection asks it instead.
+     *
+     * @param x - Horizontal offset from the collection container's top left corner.
+     * @param y - Vertical offset from the same corner.
+     */
+    getDropTargetFromPoint?(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget | null;
+    /**
+     * Where a drop indicator for the given target belongs.
+     *
+     * A drop indicator is not in the collection — it sits between two things that are — so nothing
+     * has laid it out. This is where the layout says how a gap is placed, which for a stack means
+     * a thin band straddling the boundary.
+     */
+    getDropTargetLayoutInfo?(target: ItemDropTarget): LayoutInfo;
+    getItemRect(key: VirtualizerKey): Rect | null;
+    getVisibleRect(): Rect;
+}

package/dist/utils/virtualizer-layout.js

@@ -0,0 +1,26 @@
+//#region src/utils/virtualizer-layout.ts
+var Layout = class {
+	/** Set by the virtualizer when the layout is attached. */
+	host = null;
+	/** Called before either getter, so the layout can compute whatever it needs. */
+	update(context) {}
+	/**
+	* Whether a new visible rectangle invalidates the layout. Size changes do by default; a layout
+	* that positions something against the scroll offset returns `true` always.
+	*/
+	shouldInvalidate(newRect, oldRect) {
+		return newRect.width !== oldRect.width || newRect.height !== oldRect.height;
+	}
+	/** Whether new options invalidate the layout. Identity by default. */
+	shouldInvalidateLayoutOptions(newOptions, oldOptions) {
+		return newOptions !== oldOptions;
+	}
+	getItemRect(key) {
+		return this.getLayoutInfo(key)?.rect ?? null;
+	}
+	getVisibleRect() {
+		return this.host.visibleRect;
+	}
+};
+//#endregion
+export { Layout };

package/dist/utils/virtualizer-list-layout.d.ts

@@ -0,0 +1,147 @@
+import type { DropTarget, ItemDropTarget } from "./dnd-types";
+import type { InvalidationContext, VirtualizerCollection, VirtualizerNode } from "./virtualizer-layout";
+import type { VirtualizerKey } from "./virtualizer-layout-info";
+import { Rect, Size } from "./virtualizer-geometry";
+import { Layout } from "./virtualizer-layout";
+import { LayoutInfo } from "./virtualizer-layout-info";
+export interface ListLayoutOptions {
+    /** The fixed size of a row, in px. */
+    rowSize?: number;
+    /** The size to place a row at before it has been measured, when rows vary. */
+    estimatedRowSize?: number;
+    /** The fixed size of a section header, in px. */
+    headingSize?: number;
+    /** The size to place a section header at before it has been measured. */
+    estimatedHeadingSize?: number;
+    /** The fixed size of a loading sentinel, in px. */
+    loaderSize?: number;
+    /** The space between items, in px. */
+    gap?: number;
+    /** The space around the whole list, in px. */
+    padding?: number;
+    /** How thick the line marking a gap between two items is, in px. @default 2 */
+    dropIndicatorThickness?: number;
+    /** @deprecated Use `rowSize`. Accepted because React Aria still does. */
+    rowHeight?: number;
+    /** @deprecated Use `estimatedRowSize`. */
+    estimatedRowHeight?: number;
+    /** @deprecated Use `headingSize`. */
+    headingHeight?: number;
+    /** @deprecated Use `estimatedHeadingSize`. */
+    estimatedHeadingHeight?: number;
+    /** @deprecated Use `loaderSize`. */
+    loaderHeight?: number;
+}
+/** A layout info plus the hierarchy around it, which a table needs and a list does not. */
+export interface LayoutNode {
+    layoutInfo: LayoutInfo;
+    children: LayoutNode[];
+    /** The part of the layout info that has been computed against real data. */
+    validRect: Rect;
+    node?: VirtualizerNode;
+    index?: number;
+}
+export declare class ListLayout<Options extends ListLayoutOptions = ListLayoutOptions> extends Layout<Options> {
+    protected rowSize: number | null;
+    protected estimatedRowSize: number | null;
+    protected headingSize: number | null;
+    protected estimatedHeadingSize: number | null;
+    protected loaderSize: number | null;
+    protected gap: number;
+    protected padding: number;
+    protected dropIndicatorThickness: number;
+    protected layoutNodes: Map<VirtualizerKey, LayoutNode>;
+    protected rootNodes: LayoutNode[];
+    protected contentSize: Size;
+    /** The region rows have been computed for. Everything outside it is only accounted for. */
+    protected requestedRect: Rect;
+    /** The part of `requestedRect` whose rows are known-good. */
+    protected validRect: Rect;
+    protected lastCollection: VirtualizerCollection | null;
+    private invalidateEverything;
+    constructor(options?: ListLayoutOptions);
+    getContentSize(): Size;
+    getLayoutInfo(key: VirtualizerKey): LayoutInfo | null;
+    /**
+     * The rectangle grown to whole rows.
+     *
+     * Without this a one-pixel scroll would change which rows fall inside the rectangle, and the set
+     * of rendered elements would churn on every frame. A table snaps differently — its own row
+     * stride ignores the gap — so this is the one part of the walk a subclass replaces.
+     */
+    protected snapVisibleRect(rect: Rect): Rect;
+    /** Every layout info inside `rect`, snapped to whole rows, parents before children. */
+    getVisibleLayoutInfos(rect: Rect): LayoutInfo[];
+    update(context: InvalidationContext<Options>): void;
+    shouldInvalidateLayoutOptions(newOptions: Options, oldOptions: Options): boolean;
+    /**
+     * Records a row's measured size.
+     *
+     * Returns whether anything moved, which is the virtualizer's cue to lay out again. The rows
+     * below this one are the ones that moved, so the valid region is cut off at this row's offset
+     * rather than thrown away entirely.
+     */
+    updateItemSize(key: VirtualizerKey, size: Size): boolean;
+    protected shouldInvalidateEverything(context: InvalidationContext<Options>): boolean;
+    /** Extends the computed region to cover `rect`, and to cover every persisted key. */
+    protected layoutIfNeeded(rect: Rect): void;
+    /**
+     * Computes the whole layout when a key is asked about that the lazy pass never reached.
+     *
+     * Pressing End, or restoring focus to a selected row, asks about a key at an arbitrary offset;
+     * there is no way to know where it sits without laying out everything above it.
+     */
+    private ensureLayoutInfo;
+    private replaceLayoutInfo;
+    protected buildCollection(offset?: number): LayoutNode[];
+    protected buildChild(node: VirtualizerNode, x: number, y: number, parentKey: VirtualizerKey | null): LayoutNode;
+    protected buildNode(node: VirtualizerNode, x: number, y: number): LayoutNode;
+    protected buildItem(node: VirtualizerNode, x: number, y: number): LayoutNode;
+    /**
+     * Whether a cached row can be reused as it stands.
+     *
+     * Everything here has to hold: nothing global was invalidated, the datum is the same object,
+     * the row is at the same offset, it sits inside the known-good region, and the part of it that
+     * was computed covers the part now being asked about.
+     */
+    protected isValid(node: VirtualizerNode, y: number): boolean;
+    protected buildLoader(node: VirtualizerNode, x: number, y: number): LayoutNode;
+    /**
+     * Whether a node belongs in the rendered set.
+     *
+     * A sticky element, a header and a loader are always in it — they are on screen at offsets the
+     * rectangle does not describe. A persisted key is in it because something depends on the
+     * element existing: the roving tab stop lives on the focused item, and losing its element
+     * would drop focus to the document.
+     */
+    protected isVisible(node: LayoutNode, rect: Rect): boolean;
+    /**
+     * Whether a laid-out element is somewhere a drop could land.
+     *
+     * The one thing a table changes: its rendered set holds cells and column headers as well as
+     * rows, and only a row is a drop target.
+     */
+    protected isDropCandidate(_layoutInfo: LayoutInfo): boolean;
+    /**
+     * The nearest row edge to a point, ported from React Aria's `ListLayout`.
+     *
+     * The search is a one-pixel-wide sliver rather than a hit test, and it measures distance to
+     * each candidate's **edges** rather than to its middle — the question a drop asks is "which
+     * boundary is this nearest", and between two rows the answer belongs to whichever edge is
+     * closer, not to whichever row the pointer happens to be over.
+     */
+    getDropTargetFromPoint(x: number, y: number, isValidDropTarget: (target: DropTarget) => boolean): DropTarget | null;
+    /**
+     * Where the indicator for a gap is placed.
+     *
+     * A band of `dropIndicatorThickness` straddling the boundary — half above it and half below —
+     * so a two-pixel line sits *on* the edge rather than pushing the rows apart. Dropping onto a
+     * row instead covers the whole row, which is what lets it be highlighted.
+     *
+     * One branch of React Aria's version is deliberately absent: it walks "after" down past the
+     * target's descendants so the line lands below a whole open subtree. A `VirtualizerNode` here
+     * carries no level, because a windowed collection is built from flat data and this build has
+     * no virtualized tree to be wrong about. It would have to come back with one.
+     */
+    getDropTargetLayoutInfo(target: ItemDropTarget): LayoutInfo;
+}