ropav 0.2.0 → 0.3.0

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

@@ -0,0 +1,379 @@
+import { Rect, Size } from "./virtualizer-geometry.js";
+import { LayoutInfo } from "./virtualizer-layout-info.js";
+import { Layout } from "./virtualizer-layout.js";
+//#region src/utils/virtualizer-list-layout.ts
+/**
+* A stack layout for the virtualizer, ported from React Aria's `ListLayout`.
+*
+* Items are placed one after another along the block axis, each as wide as the scroll container
+* minus the padding. With `rowSize` given the geometry is arithmetic; without it each item is
+* placed at an estimate and corrected once it has been measured.
+*
+* The layout is lazy. It computes rows for the region it has been asked about — `requestedRect` —
+* and accounts for everything outside it arithmetically, so a thousand rows cost about as much as
+* a screenful. `validRect` records how much of that region is known-good, which is what lets a
+* measured row survive the next pass instead of being placed at an estimate again.
+*
+* Two things are deliberately absent, both recorded as debt: the horizontal orientation, which no
+* collection in this library uses, and the `section`/`header`/`separator` node types, which cannot
+* reach a layout through the data-driven collection this build has.
+*/
+/** The height React Aria falls back to when neither a fixed nor an estimated size is given. */
+var DEFAULT_ROW_SIZE = 48;
+var ListLayout = class extends Layout {
+	rowSize;
+	estimatedRowSize;
+	headingSize;
+	estimatedHeadingSize;
+	loaderSize;
+	gap;
+	padding;
+	dropIndicatorThickness;
+	layoutNodes = /* @__PURE__ */ new Map();
+	rootNodes = [];
+	contentSize = new Size();
+	/** The region rows have been computed for. Everything outside it is only accounted for. */
+	requestedRect = new Rect();
+	/** The part of `requestedRect` whose rows are known-good. */
+	validRect = new Rect();
+	lastCollection = null;
+	invalidateEverything = false;
+	constructor(options = {}) {
+		super();
+		this.rowSize = options.rowSize ?? options.rowHeight ?? null;
+		this.estimatedRowSize = options.estimatedRowSize ?? options.estimatedRowHeight ?? null;
+		this.headingSize = options.headingSize ?? options.headingHeight ?? null;
+		this.estimatedHeadingSize = options.estimatedHeadingSize ?? options.estimatedHeadingHeight ?? null;
+		this.loaderSize = options.loaderSize ?? options.loaderHeight ?? null;
+		this.gap = options.gap ?? 0;
+		this.padding = options.padding ?? 0;
+		this.dropIndicatorThickness = options.dropIndicatorThickness ?? 2;
+	}
+	getContentSize() {
+		return this.contentSize;
+	}
+	getLayoutInfo(key) {
+		this.ensureLayoutInfo(key);
+		return this.layoutNodes.get(key)?.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.
+	*/
+	snapVisibleRect(rect) {
+		if (rect.height <= 1) return rect;
+		const rowSize = (this.rowSize ?? this.estimatedRowSize ?? DEFAULT_ROW_SIZE) + this.gap;
+		const snapped = rect.copy();
+		const y = Math.floor(snapped.y / rowSize) * rowSize;
+		const height = snapped.height + snapped.y - y;
+		snapped.y = y;
+		snapped.height = Math.ceil(height / rowSize) * rowSize;
+		return snapped;
+	}
+	/** Every layout info inside `rect`, snapped to whole rows, parents before children. */
+	getVisibleLayoutInfos(rect) {
+		const searchRect = this.snapVisibleRect(rect);
+		this.layoutIfNeeded(searchRect);
+		const result = [];
+		const addNodes = (nodes) => {
+			for (const node of nodes) {
+				if (!this.isVisible(node, searchRect)) continue;
+				result.push(node.layoutInfo);
+				addNodes(node.children);
+			}
+		};
+		addNodes(this.rootNodes);
+		return result;
+	}
+	update(context) {
+		const collection = this.host.collection;
+		this.invalidateEverything = this.shouldInvalidateEverything(context);
+		if (this.invalidateEverything) {
+			this.requestedRect = this.host.visibleRect.copy();
+			this.layoutNodes.clear();
+		}
+		const options = context.layoutOptions;
+		this.rowSize = options?.rowSize ?? options?.rowHeight ?? this.rowSize;
+		this.estimatedRowSize = options?.estimatedRowSize ?? options?.estimatedRowHeight ?? this.estimatedRowSize;
+		this.headingSize = options?.headingSize ?? options?.headingHeight ?? this.headingSize;
+		this.estimatedHeadingSize = options?.estimatedHeadingSize ?? options?.estimatedHeadingHeight ?? this.estimatedHeadingSize;
+		this.loaderSize = options?.loaderSize ?? options?.loaderHeight ?? this.loaderSize;
+		this.gap = options?.gap ?? this.gap;
+		this.padding = options?.padding ?? this.padding;
+		this.dropIndicatorThickness = options?.dropIndicatorThickness ?? this.dropIndicatorThickness;
+		this.rootNodes = this.buildCollection();
+		if (this.lastCollection && collection !== this.lastCollection) {
+			for (const key of this.lastCollection.keys) if (!collection.getNode(key)) this.layoutNodes.delete(key);
+		}
+		this.lastCollection = collection;
+		this.invalidateEverything = false;
+		this.validRect = this.requestedRect.copy();
+	}
+	shouldInvalidateLayoutOptions(newOptions, oldOptions) {
+		return (newOptions?.rowSize ?? newOptions?.rowHeight) !== (oldOptions?.rowSize ?? oldOptions?.rowHeight) || (newOptions?.estimatedRowSize ?? newOptions?.estimatedRowHeight) !== (oldOptions?.estimatedRowSize ?? oldOptions?.estimatedRowHeight) || (newOptions?.headingSize ?? newOptions?.headingHeight) !== (oldOptions?.headingSize ?? oldOptions?.headingHeight) || (newOptions?.estimatedHeadingSize ?? newOptions?.estimatedHeadingHeight) !== (oldOptions?.estimatedHeadingSize ?? oldOptions?.estimatedHeadingHeight) || (newOptions?.loaderSize ?? newOptions?.loaderHeight) !== (oldOptions?.loaderSize ?? oldOptions?.loaderHeight) || newOptions?.gap !== oldOptions?.gap || newOptions?.padding !== oldOptions?.padding;
+	}
+	/**
+	* 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, size) {
+		const layoutNode = this.layoutNodes.get(key);
+		if (!layoutNode) return false;
+		const layoutInfo = layoutNode.layoutInfo;
+		layoutInfo.estimatedSize = false;
+		if (layoutInfo.rect.height === size.height) return false;
+		const measured = layoutInfo.copy();
+		measured.rect.height = size.height;
+		layoutNode.layoutInfo = measured;
+		this.validRect.height = Math.min(this.validRect.height, layoutInfo.rect.y - this.validRect.y);
+		if (layoutNode.node?.type === "item" || layoutNode.node?.type === "row") this.requestedRect.height += measured.rect.height - layoutInfo.rect.height;
+		this.replaceLayoutInfo(key, layoutInfo, measured);
+		let parentKey = layoutInfo.parentKey;
+		while (parentKey != null) {
+			this.replaceLayoutInfo(parentKey, layoutInfo, measured);
+			parentKey = this.layoutNodes.get(parentKey)?.layoutInfo.parentKey ?? null;
+		}
+		return true;
+	}
+	shouldInvalidateEverything(context) {
+		const options = context.layoutOptions;
+		return Boolean(context.sizeChanged || this.rowSize !== (options?.rowSize ?? options?.rowHeight ?? this.rowSize) || this.headingSize !== (options?.headingSize ?? options?.headingHeight ?? this.headingSize) || this.loaderSize !== (options?.loaderSize ?? options?.loaderHeight ?? this.loaderSize) || this.gap !== (options?.gap ?? this.gap) || this.padding !== (options?.padding ?? this.padding));
+	}
+	/** Extends the computed region to cover `rect`, and to cover every persisted key. */
+	layoutIfNeeded(rect) {
+		if (!this.lastCollection) return;
+		if (!this.requestedRect.containsRect(rect)) {
+			this.requestedRect = this.requestedRect.union(rect);
+			this.rootNodes = this.buildCollection();
+		}
+		for (const key of this.host.persistedKeys) if (this.ensureLayoutInfo(key)) return;
+	}
+	/**
+	* 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.
+	*/
+	ensureLayoutInfo(key) {
+		if (this.layoutNodes.has(key) || !this.lastCollection || this.requestedRect.area >= this.contentSize.area) return false;
+		this.requestedRect = new Rect(0, 0, Infinity, Infinity);
+		this.rootNodes = this.buildCollection();
+		this.requestedRect = new Rect(0, 0, this.contentSize.width, this.contentSize.height);
+		return true;
+	}
+	replaceLayoutInfo(key, oldLayoutInfo, newLayoutInfo) {
+		const layoutNode = this.layoutNodes.get(key);
+		if (!layoutNode) return;
+		layoutNode.validRect = layoutNode.validRect.intersection(this.validRect);
+		if (layoutNode.layoutInfo === oldLayoutInfo) layoutNode.layoutInfo = newLayoutInfo;
+	}
+	buildCollection(offset = this.padding) {
+		const collection = this.host.collection;
+		const rootKeys = collection.rootKeys;
+		const nodes = [];
+		const isEmpty = collection.itemCount === 0;
+		const rowStride = (this.rowSize ?? this.estimatedRowSize ?? DEFAULT_ROW_SIZE) + this.gap;
+		const pendingLoaderKeys = rootKeys.filter((key) => collection.getNode(key)?.type === "loader");
+		let y = isEmpty ? 0 : offset;
+		for (const [index, key] of rootKeys.entries()) {
+			const node = collection.getNode(key);
+			if (!node) continue;
+			const isRow = node.type === "item" || node.type === "row";
+			if (isRow && y + rowStride < this.requestedRect.y && !this.isValid(node, y)) {
+				y += rowStride;
+				continue;
+			}
+			const layoutNode = this.buildChild(node, this.padding, y, null);
+			y = layoutNode.layoutInfo.rect.maxY + this.gap;
+			nodes.push(layoutNode);
+			if (node.type === "loader") pendingLoaderKeys.splice(pendingLoaderKeys.indexOf(key), 1);
+			if (!(isRow || node.type === "loader") || y <= this.requestedRect.maxY) continue;
+			let lastIndex = index;
+			for (const loaderKey of pendingLoaderKeys) {
+				const loaderNode = collection.getNode(loaderKey);
+				if (!loaderNode) continue;
+				const loaderIndex = rootKeys.indexOf(loaderKey);
+				y += (loaderIndex - lastIndex - 1) * rowStride;
+				const loader = this.buildChild(loaderNode, this.padding, y, null);
+				nodes.push(loader);
+				y = loader.layoutInfo.rect.maxY;
+				lastIndex = loaderIndex;
+			}
+			y += (rootKeys.length - lastIndex - 1) * rowStride;
+			break;
+		}
+		y = Math.max(y - this.gap, 0);
+		y += isEmpty ? 0 : this.padding;
+		this.contentSize = new Size(this.host.size.width, y);
+		return nodes;
+	}
+	buildChild(node, x, y, parentKey) {
+		if (this.isValid(node, y)) return this.layoutNodes.get(node.key);
+		const layoutNode = this.buildNode(node, x, y);
+		layoutNode.layoutInfo.parentKey = parentKey;
+		layoutNode.layoutInfo.allowOverflow = true;
+		this.layoutNodes.set(node.key, layoutNode);
+		return layoutNode;
+	}
+	buildNode(node, x, y) {
+		switch (node.type) {
+			case "item":
+			case "row": return this.buildItem(node, x, y);
+			case "loader": return this.buildLoader(node, x, y);
+			default: throw new Error(`Unsupported node type: ${node.type}`);
+		}
+	}
+	buildItem(node, x, y) {
+		const width = this.host.size.width - this.padding - x;
+		let height = this.rowSize;
+		let isEstimated = false;
+		if (height == null) {
+			const previous = this.layoutNodes.get(node.key);
+			if (previous) {
+				height = previous.layoutInfo.rect.height;
+				isEstimated = width !== previous.layoutInfo.rect.width || node !== previous.node || previous.layoutInfo.estimatedSize;
+			} else {
+				height = this.estimatedRowSize;
+				isEstimated = true;
+			}
+		}
+		const layoutInfo = new LayoutInfo(node.type, node.key, new Rect(x, y, width, height ?? DEFAULT_ROW_SIZE));
+		layoutInfo.estimatedSize = isEstimated;
+		return {
+			children: [],
+			layoutInfo,
+			node,
+			validRect: layoutInfo.rect.intersection(this.requestedRect)
+		};
+	}
+	/**
+	* 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.
+	*/
+	isValid(node, y) {
+		const cached = this.layoutNodes.get(node.key);
+		return !this.invalidateEverything && !!cached && cached.node === node && cached.layoutInfo.rect.y === y && cached.layoutInfo.rect.intersects(this.validRect) && cached.validRect.containsRect(cached.layoutInfo.rect.intersection(this.requestedRect));
+	}
+	buildLoader(node, x, y) {
+		const width = this.host.size.width - this.padding - x;
+		const height = this.loaderSize ?? this.rowSize ?? this.estimatedRowSize ?? DEFAULT_ROW_SIZE;
+		const layoutInfo = new LayoutInfo("loader", node.key, new Rect(x, y, width, height));
+		layoutInfo.estimatedSize = this.loaderSize == null && this.rowSize == null;
+		return {
+			children: [],
+			layoutInfo,
+			node,
+			validRect: layoutInfo.rect.intersection(this.requestedRect)
+		};
+	}
+	/**
+	* 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.
+	*/
+	isVisible(node, rect) {
+		return node.layoutInfo.rect.intersects(rect) || node.layoutInfo.isSticky || node.layoutInfo.type === "header" || node.layoutInfo.type === "loader" || this.host.isPersistedKey(node.layoutInfo.key);
+	}
+	/**
+	* 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.
+	*/
+	isDropCandidate(_layoutInfo) {
+		return true;
+	}
+	/**
+	* 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, y, isValidDropTarget) {
+		const visibleRect = this.host.visibleRect;
+		const pointX = x + visibleRect.x;
+		const pointY = y + visibleRect.y;
+		const searchRect = new Rect(pointX, Math.max(0, pointY - this.gap), 1, Math.max(1, this.gap * 2));
+		let key = null;
+		let minDistance = Infinity;
+		for (const candidate of this.getVisibleLayoutInfos(searchRect)) {
+			if (!this.isDropCandidate(candidate) || !candidate.rect.intersects(searchRect)) continue;
+			const distance = Math.min(Math.abs(candidate.rect.y - pointY), Math.abs(candidate.rect.maxY - pointY));
+			if (distance < minDistance) {
+				minDistance = distance;
+				key = candidate.key;
+			}
+		}
+		if (key == null || this.host.collection.itemCount === 0) return { type: "root" };
+		const layoutInfo = this.getLayoutInfo(key);
+		if (!layoutInfo) return null;
+		const rect = layoutInfo.rect;
+		const target = {
+			dropPosition: "on",
+			key: layoutInfo.key,
+			type: "item"
+		};
+		/**
+		* Where within the row the point means.
+		*
+		* Dropping on the row wins the middle when it is allowed, and before/after only take the
+		* outer 10px. When it is not allowed the row splits down the middle instead, so every
+		* pixel resolves to one side or the other.
+		*/
+		if (!isValidDropTarget(target)) {
+			if (pointY <= rect.y + rect.height / 2 && isValidDropTarget({
+				...target,
+				dropPosition: "before"
+			})) target.dropPosition = "before";
+			else if (isValidDropTarget({
+				...target,
+				dropPosition: "after"
+			})) target.dropPosition = "after";
+		} else if (pointY <= rect.y + 10 && isValidDropTarget({
+			...target,
+			dropPosition: "before"
+		})) target.dropPosition = "before";
+		else if (pointY >= rect.maxY - 10 && isValidDropTarget({
+			...target,
+			dropPosition: "after"
+		})) target.dropPosition = "after";
+		return target;
+	}
+	/**
+	* 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) {
+		const rect = this.getLayoutInfo(target.key)?.rect ?? new Rect();
+		const thickness = this.dropIndicatorThickness;
+		let indicatorRect;
+		if (target.dropPosition === "before") indicatorRect = new Rect(rect.x, Math.max(0, rect.y - thickness / 2), rect.width, thickness);
+		else if (target.dropPosition === "after") indicatorRect = new Rect(rect.x, rect.maxY - thickness / 2, rect.width, thickness);
+		else indicatorRect = rect;
+		return new LayoutInfo("dropIndicator", `${target.key}:${target.dropPosition}`, indicatorRect);
+	}
+};
+//#endregion
+export { ListLayout };

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

@@ -0,0 +1,20 @@
+import { Rect } from "./virtualizer-geometry";
+/**
+ * How much beyond the viewport the virtualizer renders, ported from React Aria's
+ * `OverscanManager`.
+ *
+ * A third of the viewport is added past the scroll direction, so a fast scroll has something to
+ * land on rather than a gap. The extra is added in the direction of travel only, which is why the
+ * rendered set depends on how the scroll position was arrived at and not only on where it is.
+ *
+ * Velocity is never reset, exactly as upstream: after a scroll upward it stays negative while the
+ * list sits still, and the window keeps its extra rows above. Anything comparing rendered sets
+ * has to pin the direction of arrival, not just the offset.
+ */
+export declare class OverscanManager {
+    private startTime;
+    private velocity;
+    private visibleRect;
+    setVisibleRect(rect: Rect): void;
+    getOverscannedRect(): Rect;
+}

package/dist/utils/virtualizer-overscan.js

@@ -0,0 +1,40 @@
+import { Point, Rect } from "./virtualizer-geometry.js";
+//#region src/utils/virtualizer-overscan.ts
+/**
+* How much beyond the viewport the virtualizer renders, ported from React Aria's
+* `OverscanManager`.
+*
+* A third of the viewport is added past the scroll direction, so a fast scroll has something to
+* land on rather than a gap. The extra is added in the direction of travel only, which is why the
+* rendered set depends on how the scroll position was arrived at and not only on where it is.
+*
+* Velocity is never reset, exactly as upstream: after a scroll upward it stays negative while the
+* list sits still, and the window keeps its extra rows above. Anything comparing rendered sets
+* has to pin the direction of arrival, not just the offset.
+*/
+var OverscanManager = class {
+	startTime = 0;
+	velocity = new Point(0, 0);
+	visibleRect = new Rect();
+	setVisibleRect(rect) {
+		const time = performance.now() - this.startTime;
+		if (time < 500) {
+			if (rect.x !== this.visibleRect.x && time > 0) this.velocity.x = (rect.x - this.visibleRect.x) / time;
+			if (rect.y !== this.visibleRect.y && time > 0) this.velocity.y = (rect.y - this.visibleRect.y) / time;
+		}
+		this.startTime = performance.now();
+		this.visibleRect = rect;
+	}
+	getOverscannedRect() {
+		const overscanned = this.visibleRect.copy();
+		const overscanY = this.visibleRect.height / 3;
+		const overscanX = this.visibleRect.width / 3;
+		overscanned.height += overscanY;
+		if (this.velocity.y < 0) overscanned.y -= overscanY;
+		overscanned.width += overscanX;
+		if (this.velocity.x < 0) overscanned.x -= overscanX;
+		return overscanned;
+	}
+};
+//#endregion
+export { OverscanManager };

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

@@ -0,0 +1,98 @@
+import type { ItemDropTarget } from "./dnd-types";
+import type { VirtualizerTableCollection } from "./virtualizer-collection";
+import type { InvalidationContext, VirtualizerNode } from "./virtualizer-layout";
+import type { VirtualizerKey } from "./virtualizer-layout-info";
+import type { LayoutNode, ListLayoutOptions } from "./virtualizer-list-layout";
+import { Rect } from "./virtualizer-geometry";
+import { LayoutInfo } from "./virtualizer-layout-info";
+import { ListLayout } from "./virtualizer-list-layout";
+export interface TableLayoutOptions extends ListLayoutOptions {
+    /**
+     * How wide each column is, in px.
+     *
+     * A column with no entry here is zero wide, exactly as upstream has it. The table supplies the
+     * whole map, because it is the same map the non-virtualized table lays its columns out with.
+     */
+    columnWidths?: Map<VirtualizerKey, number>;
+}
+export declare class TableLayout<Options extends TableLayoutOptions = TableLayoutOptions> extends ListLayout<Options> {
+    private columnWidths;
+    protected get tableCollection(): VirtualizerTableCollection;
+    shouldInvalidateLayoutOptions(newOptions: Options, oldOptions: Options): boolean;
+    update(context: InvalidationContext<Options>): void;
+    private widthsChanged;
+    /**
+     * The rectangle grown to whole rows.
+     *
+     * The table's own stride, which ignores the gap and does not compensate for how far the top edge
+     * moved — the list layout does both. Kept as upstream has it, because one extra row rendered is
+     * one row of difference against the React build.
+     */
+    protected snapVisibleRect(rect: Rect): Rect;
+    /**
+     * Every layout info to render, parents before children.
+     *
+     * The rows are found by a binary search rather than by testing each one against the rectangle,
+     * and the two do not agree at the edges: the search treats a row whose bottom edge is exactly the
+     * rectangle's top edge as **above** the window, while an intersection test counts a shared edge
+     * as an overlap. Since the rectangle is snapped to whole rows, its top edge lands on a row
+     * boundary nearly always — so the difference is a whole extra row, every time. That is what makes
+     * this a port and not a simplification.
+     */
+    getVisibleLayoutInfos(rect: Rect): LayoutInfo[];
+    private addVisibleLayoutInfos;
+    /**
+     * The child whose band contains `y`, clamped to the ends.
+     *
+     * A row ending exactly on `y` counts as being before it, which is the edge rule the whole window
+     * turns on.
+     */
+    private binarySearch;
+    protected getEstimatedRowHeight(): number;
+    protected buildCollection(): LayoutNode[];
+    protected buildTableHeader(): LayoutNode;
+    protected buildHeaderRow(node: VirtualizerNode, x: number, y: number): LayoutNode;
+    protected buildColumn(node: VirtualizerNode, x: number, y: number): LayoutNode;
+    protected buildRowGroup(y: number, node: VirtualizerNode): LayoutNode;
+    protected buildRow(node: VirtualizerNode, x: number, y: number): LayoutNode;
+    protected buildCell(node: VirtualizerNode, x: number, y: number): LayoutNode;
+    protected buildLoader(node: VirtualizerNode, x: number, y: number): LayoutNode;
+    protected buildNode(node: VirtualizerNode, x: number, y: number): LayoutNode;
+    /** How wide the whole table is, which the header is the only part that knows. */
+    private headerWidth;
+    /** How wide the column a cell or a column header covers is. */
+    private getRenderedColumnWidth;
+    /**
+     * A height nobody declared.
+     *
+     * A part that has already been measured keeps that height. It counts as an estimate again if it
+     * got narrower or wider, or if the datum behind it changed — either can reflow its content.
+     */
+    private getEstimatedHeight;
+    /**
+     * Level the parts of one row.
+     *
+     * A row is as tall as its tallest cell, and every cell in it is that tall — which is what makes
+     * a border run the width of the row rather than stopping under the shortest cell.
+     */
+    private setChildHeights;
+    /**
+     * Only a row is somewhere a drop can land.
+     *
+     * The whole search inherited from the list layout is right; what differs is what it searches
+     * over. A table's rendered set also holds the sticky header and its columns, which sit at an
+     * offset the visible rectangle does not describe — near the top of the collection they are the
+     * nearest thing to the pointer, and naming one would offer a drop into the header. Cells are
+     * excluded too, though they would lose anyway: a row is reported before its own cells, and the
+     * comparison keeps the first of equals.
+     */
+    protected isDropCandidate(layoutInfo: LayoutInfo): boolean;
+    /**
+     * The indicator belongs to the body, not to the table.
+     *
+     * Every layout info in a table is positioned against its parent, and a gap between two rows
+     * sits inside the same rowgroup they do. Without the parent it would be placed against the
+     * table's own origin and land under the header.
+     */
+    getDropTargetLayoutInfo(target: ItemDropTarget): LayoutInfo;
+}