simple-table-core 4.0.1 → 4.0.3

package/dist/{cjs/src/core → core}/rendering/RenderOrchestrator.d.ts

@@ -1,172 +1,174 @@
-import { SimpleTableConfig } from "../../types/SimpleTableConfig";
-import { CustomTheme } from "../../types/CustomTheme";
-import HeaderObject, { Accessor } from "../../types/HeaderObject";
-import Row from "../../types/Row";
-import RowState from "../../types/RowState";
-import { DimensionManager } from "../../managers/DimensionManager";
-import { ScrollManager } from "../../managers/ScrollManager";
-import type { SectionScrollController } from "../../managers/SectionScrollController";
-import { SortManager } from "../../managers/SortManager";
-import { FilterManager } from "../../managers/FilterManager";
-import { SelectionManager } from "../../managers/SelectionManager";
-import { RowSelectionManager } from "../../managers/RowSelectionManager";
-import type { AnimationCoordinator, CellPosition } from "../../managers/AnimationCoordinator";
-import type { AccordionAxis } from "../../utils/accordionAnimation";
-import type { NestedTableFactory } from "../../utils/nestedGridRowRenderer";
-import { FlattenRowsResult } from "../../utils/rowFlattening";
-import { ProcessRowsResult } from "../../utils/rowProcessing";
-import { MergedColumnEditorConfig, ResolvedIcons } from "../initialization/TableInitializer";
-export interface RenderContext {
-    /**
-     * Active accordion animation axis for this render. Set on row-grouping or
-     * nested-column collapse/expand toggles (see
-     * {@link SimpleTableVanilla.beginAccordionAnimation}). Cell renderers use it
-     * to initialize incoming cells at zero size in the named axis so the CSS
-     * size transition can grow them while sibling cells FLIP into place.
-     */
-    accordionAxis?: AccordionAxis;
-    animationCoordinator?: AnimationCoordinator;
-    cellRegistry: Map<string, any>;
-    collapsedHeaders: Set<Accessor>;
-    collapsedRows: Map<string, number>;
-    config: SimpleTableConfig;
-    customTheme: CustomTheme;
-    dimensionManager: DimensionManager | null;
-    draggedHeaderRef: {
-        current: HeaderObject | null;
-    };
-    effectiveHeaders: HeaderObject[];
-    essentialAccessors: Set<string>;
-    expandedDepths: Set<number>;
-    expandedRows: Map<string, number>;
-    filterManager: FilterManager | null;
-    getCollapsedRows: () => Map<string, number>;
-    getCollapsedHeaders?: () => Set<Accessor>;
-    getExpandedRows: () => Map<string, number>;
-    getHeaders: () => HeaderObject[];
-    /** Pristine snapshot of the configured column definitions — the reset target for the column editor's reset button. */
-    getPristineDefaultHeaders: () => HeaderObject[];
-    getRowStateMap: () => Map<string | number, RowState>;
-    headerRegistry: Map<string, any>;
-    headers: HeaderObject[];
-    /**
-     * Unique id for this table instance. Scopes row-hover cell tracking so
-     * multiple tables on one page with overlapping rowIds don't cross-hover.
-     */
-    hoverScopeId: string;
-    hoveredHeaderRef: {
-        current: HeaderObject | null;
-    };
-    internalIsLoading: boolean;
-    isResizing: boolean;
-    localRows: Row[];
-    /** Injected factory for nested grid tables (breaks the SimpleTableVanilla import cycle). */
-    createNestedTable?: NestedTableFactory;
-    mainBodyRef: {
-        current: HTMLDivElement | null;
-    };
-    mainHeaderRef: {
-        current: HTMLDivElement | null;
-    };
-    onRender: () => void;
-    /** Natural-width shrink floors (accessor -> px) for auto-expand column resize. */
-    getShrinkFloors?: () => Map<string, number>;
-    /** Persist user-set widths (drag / double-click auto-fit) as natural widths. */
-    onAutoExpandNaturalWidths?: (widths: Map<string, number>) => void;
-    pinnedLeftHeaderRef: {
-        current: HTMLDivElement | null;
-    };
-    pinnedLeftRef: {
-        current: HTMLDivElement | null;
-    };
-    pinnedRightHeaderRef: {
-        current: HTMLDivElement | null;
-    };
-    pinnedRightRef: {
-        current: HTMLDivElement | null;
-    };
-    resolvedIcons: ResolvedIcons;
-    rowSelectionManager: RowSelectionManager | null;
-    rowStateMap: Map<string | number, RowState>;
-    scrollManager: ScrollManager | null;
-    sectionScrollController: SectionScrollController | null;
-    selectionManager: SelectionManager | null;
-    setCollapsedHeaders: (headers: Set<Accessor>) => void;
-    setCollapsedRows: (rows: Map<string, number>) => void;
-    setColumnEditorOpen: (open: boolean) => void;
-    setCurrentPage: (page: number) => void;
-    setExpandedRows: (rows: Map<string, number>) => void;
-    setHeaders: (headers: HeaderObject[]) => void;
-    setIsResizing: (value: boolean) => void;
-    setRowStateMap: (map: Map<string | number, any>) => void;
-    sortManager: SortManager | null;
-    /** When true, body cells that stay visible get only position updates (no content/selection recalc). Used during vertical scroll for performance. */
-    positionOnlyBody?: boolean;
-    /**
-     * Visible portion of the table inside an external scroll parent (in pixels).
-     * Set by {@link SimpleTableVanilla} per render when `config.scrollParent` is
-     * active and no explicit `height`/`maxHeight` is set. Drives virtualization
-     * the same way an explicit `height` does, but the scroll source is external.
-     */
-    externalViewportHeight?: number;
-}
-export interface RenderState {
-    currentPage: number;
-    scrollTop: number;
-    scrollDirection: "up" | "down" | "none";
-    scrollbarWidth: number;
-    isMainSectionScrollable: boolean;
-    columnEditorOpen: boolean;
-}
-export declare class RenderOrchestrator {
-    private tableRenderer;
-    private lastHeadersRef;
-    private lastRowsRef;
-    private flattenedRowsCache;
-    private lastProcessedResult;
-    /** Fingerprint for skipping pagination + height-map work on vertical scroll frames. */
-    private processRowsScrollReuseKey;
-    private processRowsScrollReuseBase;
-    /** Last painted virtual row range on scroll-raf; when unchanged, DOM work is redundant (native scroll moves content). */
-    private lastScrollRafPaintedRange;
-    /** Reuse normalized headers across scroll frames when layout inputs are unchanged. */
-    private scrollRafHeadersMemo;
-    constructor();
-    getCachedFlattenResult(): FlattenRowsResult | null;
-    getLastProcessedResult(): ProcessRowsResult | null;
-    /** See {@link TableRenderer.getCurrentBodyLayouts}. */
-    getCurrentBodyLayouts(): Map<HTMLElement, Map<string, CellPosition>>;
-    setOnRendererHostDiscard(cb: ((host: HTMLElement) => void) | undefined): void;
-    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
-    computeEffectiveHeaders(headers: HeaderObject[], config: SimpleTableConfig, customTheme: CustomTheme, containerWidth?: number): HeaderObject[];
-    /**
-     * Warms flattened/processed row caches so imperative APIs (e.g. getVisibleRows) are
-     * correct before the first ResizeObserver-driven render, without mutating the DOM.
-     */
-    primeLastProcessedResult(context: RenderContext, state: RenderState): void;
-    private buildRowModelSnapshot;
-    render(elements: {
-        bodyContainer: HTMLElement;
-        content: HTMLElement;
-        contentWrapper: HTMLElement;
-        footerContainer: HTMLElement;
-        headerContainer: HTMLElement;
-        rootElement: HTMLElement;
-        wrapperContainer: HTMLElement;
-    }, refs: {
-        mainBodyRef: {
-            current: HTMLDivElement | null;
-        };
-        tableBodyContainerRef: {
-            current: HTMLDivElement | null;
-        };
-    }, context: RenderContext, state: RenderState, mergedColumnEditorConfig: MergedColumnEditorConfig): void;
-    private renderHeader;
-    private renderBody;
-    private renderFooter;
-    private renderColumnEditor;
-    private renderHorizontalScrollbar;
-    private registerSectionPanes;
-    private buildRendererDeps;
-    cleanup(): void;
-}
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import { CustomTheme } from "../../types/CustomTheme";
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import Row from "../../types/Row";
+import RowState from "../../types/RowState";
+import { DimensionManager } from "../../managers/DimensionManager";
+import { ScrollManager } from "../../managers/ScrollManager";
+import type { SectionScrollController } from "../../managers/SectionScrollController";
+import { SortManager } from "../../managers/SortManager";
+import { FilterManager } from "../../managers/FilterManager";
+import { SelectionManager } from "../../managers/SelectionManager";
+import { RowSelectionManager } from "../../managers/RowSelectionManager";
+import type { AnimationCoordinator, CellPosition } from "../../managers/AnimationCoordinator";
+import type { AccordionAxis } from "../../utils/accordionAnimation";
+import type { NestedTableFactory } from "../../utils/nestedGridRowRenderer";
+import { FlattenRowsResult } from "../../utils/rowFlattening";
+import { ProcessRowsResult } from "../../utils/rowProcessing";
+import { MergedColumnEditorConfig, ResolvedIcons } from "../initialization/TableInitializer";
+export interface RenderContext {
+    /**
+     * Active accordion animation axis for this render. Set on row-grouping or
+     * nested-column collapse/expand toggles (see
+     * {@link SimpleTableVanilla.beginAccordionAnimation}). Cell renderers use it
+     * to initialize incoming cells at zero size in the named axis so the CSS
+     * size transition can grow them while sibling cells FLIP into place.
+     */
+    accordionAxis?: AccordionAxis;
+    animationCoordinator?: AnimationCoordinator;
+    cellRegistry: Map<string, any>;
+    collapsedHeaders: Set<Accessor>;
+    collapsedRows: Map<string, number>;
+    config: SimpleTableConfig;
+    customTheme: CustomTheme;
+    dimensionManager: DimensionManager | null;
+    draggedHeaderRef: {
+        current: HeaderObject | null;
+    };
+    effectiveHeaders: HeaderObject[];
+    essentialAccessors: Set<string>;
+    expandedDepths: Set<number>;
+    expandedRows: Map<string, number>;
+    filterManager: FilterManager | null;
+    getCollapsedRows: () => Map<string, number>;
+    getCollapsedHeaders?: () => Set<Accessor>;
+    getExpandedRows: () => Map<string, number>;
+    getHeaders: () => HeaderObject[];
+    /** Pristine snapshot of the configured column definitions — the reset target for the column editor's reset button. */
+    getPristineDefaultHeaders: () => HeaderObject[];
+    getRowStateMap: () => Map<string | number, RowState>;
+    headerRegistry: Map<string, any>;
+    headers: HeaderObject[];
+    /**
+     * Unique id for this table instance. Scopes row-hover cell tracking so
+     * multiple tables on one page with overlapping rowIds don't cross-hover.
+     */
+    hoverScopeId: string;
+    hoveredHeaderRef: {
+        current: HeaderObject | null;
+    };
+    internalIsLoading: boolean;
+    isResizing: boolean;
+    localRows: Row[];
+    /** Injected factory for nested grid tables (breaks the SimpleTableVanilla import cycle). */
+    createNestedTable?: NestedTableFactory;
+    mainBodyRef: {
+        current: HTMLDivElement | null;
+    };
+    mainHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    onRender: () => void;
+    /** Natural-width shrink floors (accessor -> px) for auto-expand column resize. */
+    getShrinkFloors?: () => Map<string, number>;
+    /** Persist user-set widths (drag / double-click auto-fit) as natural widths. */
+    onAutoExpandNaturalWidths?: (widths: Map<string, number>) => void;
+    pinnedLeftHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedLeftRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightHeaderRef: {
+        current: HTMLDivElement | null;
+    };
+    pinnedRightRef: {
+        current: HTMLDivElement | null;
+    };
+    resolvedIcons: ResolvedIcons;
+    rowSelectionManager: RowSelectionManager | null;
+    rowStateMap: Map<string | number, RowState>;
+    scrollManager: ScrollManager | null;
+    sectionScrollController: SectionScrollController | null;
+    selectionManager: SelectionManager | null;
+    setCollapsedHeaders: (headers: Set<Accessor>) => void;
+    setCollapsedRows: (rows: Map<string, number>) => void;
+    setColumnEditorOpen: (open: boolean) => void;
+    setCurrentPage: (page: number) => void;
+    setExpandedRows: (rows: Map<string, number>) => void;
+    setHeaders: (headers: HeaderObject[]) => void;
+    setIsResizing: (value: boolean) => void;
+    setRowStateMap: (map: Map<string | number, any>) => void;
+    sortManager: SortManager | null;
+    /** When true, body cells that stay visible get only position updates (no content/selection recalc). Used during vertical scroll for performance. */
+    positionOnlyBody?: boolean;
+    /**
+     * Visible portion of the table inside an external scroll parent (in pixels).
+     * Set by {@link SimpleTableVanilla} per render when `config.scrollParent` is
+     * active and no explicit `height`/`maxHeight` is set. Drives virtualization
+     * the same way an explicit `height` does, but the scroll source is external.
+     */
+    externalViewportHeight?: number;
+}
+export interface RenderState {
+    currentPage: number;
+    scrollTop: number;
+    scrollDirection: "up" | "down" | "none";
+    scrollbarWidth: number;
+    isMainSectionScrollable: boolean;
+    columnEditorOpen: boolean;
+}
+export declare class RenderOrchestrator {
+    private tableRenderer;
+    private lastHeadersRef;
+    private lastRowsRef;
+    private flattenedRowsCache;
+    private lastProcessedResult;
+    /** Fingerprint for skipping pagination + height-map work on vertical scroll frames. */
+    private processRowsScrollReuseKey;
+    private processRowsScrollReuseBase;
+    /** Last painted virtual row range on scroll-raf; when unchanged, DOM work is redundant (native scroll moves content). */
+    private lastScrollRafPaintedRange;
+    /** Reuse normalized headers across scroll frames when layout inputs are unchanged. */
+    private scrollRafHeadersMemo;
+    constructor();
+    getCachedFlattenResult(): FlattenRowsResult | null;
+    getLastProcessedResult(): ProcessRowsResult | null;
+    /** See {@link TableRenderer.getCurrentBodyLayouts}. */
+    getCurrentBodyLayouts(): Map<HTMLElement, Map<string, CellPosition>>;
+    setOnRendererHostDiscard(cb: ((host: HTMLElement) => void) | undefined): void;
+    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
+    /** @see TableRenderer.invalidateCustomFooterCache */
+    invalidateCustomFooterCache(): void;
+    computeEffectiveHeaders(headers: HeaderObject[], config: SimpleTableConfig, customTheme: CustomTheme, containerWidth?: number): HeaderObject[];
+    /**
+     * Warms flattened/processed row caches so imperative APIs (e.g. getVisibleRows) are
+     * correct before the first ResizeObserver-driven render, without mutating the DOM.
+     */
+    primeLastProcessedResult(context: RenderContext, state: RenderState): void;
+    private buildRowModelSnapshot;
+    render(elements: {
+        bodyContainer: HTMLElement;
+        content: HTMLElement;
+        contentWrapper: HTMLElement;
+        footerContainer: HTMLElement;
+        headerContainer: HTMLElement;
+        rootElement: HTMLElement;
+        wrapperContainer: HTMLElement;
+    }, refs: {
+        mainBodyRef: {
+            current: HTMLDivElement | null;
+        };
+        tableBodyContainerRef: {
+            current: HTMLDivElement | null;
+        };
+    }, context: RenderContext, state: RenderState, mergedColumnEditorConfig: MergedColumnEditorConfig): void;
+    private renderHeader;
+    private renderBody;
+    private renderFooter;
+    private renderColumnEditor;
+    private renderHorizontalScrollbar;
+    private registerSectionPanes;
+    private buildRendererDeps;
+    cleanup(): void;
+}

package/dist/{src/core → core}/rendering/SectionRenderer.d.ts

@@ -1,119 +1,119 @@
-import HeaderObject, { Accessor } from "../../types/HeaderObject";
-import { HeaderRenderContext } from "../../utils/headerCellRenderer";
-import { CellRenderContext } from "../../utils/bodyCellRenderer";
-import TableRow from "../../types/TableRow";
-import type { AnimationCoordinator, CellPosition } from "../../managers/AnimationCoordinator";
-export interface HeaderSectionParams {
-    headers: HeaderObject[];
-    collapsedHeaders: Set<Accessor>;
-    pinned?: "left" | "right";
-    maxHeaderDepth: number;
-    headerHeight: number;
-    context: HeaderRenderContext;
-    sectionWidth?: number;
-    startColIndex?: number;
-}
-export interface BodySectionParams {
-    headers: HeaderObject[];
-    rows: TableRow[];
-    collapsedHeaders: Set<Accessor>;
-    pinned?: "left" | "right";
-    context: CellRenderContext;
-    sectionWidth?: number;
-    rowHeight: number;
-    heightOffsets?: Array<[number, number]>;
-    totalRowCount?: number;
-    startColIndex?: number;
-    /** When true, only update cell positions for existing cells (scroll performance). */
-    positionOnly?: boolean;
-    /** Full table rows ref + range for range-based body cell cache (avoids cache miss on every scroll). */
-    fullTableRows?: TableRow[];
-    renderedStartIndex?: number;
-    renderedEndIndex?: number;
-    /** Full pre-pagination flattened rows (used by animation snapshot to include
-     * off-page rows so cross-page sort can FLIP cells in/out from off-screen). */
-    allFlattenedRows?: TableRow[];
-    /** Global flattened-list index where the current page starts. Used to offset
-     * absolute positions in {@link allFlattenedRows} so on-page rows align with
-     * the page-relative DOM positions while off-page rows fall above/below. */
-    pageStartIndex?: number;
-    /** When provided, body cell renderer hands outgoing cells to the coordinator
-     * for FLIP-style out-animation instead of removing them immediately. */
-    animationCoordinator?: AnimationCoordinator;
-}
-export declare class SectionRenderer {
-    private headerSections;
-    private bodySections;
-    /**
-     * Callback fired before a body cell host element is permanently removed in
-     * the {@link invalidateCache} "all" path (which wipes every rendered cell).
-     * Threaded down from the table config so framework adapters can tear down
-     * renderer subtrees (React portals, etc.) before the nodes are discarded.
-     */
-    private onRendererHostDiscard?;
-    private bodyCellsCache;
-    private headerCellsCache;
-    private contextCache;
-    private bodySectionSnapshots;
-    private nextColIndexMap;
-    private stateRowsMap;
-    private nestedGridRowsMap;
-    renderHeaderSection(params: HeaderSectionParams): HTMLElement;
-    renderBodySection(params: BodySectionParams): HTMLElement;
-    private renderNestedGridRows;
-    private renderStateRows;
-    private calculateAbsoluteHeaderCells;
-    private calculateAbsoluteBodyCells;
-    private getLeafHeaders;
-    private createHeadersHash;
-    private createHeightOffsetsHash;
-    private createContextHash;
-    private getCachedBodyCells;
-    private getCachedHeaderCells;
-    private getCachedContext;
-    setOnRendererHostDiscard(cb: ((host: HTMLElement) => void) | undefined): void;
-    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
-    /**
-     * Get the next colIndex after rendering a section
-     */
-    getNextColIndex(sectionKey: string): number;
-    /**
-     * Build a per-section layout map covering every cell in the dataset (every
-     * row × every leaf header), not just the cells in the current virtualization
-     * band. Used by the animation coordinator: it needs positions for off-screen
-     * rows so that:
-     *
-     *   - Cells that newly enter the visible band (e.g. row sorted from bottom
-     *     to top) can FLIP in from their actual pre-change off-screen `top`.
-     *   - Cells that leave the visible band (e.g. row sorted from top to
-     *     bottom) can be retained and slid to their actual post-change
-     *     off-screen `top` before being removed.
-     *
-     * The body container clips overflow so cells whose interpolated position
-     * falls outside the viewport simply aren't painted — the animation looks
-     * like a slide in from / out to the viewport edge.
-     */
-    getCurrentBodyLayouts(): Map<HTMLElement, Map<string, CellPosition>>;
-    /**
-     * Compute every cell position the section currently knows about (every row
-     * × every leaf header), including positions for off-screen rows, by using
-     * the most recent snapshot config for `sectionKey`. Returns null if no
-     * snapshot has been captured for this section yet.
-     */
-    getFullSectionLayout(sectionKey: string): Map<string, CellPosition> | null;
-    /**
-     * Refresh the per-section snapshot config so getCurrentBodyLayouts can
-     * recompute positions for any row × column combination the section
-     * currently knows about.
-     */
-    private captureSnapshotConfig;
-    /**
-     * Tear down all body sections and forget them so a subsequent
-     * `renderBodySection` creates fresh nodes. Used when the empty-state path
-     * takes over the body container: clearing `innerHTML` alone leaves
-     * `renderedCells` pointing at detached nodes, so rows never remount when
-     * data returns (e.g. typing `-E` mid-filter briefly matches every row).
-     */
-    releaseBodySections(): void;
-    cleanup(): void;
-}
+import HeaderObject, { Accessor } from "../../types/HeaderObject";
+import { HeaderRenderContext } from "../../utils/headerCellRenderer";
+import { CellRenderContext } from "../../utils/bodyCellRenderer";
+import TableRow from "../../types/TableRow";
+import type { AnimationCoordinator, CellPosition } from "../../managers/AnimationCoordinator";
+export interface HeaderSectionParams {
+    headers: HeaderObject[];
+    collapsedHeaders: Set<Accessor>;
+    pinned?: "left" | "right";
+    maxHeaderDepth: number;
+    headerHeight: number;
+    context: HeaderRenderContext;
+    sectionWidth?: number;
+    startColIndex?: number;
+}
+export interface BodySectionParams {
+    headers: HeaderObject[];
+    rows: TableRow[];
+    collapsedHeaders: Set<Accessor>;
+    pinned?: "left" | "right";
+    context: CellRenderContext;
+    sectionWidth?: number;
+    rowHeight: number;
+    heightOffsets?: Array<[number, number]>;
+    totalRowCount?: number;
+    startColIndex?: number;
+    /** When true, only update cell positions for existing cells (scroll performance). */
+    positionOnly?: boolean;
+    /** Full table rows ref + range for range-based body cell cache (avoids cache miss on every scroll). */
+    fullTableRows?: TableRow[];
+    renderedStartIndex?: number;
+    renderedEndIndex?: number;
+    /** Full pre-pagination flattened rows (used by animation snapshot to include
+     * off-page rows so cross-page sort can FLIP cells in/out from off-screen). */
+    allFlattenedRows?: TableRow[];
+    /** Global flattened-list index where the current page starts. Used to offset
+     * absolute positions in {@link allFlattenedRows} so on-page rows align with
+     * the page-relative DOM positions while off-page rows fall above/below. */
+    pageStartIndex?: number;
+    /** When provided, body cell renderer hands outgoing cells to the coordinator
+     * for FLIP-style out-animation instead of removing them immediately. */
+    animationCoordinator?: AnimationCoordinator;
+}
+export declare class SectionRenderer {
+    private headerSections;
+    private bodySections;
+    /**
+     * Callback fired before a body cell host element is permanently removed in
+     * the {@link invalidateCache} "all" path (which wipes every rendered cell).
+     * Threaded down from the table config so framework adapters can tear down
+     * renderer subtrees (React portals, etc.) before the nodes are discarded.
+     */
+    private onRendererHostDiscard?;
+    private bodyCellsCache;
+    private headerCellsCache;
+    private contextCache;
+    private bodySectionSnapshots;
+    private nextColIndexMap;
+    private stateRowsMap;
+    private nestedGridRowsMap;
+    renderHeaderSection(params: HeaderSectionParams): HTMLElement;
+    renderBodySection(params: BodySectionParams): HTMLElement;
+    private renderNestedGridRows;
+    private renderStateRows;
+    private calculateAbsoluteHeaderCells;
+    private calculateAbsoluteBodyCells;
+    private getLeafHeaders;
+    private createHeadersHash;
+    private createHeightOffsetsHash;
+    private createContextHash;
+    private getCachedBodyCells;
+    private getCachedHeaderCells;
+    private getCachedContext;
+    setOnRendererHostDiscard(cb: ((host: HTMLElement) => void) | undefined): void;
+    invalidateCache(type?: "body" | "header" | "context" | "all"): void;
+    /**
+     * Get the next colIndex after rendering a section
+     */
+    getNextColIndex(sectionKey: string): number;
+    /**
+     * Build a per-section layout map covering every cell in the dataset (every
+     * row × every leaf header), not just the cells in the current virtualization
+     * band. Used by the animation coordinator: it needs positions for off-screen
+     * rows so that:
+     *
+     *   - Cells that newly enter the visible band (e.g. row sorted from bottom
+     *     to top) can FLIP in from their actual pre-change off-screen `top`.
+     *   - Cells that leave the visible band (e.g. row sorted from top to
+     *     bottom) can be retained and slid to their actual post-change
+     *     off-screen `top` before being removed.
+     *
+     * The body container clips overflow so cells whose interpolated position
+     * falls outside the viewport simply aren't painted — the animation looks
+     * like a slide in from / out to the viewport edge.
+     */
+    getCurrentBodyLayouts(): Map<HTMLElement, Map<string, CellPosition>>;
+    /**
+     * Compute every cell position the section currently knows about (every row
+     * × every leaf header), including positions for off-screen rows, by using
+     * the most recent snapshot config for `sectionKey`. Returns null if no
+     * snapshot has been captured for this section yet.
+     */
+    getFullSectionLayout(sectionKey: string): Map<string, CellPosition> | null;
+    /**
+     * Refresh the per-section snapshot config so getCurrentBodyLayouts can
+     * recompute positions for any row × column combination the section
+     * currently knows about.
+     */
+    private captureSnapshotConfig;
+    /**
+     * Tear down all body sections and forget them so a subsequent
+     * `renderBodySection` creates fresh nodes. Used when the empty-state path
+     * takes over the body container: clearing `innerHTML` alone leaves
+     * `renderedCells` pointing at detached nodes, so rows never remount when
+     * data returns (e.g. typing `-E` mid-filter briefly matches every row).
+     */
+    releaseBodySections(): void;
+    cleanup(): void;
+}