simple-table-core 4.0.1 → 4.0.3

package/dist/src/core/SimpleTableVanilla.d.ts

@@ -1,369 +0,0 @@
-import { SimpleTableConfig } from "../types/SimpleTableConfig";
-import { TableAPI } from "../types/TableAPI";
-import "../styles/all-themes.css";
-export declare class SimpleTableVanilla {
-    private container;
-    private config;
-    private customTheme;
-    private mergedColumnEditorConfig;
-    private resolvedIcons;
-    private domManager;
-    private renderOrchestrator;
-    private draggedHeaderRef;
-    private hoveredHeaderRef;
-    private localRows;
-    private headers;
-    /**
-     * Pristine deep-cloned snapshot of the column definitions as configured
-     * (constructor / update with `defaultHeaders`). `this.headers` shares object
-     * references with `config.defaultHeaders` at mount, and the column editor
-     * mutates header objects in place (e.g. `header.hide = true`) — so
-     * `config.defaultHeaders` drifts with runtime state and cannot serve as the
-     * reset target. `resetColumns()` restores from this snapshot instead, giving
-     * a well-defined default: every column visible except those explicitly
-     * configured with `hide: true` in the definitions.
-     */
-    private pristineDefaultHeaders;
-    private essentialAccessors;
-    /** Accessors of leaf columns that should size to content (width:"auto" or autoSizeColumns). */
-    private autoSizeAccessors;
-    /** Accessors awaiting a content-fit measurement on the next render. */
-    private pendingAutoSize;
-    /**
-     * Natural (unexpanded) pixel width per leaf column, overriding the declared
-     * width: the measured content width for `width: "auto"` columns and the
-     * width the user explicitly set via drag-resize / double-click auto-fit.
-     * With autoExpandColumns these feed the shrink floors used during column
-     * resize — neighbors give up surplus (expanded) space but are never
-     * squeezed below their natural width; past that point the section
-     * overflows into horizontal scroll.
-     */
-    private naturalWidths;
-    /** Guard against re-entrancy while the auto-size pass re-renders. */
-    private isAutoSizing;
-    private currentPage;
-    private scrollTop;
-    private scrollDirection;
-    private isResizing;
-    private isScrolling;
-    /** True when this render is scroll-driven so body can use position-only updates for existing cells. */
-    private _positionOnlyBody;
-    private firstRenderDone;
-    private internalIsLoading;
-    private scrollbarWidth;
-    private isMainSectionScrollable;
-    private columnEditorOpen;
-    private collapsedHeaders;
-    private expandedDepths;
-    private expandedRows;
-    private collapsedRows;
-    private rowStateMap;
-    private announcement;
-    private cellRegistry;
-    private static nextHoverScopeId;
-    /**
-     * Unique id for this table instance. Scopes the module-level row-hover cell
-     * map so multiple tables on one page with overlapping rowIds don't cross-hover.
-     */
-    private readonly hoverScopeId;
-    private headerRegistry;
-    private rowIndexMap;
-    private animationCoordinator;
-    /**
-     * When true, the sort subscriber skips `captureAnimationSnapshot` so
-     * live-update-driven reorder/visibility changes don't FLIP-animate.
-     * User-initiated sorts leave this false and keep FLIP.
-     */
-    private suppressNextAnimationSnapshot;
-    /** Lazily created once — callers often invoke getAPI() every live tick. */
-    private cachedAPI;
-    private autoScaleManager;
-    private dimensionManager;
-    private scrollManager;
-    private sectionScrollController;
-    private sortManager;
-    private filterManager;
-    private pivotManager;
-    private selectionManager;
-    private rowSelectionManager;
-    private windowResizeManager;
-    private handleOutsideClickManager;
-    private scrollbarVisibilityManager;
-    private expandedDepthsManager;
-    private ariaAnnouncementManager;
-    private mounted;
-    private scrollRafId;
-    private scrollEndTimeoutId;
-    private lastScrollTop;
-    private isUpdating;
-    /** Set once the dev-only "too many unvirtualized rows" warning has fired, so it never repeats. */
-    private hasWarnedUnvirtualizedRows;
-    /** Pending deferred check for the unvirtualized-rows warning (lets external-scroll seeding settle first). */
-    private unvirtualizedRowsCheckTimeoutId;
-    /** Currently resolved external scroll parent (HTMLElement or window). Null when external scroll mode is inactive. */
-    private resolvedScrollParent;
-    /** Bound scroll handler attached to the external scroll parent. */
-    private externalScrollListener;
-    /** Bound resize handler attached to window when scrollParent is "window". */
-    private externalWindowResizeListener;
-    /** ResizeObserver watching the external scroll parent element. */
-    private externalParentResizeObserver;
-    /** Cached visible viewport height of the table inside the external parent. Fed into virtualization. */
-    private externalViewportHeight;
-    /**
-     * rAF handle for retrying resolution of a configured-but-not-yet-resolvable
-     * `scrollParent` (e.g. a getter pointing at a ref attached on a later commit
-     * than this table's mount). Null when no retry is pending.
-     */
-    private externalScrollRetryRaf;
-    /** Number of resolution retries attempted; bounded so we don't spin forever. */
-    private externalScrollRetryCount;
-    private static readonly EXTERNAL_SCROLL_MAX_RETRIES;
-    /** True iff the body-container scroll listener is currently attached. */
-    private bodyScrollListenerAttached;
-    /** Bound mouseleave handler on the body container. */
-    private bodyContainerMouseLeaveListener;
-    /** Bound scroll handler attached to the body container (internal scroll mode). */
-    private bodyContainerScrollListener;
-    /**
-     * When external scroll mode is active we briefly take control of the scroll
-     * parent's `overscroll-behavior-y` to neutralize the browser's rubber-band /
-     * scroll-chaining at the boundaries. Without this, pulling past the top or
-     * bottom of the scroll parent visually translates the entire scroll content
-     * layer (including the CSS-sticky header), causing the header to "disappear"
-     * during overscroll bounces even though its layout position is unchanged.
-     * We record the previous inline value so {@link detachExternalScrollWiring}
-     * can restore it cleanly.
-     */
-    private overscrollBehaviorTarget;
-    private overscrollBehaviorPrev;
-    /**
-     * Active accordion axis for the next render. Set by row/column collapse-
-     * expand mutators (see {@link beginAccordionAnimation}) and consumed by the
-     * cell renderers via the render context. Cleared in {@link render} after
-     * each render so subsequent non-accordion renders (sort, scroll, etc.)
-     * don't re-trigger the size transitions.
-     */
-    private pendingAccordionAxis;
-    /** Pending timeout id used to remove the accordion CSS class. */
-    private accordionCleanupTimerId;
-    /**
-     * Visible-leaf-headers key as of the last render that committed to the DOM.
-     * Used by `setHeaders` to detect hide/show/pin/unpin and trigger the
-     * accordion-horizontal animation. Comparing against `this.headers` directly
-     * doesn't work because the column editor mutates header objects in place
-     * (e.g. `header.hide = true`) BEFORE invoking setHeaders, so by the time
-     * setHeaders runs, the prev and next trees already point to the same
-     * mutated header instances.
-     */
-    private lastRenderedVisibilityKey;
-    constructor(container: HTMLElement, config: SimpleTableConfig);
-    private applyAnimationsConfig;
-    private rebuildRowIndexMap;
-    private getBodyContainers;
-    private getHeaderContainers;
-    /**
-     * All cell-bearing containers — body sections AND header sections — that the
-     * animation coordinator needs to inspect. Headers participate in FLIP for
-     * column reorder so their cells slide to their new slot rather than
-     * teleporting.
-     */
-    private getAnimatableContainers;
-    /**
-     * Capture pre-change cell positions for the FLIP animation, including
-     * conceptual positions for cells outside the virtualization viewport so
-     * incoming cells can animate from off-screen on column reorder/sort. The
-     * `play` step that runs at the end of the next render consumes this
-     * snapshot to inverse-transform cells from their old visual positions and
-     * tween them to their new ones.
-     *
-     * Called on every layout-affecting state change — including the chain of
-     * mid-drag `setHeaders` calls that fire on each `dragover` swap — so that
-     * displaced columns slide smoothly out of the dragged column's way rather
-     * than snapping into place.
-     */
-    /**
-     * Build a key summarizing the leaf columns that will paint (accessor +
-     * pinned section). Hidden leaves and excluded subtrees drop out; nested
-     * children are flattened so a parent collapse/expand counts as a
-     * visibility change at the leaf level too.
-     */
-    private buildVisibilityKey;
-    /**
-     * True when the visible-leaf-set (or its pinned-section assignment) for
-     * `nextHeaders` differs from the last render that committed to the DOM.
-     *
-     * We deliberately compare against {@link lastRenderedVisibilityKey} rather
-     * than `this.headers`: the column editor mutates header objects in place
-     * before invoking setHeaders (e.g. `header.hide = true`, then
-     * `setHeaders(deepClone(headers))`), and `this.headers` shares those
-     * mutated references — so a prev-vs-next compare always reads the same
-     * state and reports no change. Comparing to the last-rendered key sees
-     * the user's actually-painted state and correctly detects hide/show and
-     * pin/unpin changes.
-     */
-    private didColumnVisibilityChange;
-    private captureAnimationSnapshot;
-    /**
-     * Push the visible vertical viewport into the animation coordinator when
-     * external/page scroll is active (or clear it otherwise). Keeps the FLIP
-     * distance-scaling viewport-relative so cells don't slide the full
-     * conceptual distance when the table grows to its natural height.
-     */
-    private updateAnimationVerticalScroll;
-    /**
-     * Open the accordion animation window for the next render: capture a FLIP
-     * snapshot, mark the active axis so cell renderers initialize incoming
-     * cells at zero size, and add the CSS class that enables the size
-     * transitions on `.st-cell` / `.st-header-cell`.
-     *
-     * The CSS class is removed after `duration + ACCORDION_CLEANUP_BUFFER_MS`
-     * so non-accordion renders don't keep transitioning size on subsequent
-     * inline-style writes.
-     *
-     * No-op when animations are disabled (which already includes the
-     * prefers-reduced-motion check via {@link AnimationCoordinator.isEnabled}).
-     */
-    /**
-     * Walk the CURRENT (pre-change) header tree and collect every accessor that
-     * is renderable as a header cell given the current collapsed/hidden state —
-     * group headers plus the leaf columns visible under them (honoring
-     * `showWhen` and the collapsed set). Used by {@link beginAccordionAnimation}
-     * to seed the animation coordinator's re-entry guard.
-     */
-    private collectAccordionRenderableAccessors;
-    private beginAccordionAnimation;
-    private initializeManagers;
-    mount(): void;
-    private setupManagers;
-    private setupEventListeners;
-    /**
-     * Reconciles which element owns the vertical scroll listener based on the
-     * current `scrollParent` config. Called on mount and whenever `update()`
-     * could have changed the relevant inputs (`scrollParent` / `height` /
-     * `maxHeight`). Idempotent — safe to call repeatedly.
-     */
-    private syncExternalScrollWiring;
-    /**
-     * Retry resolving a configured `scrollParent` on the next animation frame.
-     * Used when the parent (typically a getter pointing at a ref) was not yet
-     * resolvable when external wiring last ran. Bounded by
-     * {@link SimpleTableVanilla.EXTERNAL_SCROLL_MAX_RETRIES} so a permanently
-     * unresolvable parent doesn't spin forever.
-     */
-    private scheduleExternalScrollParentRetry;
-    private ensureBodyScrollListenerAttached;
-    private ensureBodyScrollListenerDetached;
-    private attachExternalScrollWiring;
-    private detachExternalScrollWiring;
-    /**
-     * Set `overscroll-behavior-y: none` on the resolved scroll parent (or
-     * `document.documentElement` for `scrollParent: "window"`). This neutralizes
-     * the browser's elastic rubber-band at the scroll boundaries, which would
-     * otherwise translate the entire scroll content layer (including our
-     * `position: sticky` header) during overscroll bounces — making the header
-     * visually disappear off the top of the parent. `contain` only stops scroll
-     * chaining; we need `none` to actually disable the elastic bounce on the
-     * scroll container itself. Previous inline value is captured so we can
-     * restore it on detach.
-     */
-    private applyOverscrollContainment;
-    private restoreOverscrollBehavior;
-    /**
-     * Read the resolved scroll parent's computed `padding-top` and publish it
-     * as `--st-external-scroll-padding-top` on the table root. The sticky
-     * header CSS uses `top: calc(-1 * var(...))` so the header pins flush to
-     * the parent's outer top edge instead of the padding edge, eliminating the
-     * visible gap that CSS sticky would otherwise produce when the consumer
-     * gives the scroll parent any top padding. Re-run on layout changes via
-     * ResizeObserver / window resize.
-     */
-    private recomputeExternalScrollPaddingTop;
-    /**
-     * Recompute the visible portion of the table inside the external scroll
-     * parent and push it into the DimensionManager so virtualization math
-     * picks it up. Cheap; called on scroll, on parent/window resize, and on
-     * every re-render where the resolved parent may have moved.
-     */
-    private recomputeExternalViewportHeight;
-    private handleExternalResize;
-    private handleExternalScroll;
-    private handleScroll;
-    private clearHoveredRows;
-    private updateAriaLiveRegion;
-    /** Row grouping used for flatten/expand while pivot is active (overrides consumer). */
-    private getEffectiveRowGrouping;
-    /**
-     * Recompute pivot from filtered source rows and feed sort/selection managers.
-     * When pivot is inactive, sort sees the filtered source rows directly.
-     */
-    private syncPivotPipeline;
-    private getRenderContext;
-    private getRenderState;
-    /** A leaf column that should size to content (declared with width:"auto"). */
-    private isAutoSizeLeaf;
-    private computeAutoSizeAccessors;
-    private getAutoSizeStyleRoot;
-    /**
-     * Rows that content-fit ("auto") measurement should sample. With client-side
-     * pagination only the current page is rendered, so fit columns to the page's
-     * rows rather than the entire dataset — otherwise off-page values inflate
-     * every auto column's width.
-     */
-    private getAutoSizeRows;
-    /**
-     * Shrink floors for auto-expand column resize, keyed by accessor. Each
-     * visible leaf's floor is its natural width — a user-set / content-measured
-     * override when present, else the pixel width declared in the column
-     * definitions — raised to at least its `minWidth` (or the global minimum).
-     * Flexible declarations (fr / % / unmeasured "auto") have no pixel natural,
-     * so they floor at `minWidth` alone.
-     */
-    private getShrinkFloors;
-    /** Record user-set / measured widths as the columns' new natural widths. */
-    private recordNaturalWidths;
-    /** Immutably write measured pixel widths into the leaf headers. */
-    private applyMeasuredWidths;
-    /**
-     * Measure and apply content-fit widths for any pending "auto" columns, then
-     * re-render once at the final widths. Called at the end of render(); the
-     * measurement reads the just-rendered (provisional-width) DOM and the
-     * corrective render happens in the same synchronous task, so there is no
-     * visible width snap.
-     *
-     * With autoExpandColumns, the measured width becomes the column's natural
-     * width: the expand-only auto-scale pass in the corrective render stretches
-     * columns to fill surplus container space, or leaves them at natural width
-     * (horizontal scroll) when they don't fit.
-     */
-    private maybeAutoSizeColumns;
-    /**
-     * Re-run the content-fit measurement for all auto-size columns. Useful for
-     * host frameworks (e.g. React) whose custom renderers mount asynchronously:
-     * calling this from a layout effect (pre-paint) re-measures once the real
-     * renderer DOM is present, so the column fits accurately without flicker.
-     */
-    refitAutoSizeColumns(): void;
-    private render;
-    /**
-     * Dev-only safeguard. Schedules a one-shot, deferred check that warns when the
-     * table is about to render a very large number of rows with no virtualization
-     * active (no `height` / `maxHeight` and no bounded `scrollParent`). The check
-     * is deferred so external-scroll viewport seeding (which can momentarily leave
-     * `contentHeight` undefined on the first paint) has time to settle and we
-     * don't cry wolf for a correctly-configured table. Compiled out of production
-     * via the NODE_ENV guard. Never throws.
-     */
-    private maybeScheduleUnvirtualizedRowsWarning;
-    private evaluateUnvirtualizedRowsWarning;
-    update(config: Partial<SimpleTableConfig>): void;
-    /** @deprecated Use {@link update} — same behavior. */
-    updateConfig(config: Partial<SimpleTableConfig>): void;
-    /**
-     * Create, update, or destroy the RowSelectionManager when enableRowSelection
-     * (and related props) change at runtime.
-     */
-    private syncRowSelectionManager;
-    destroy(): void;
-    getAPI(): TableAPI;
-}

package/dist/src/core/dom/DOMManager.d.ts

@@ -1,52 +0,0 @@
-import { SimpleTableConfig } from "../../types/SimpleTableConfig";
-export interface DOMElements {
-    rootElement: HTMLElement;
-    wrapperContainer: HTMLElement;
-    contentWrapper: HTMLElement;
-    content: HTMLElement;
-    headerContainer: HTMLElement;
-    bodyContainer: HTMLElement;
-    footerContainer: HTMLElement;
-    ariaLiveRegion: HTMLElement;
-}
-export interface DOMRefs {
-    mainBodyRef: {
-        current: HTMLDivElement | null;
-    };
-    pinnedLeftRef: {
-        current: HTMLDivElement | null;
-    };
-    pinnedRightRef: {
-        current: HTMLDivElement | null;
-    };
-    mainHeaderRef: {
-        current: HTMLDivElement | null;
-    };
-    pinnedLeftHeaderRef: {
-        current: HTMLDivElement | null;
-    };
-    pinnedRightHeaderRef: {
-        current: HTMLDivElement | null;
-    };
-    headerContainerRef: {
-        current: HTMLDivElement | null;
-    };
-    tableBodyContainerRef: {
-        current: HTMLDivElement | null;
-    };
-    horizontalScrollbarRef: {
-        current: HTMLElement | null;
-    };
-}
-export declare class DOMManager {
-    private elements;
-    private refs;
-    constructor();
-    createDOMStructure(container: HTMLElement, config: SimpleTableConfig): DOMElements;
-    updateTheme(theme: string): void;
-    /** Reorders footer vs content when `footerPosition` changes after mount. */
-    syncFooterPosition(footerPosition: SimpleTableConfig["footerPosition"]): void;
-    getElements(): DOMElements | null;
-    getRefs(): DOMRefs;
-    destroy(container: HTMLElement): void;
-}

package/dist/src/core/initialization/TableInitializer.d.ts

@@ -1,34 +0,0 @@
-import { SimpleTableConfig } from "../../types/SimpleTableConfig";
-import { CustomTheme } from "../../types/CustomTheme";
-import { ColumnEditorRowRenderer } from "../../types/ColumnEditorRowRendererProps";
-import { ColumnEditorCustomRenderer } from "../../types/ColumnEditorCustomRendererProps";
-import HeaderObject, { Accessor } from "../../types/HeaderObject";
-export interface ResolvedIcons {
-    drag: string | HTMLElement | SVGSVGElement;
-    expand: string | HTMLElement | SVGSVGElement;
-    filter: string | HTMLElement | SVGSVGElement;
-    headerCollapse: string | HTMLElement | SVGSVGElement;
-    headerExpand: string | HTMLElement | SVGSVGElement;
-    next: string | HTMLElement | SVGSVGElement;
-    prev: string | HTMLElement | SVGSVGElement;
-    sortDown: string | HTMLElement | SVGSVGElement;
-    sortUp: string | HTMLElement | SVGSVGElement;
-}
-export interface MergedColumnEditorConfig {
-    text: string;
-    showToggle: boolean;
-    searchEnabled: boolean;
-    searchPlaceholder: string;
-    allowColumnPinning: boolean;
-    searchFunction?: (header: HeaderObject, searchText: string) => boolean;
-    rowRenderer?: ColumnEditorRowRenderer;
-    customRenderer?: ColumnEditorCustomRenderer;
-}
-export declare class TableInitializer {
-    static resolveIcons(config: SimpleTableConfig): ResolvedIcons;
-    static mergeCustomTheme(config: SimpleTableConfig): CustomTheme;
-    static mergeColumnEditorConfig(config: SimpleTableConfig): MergedColumnEditorConfig;
-    static buildEssentialAccessors(headers: HeaderObject[]): Set<string>;
-    static getInitialCollapsedHeaders(headers: HeaderObject[]): Set<Accessor>;
-    static getInitialExpandedDepths(config: SimpleTableConfig): Set<number>;
-}

package/dist/src/core/rendering/RenderOrchestrator.d.ts

@@ -1,172 +0,0 @@
-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;
-}