simple-table-core 4.1.6 → 4.1.7

package/dist/core/SimpleTableVanilla.d.ts

@@ -16,38 +16,13 @@ export declare class SimpleTableVanilla<TData extends RowData = Row> {
     private localRows;
     private headers;
     /**
-     * Pristine deep-cloned snapshot of the column definitions as configured
-     * (constructor / update with `columns`). `this.headers` shares object
-     * references with `config.columns` at mount, and the column editor
-     * mutates header objects in place (e.g. `header.hide = true`) — so
-     * `config.columns` 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.
+     * Last ingested column definitions. `resetColumns()` restores from this
+     * snapshot. Runtime hide, width, and pin live on `this.headers`.
      */
     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;
@@ -71,6 +46,11 @@ export declare class SimpleTableVanilla<TData extends RowData = Row> {
     private headerRegistry;
     private rowIndexMap;
     private animationCoordinator;
+    private accordionController;
+    private autoSizeManager;
+    private externalScrollController;
+    private scrollCoalescer;
+    private unvirtualizedRowsWarning;
     /**
      * When true, the sort subscriber skips `captureAnimationSnapshot` so
      * live-update-driven reorder/visibility changes don't FLIP-animate.
@@ -94,281 +74,45 @@ export declare class SimpleTableVanilla<TData extends RowData = Row> {
     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;
+    private liveHost;
     constructor(container: HTMLElement, config: SimpleTableConfigInput<TData>);
+    /** Copy caller columns into `config.columns` and `pristineDefaultHeaders`. */
+    private ingestColumnSnapshot;
     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.
+     * Shared header write path for the render context and TableAPI. Accordion-
+     * horizontal when the visible or pinned set changed; column-drag uses the
+     * dedicated reorder animator; otherwise snapshot for FLIP.
      */
-    /**
-     * 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 applyHeaders;
     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 handleExternalScrollMetrics;
     private handleScroll;
+    private getTableRoot;
+    private bindTableRoot;
     private clearHoveredRows;
     private updateAriaLiveRegion;
-    /**
-     * Pivot emits a flat matrix — disable consumer rowGrouping while active so
-     * expand/collapse hierarchy does not wrap pivoted rows.
-     */
     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 applyPivot;
     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<SimpleTableConfigInput<TData>>): void;
     /** @deprecated Use {@link update} — same behavior. */
     updateConfig(config: Partial<SimpleTableConfigInput<TData>>): void;
-    /**
-     * Create, update, or destroy the RowSelectionManager when enableRowSelection
-     * (and related props) change at runtime.
-     */
     private syncRowSelectionManager;
     destroy(): void;
     getAPI(): TableAPI<TData>;
+    private getLiveHost;
 }

package/dist/core/api/TableAPIContext.d.ts

@@ -0,0 +1,74 @@
+import { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import ColumnDef, { Accessor } from "../../types/ColumnDef";
+import Row from "../../types/Row";
+import { CustomTheme } from "../../types/CustomTheme";
+import RowState from "../../types/RowState";
+import { SelectionManager } from "../../managers/SelectionManager";
+import { RowSelectionManager } from "../../managers/RowSelectionManager";
+import { SortManager } from "../../managers/SortManager";
+import { FilterManager } from "../../managers/FilterManager";
+import { FlattenRowsResult } from "../../utils/rowFlattening";
+import { ProcessRowsResult } from "../../utils/rowProcessing";
+import type { PivotConfig } from "../../types/PivotTypes";
+export interface TableAPIContext {
+    config: SimpleTableConfig;
+    localRows: Row[];
+    effectiveHeaders: ColumnDef[];
+    headers: ColumnDef[];
+    /** Last ingested column definitions (see SimpleTableVanilla.pristineDefaultHeaders). */
+    getPristineDefaultHeaders: () => ColumnDef[];
+    essentialAccessors: Set<string>;
+    customTheme: CustomTheme;
+    currentPage: number;
+    /** Returns current page from live state (use this in API getCurrentPage so it stays correct after setPage). */
+    getCurrentPage: () => number;
+    expandedRows: Map<string, number>;
+    collapsedRows: Map<string, number>;
+    expandedDepths: Set<number>;
+    clearExpandedRows: () => void;
+    clearCollapsedRows: () => void;
+    rowStateMap: Map<string | number, RowState>;
+    headerRegistry: Map<string, any>;
+    cellRegistry?: Map<string, {
+        updateContent: (value: any) => void;
+    }>;
+    /**
+     * Whether a cell (by its `getCellId` key) is currently mid-FLIP-animation.
+     * Live `updateData` content writes are skipped for animating cells so a
+     * data tick doesn't re-render / mutate a cell that is sliding to a new
+     * position (which causes visible jank). The underlying row data is still
+     * updated; only the in-place DOM refresh is deferred to the next tick or
+     * re-render once the animation settles.
+     */
+    isCellAnimating?: (cellId: string) => boolean;
+    /** True while any FLIP cell transition is in flight (blocks live re-sort/re-filter). */
+    hasAnimatingCells?: () => boolean;
+    columnEditorOpen: boolean;
+    expandedDepthsManager: any;
+    selectionManager: SelectionManager | null;
+    rowSelectionManager: RowSelectionManager | null;
+    sortManager: SortManager | null;
+    filterManager: FilterManager | null;
+    getCachedFlattenResult?: () => FlattenRowsResult | null;
+    getCachedProcessedResult?: () => ProcessRowsResult | null;
+    onRender: () => void;
+    /**
+     * Bust the flatten / body row caches so the next render re-runs quick filter
+     * (and related processing) against in-place mutated row values.
+     */
+    invalidateRowsCache?: () => void;
+    /**
+     * Run `fn` without capturing a FLIP snapshot when sort/filter subscribers
+     * fire. Used for live-update-driven reorder/visibility changes so high-
+     * frequency ticks don't spam sort animations.
+     */
+    runWithoutAnimationSnapshot?: (fn: () => void) => void;
+    setHeaders: (headers: ColumnDef[]) => void;
+    setCurrentPage: (page: number) => void;
+    setColumnEditorOpen: (open: boolean) => void;
+    getEffectiveRowGrouping: () => Accessor[] | undefined;
+    setPivot: (config: PivotConfig | null) => void;
+    getPivot: () => PivotConfig | null;
+    getPivotHeaders: () => ColumnDef[];
+    getPivotedRows: () => Row[];
+}

package/dist/core/api/TableAPIImpl.d.ts

@@ -1,78 +1,6 @@
 import { TableAPI } from "../../types/TableAPI";
-import { SimpleTableConfig } from "../../types/SimpleTableConfig";
-import ColumnDef, { Accessor } from "../../types/ColumnDef";
-import Row from "../../types/Row";
-import { CustomTheme } from "../../types/CustomTheme";
-import RowState from "../../types/RowState";
-import { SelectionManager } from "../../managers/SelectionManager";
-import { RowSelectionManager } from "../../managers/RowSelectionManager";
-import { SortManager } from "../../managers/SortManager";
-import { FilterManager } from "../../managers/FilterManager";
-import { FlattenRowsResult } from "../../utils/rowFlattening";
-import { ProcessRowsResult } from "../../utils/rowProcessing";
-import type { PivotConfig } from "../../types/PivotTypes";
-export interface TableAPIContext {
-    config: SimpleTableConfig;
-    localRows: Row[];
-    effectiveHeaders: ColumnDef[];
-    headers: ColumnDef[];
-    /** Pristine snapshot of the configured column definitions (see SimpleTableVanilla.pristineDefaultHeaders). */
-    getPristineDefaultHeaders: () => ColumnDef[];
-    essentialAccessors: Set<string>;
-    customTheme: CustomTheme;
-    currentPage: number;
-    /** Returns current page from live state (use this in API getCurrentPage so it stays correct after setPage). */
-    getCurrentPage: () => number;
-    expandedRows: Map<string, number>;
-    collapsedRows: Map<string, number>;
-    expandedDepths: Set<number>;
-    clearExpandedRows: () => void;
-    clearCollapsedRows: () => void;
-    rowStateMap: Map<string | number, RowState>;
-    headerRegistry: Map<string, any>;
-    cellRegistry?: Map<string, {
-        updateContent: (value: any) => void;
-    }>;
-    /**
-     * Whether a cell (by its `getCellId` key) is currently mid-FLIP-animation.
-     * Live `updateData` content writes are skipped for animating cells so a
-     * data tick doesn't re-render / mutate a cell that is sliding to a new
-     * position (which causes visible jank). The underlying row data is still
-     * updated; only the in-place DOM refresh is deferred to the next tick or
-     * re-render once the animation settles.
-     */
-    isCellAnimating?: (cellId: string) => boolean;
-    /** True while any FLIP cell transition is in flight (blocks live re-sort/re-filter). */
-    hasAnimatingCells?: () => boolean;
-    columnEditorOpen: boolean;
-    expandedDepthsManager: any;
-    selectionManager: SelectionManager | null;
-    rowSelectionManager: RowSelectionManager | null;
-    sortManager: SortManager | null;
-    filterManager: FilterManager | null;
-    getCachedFlattenResult?: () => FlattenRowsResult | null;
-    getCachedProcessedResult?: () => ProcessRowsResult | null;
-    onRender: () => void;
-    /**
-     * Bust the flatten / body row caches so the next render re-runs quick filter
-     * (and related processing) against in-place mutated row values.
-     */
-    invalidateRowsCache?: () => void;
-    /**
-     * Run `fn` without capturing a FLIP snapshot when sort/filter subscribers
-     * fire. Used for live-update-driven reorder/visibility changes so high-
-     * frequency ticks don't spam sort animations.
-     */
-    runWithoutAnimationSnapshot?: (fn: () => void) => void;
-    setHeaders: (headers: ColumnDef[]) => void;
-    setCurrentPage: (page: number) => void;
-    setColumnEditorOpen: (open: boolean) => void;
-    getEffectiveRowGrouping: () => Accessor[] | undefined;
-    setPivot: (config: PivotConfig | null) => void;
-    getPivot: () => PivotConfig | null;
-    getPivotHeaders: () => ColumnDef[];
-    getPivotedRows: () => Row[];
-}
+import type { TableAPIContext } from "./TableAPIContext";
+export type { TableAPIContext } from "./TableAPIContext";
 export declare class TableAPIImpl {
     static createAPI(context: TableAPIContext): TableAPI;
 }

package/dist/core/api/buildTableAPIContext.d.ts

@@ -0,0 +1,61 @@
+import type { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import type ColumnDef from "../../types/ColumnDef";
+import type { Accessor } from "../../types/ColumnDef";
+import type Row from "../../types/Row";
+import type { CustomTheme } from "../../types/CustomTheme";
+import type RowState from "../../types/RowState";
+import type { SelectionManager } from "../../managers/SelectionManager";
+import type { RowSelectionManager } from "../../managers/RowSelectionManager";
+import type { SortManager } from "../../managers/SortManager";
+import type { FilterManager } from "../../managers/FilterManager";
+import type { FlattenRowsResult } from "../../utils/rowFlattening";
+import type { ProcessRowsResult } from "../../utils/rowProcessing";
+import type { PivotConfig } from "../../types/PivotTypes";
+import type { TableAPIContext } from "./TableAPIContext";
+/**
+ * Live table instance surface used to build a cached {@link TableAPIContext}.
+ * Getters read current instance state rather than a snapshot captured at
+ * `getAPI()` time.
+ */
+export interface TableAPIContextHost {
+    getConfig(): SimpleTableConfig;
+    getLocalRows(): Row[];
+    getHeaders(): ColumnDef[];
+    applyHeaders(headers: ColumnDef[]): void;
+    getPristineDefaultHeaders(): ColumnDef[];
+    getEssentialAccessors(): Set<string>;
+    getCustomTheme(): CustomTheme;
+    getCurrentPage(): number;
+    setCurrentPage(page: number): void;
+    getExpandedRows(): Map<string, number>;
+    getCollapsedRows(): Map<string, number>;
+    getExpandedDepths(): Set<number>;
+    clearExpandedRows(): void;
+    clearCollapsedRows(): void;
+    getRowStateMap(): Map<string | number, RowState>;
+    getHeaderRegistry(): Map<string, any>;
+    getCellRegistry(): Map<string, {
+        updateContent: (value: any) => void;
+    }>;
+    isCellAnimating(cellId: string): boolean;
+    hasAnimatingCells(): boolean;
+    getColumnEditorOpen(): boolean;
+    setColumnEditorOpen(open: boolean): void;
+    getExpandedDepthsManager(): any;
+    getSelectionManager(): SelectionManager | null;
+    getRowSelectionManager(): RowSelectionManager | null;
+    getSortManager(): SortManager | null;
+    getFilterManager(): FilterManager | null;
+    getCachedFlattenResult(): FlattenRowsResult | null;
+    getCachedProcessedResult(): ProcessRowsResult | null;
+    getEffectiveRowGrouping(): Accessor[] | undefined;
+    setPivot(config: PivotConfig | null): void;
+    getPivot(): PivotConfig | null;
+    getPivotHeaders(): ColumnDef[];
+    getPivotedRows(): Row[];
+    onRender(): void;
+    invalidateRowsCache(): void;
+    runWithoutAnimationSnapshot(fn: () => void): void;
+    computeEffectiveHeaders(): ColumnDef[];
+}
+export declare const buildTableAPIContext: (host: TableAPIContextHost) => TableAPIContext;

package/dist/core/dev/UnvirtualizedRowsWarning.d.ts

@@ -0,0 +1,20 @@
+export interface UnvirtualizedRowsWarningHost {
+    isMounted(): boolean;
+    isVirtualizationDisabled(): boolean;
+    getContentHeight(): number | undefined;
+    getRenderedRowCount(): number;
+    hasScrollParent(): boolean;
+}
+/**
+ * Warns once in development when a large row set is painted with no viewport
+ * (`height`, `maxHeight`, or a bounded `scrollParent`).
+ */
+export declare class UnvirtualizedRowsWarning {
+    private hasWarned;
+    private timeoutId;
+    private host;
+    constructor(host: UnvirtualizedRowsWarningHost);
+    schedule(): void;
+    destroy(): void;
+    private evaluate;
+}

package/dist/core/initialization/createDataManagers.d.ts

@@ -0,0 +1,37 @@
+import type { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import type { CustomTheme } from "../../types/CustomTheme";
+import type ColumnDef from "../../types/ColumnDef";
+import type { Accessor } from "../../types/ColumnDef";
+import type Row from "../../types/Row";
+import type { PivotManager } from "../../managers/PivotManager";
+import { SortManager } from "../../managers/SortManager";
+import { FilterManager } from "../../managers/FilterManager";
+import { SelectionManager } from "../../managers/SelectionManager";
+import ExpandedDepthsManager from "../../hooks/expandedDepths";
+import AriaAnnouncementManager from "../../hooks/ariaAnnouncements";
+export interface DataManagersHost {
+    getConfig(): SimpleTableConfig;
+    getHeaders(): ColumnDef[];
+    getPristineDefaultHeaders(): ColumnDef[];
+    getLocalRows(): Row[];
+    getCustomTheme(): CustomTheme;
+    getCollapsedHeaders(): Set<Accessor>;
+    getCellRegistry(): Map<string, any>;
+    getTableRoot(): HTMLElement;
+    getEffectiveRowGrouping(): Accessor[] | undefined;
+    getPivotManager(): PivotManager | null;
+    onAnnouncement(message: string): void;
+    onExpandedDepths(depths: Set<number>): void;
+    onSortNotify(): void;
+    onFilterNotify(filteredRows: Row[]): void;
+    onSelectionDragEnd(): void;
+}
+export interface DataManagers {
+    ariaAnnouncementManager: AriaAnnouncementManager;
+    expandedDepthsManager: ExpandedDepthsManager;
+    sortManager: SortManager;
+    filterManager: FilterManager;
+    selectionManager: SelectionManager;
+}
+/** Constructs sort, filter, selection, expand-depth, and aria managers. */
+export declare const createDataManagers: (host: DataManagersHost) => DataManagers;

package/dist/core/initialization/wireMountManagers.d.ts

@@ -0,0 +1,43 @@
+import type { SimpleTableConfig } from "../../types/SimpleTableConfig";
+import type { CustomTheme } from "../../types/CustomTheme";
+import type ColumnDef from "../../types/ColumnDef";
+import type { Accessor } from "../../types/ColumnDef";
+import type { DOMRefs } from "../dom/DOMManager";
+import { DimensionManager } from "../../managers/DimensionManager";
+import { ScrollManager } from "../../managers/ScrollManager";
+import { SectionScrollController } from "../../managers/SectionScrollController";
+import { AutoScaleManager } from "../../managers/AutoScaleManager";
+import { SelectionManager } from "../../managers/SelectionManager";
+import WindowResizeManager from "../../hooks/windowResize";
+import HandleOutsideClickManager from "../../hooks/handleOutsideClick";
+import ScrollbarVisibilityManager from "../../hooks/scrollbarVisibility";
+import type { RenderOrchestrator } from "../rendering/RenderOrchestrator";
+export interface MountManagersHost {
+    getConfig(): SimpleTableConfig;
+    getCustomTheme(): CustomTheme;
+    getHeaders(): ColumnDef[];
+    getCollapsedHeaders(): Set<Accessor>;
+    getLocalRowCount(): number;
+    getIsResizing(): boolean;
+    getSelectionManager(): SelectionManager | null;
+    getRenderOrchestrator(): RenderOrchestrator;
+    onRender(source: string): void;
+    onFirstDimensionPaint(): void;
+    onScrollbarVisibilityChange(isScrollable: boolean, scrollbarWidth: number): void;
+    onScrollbarWidthChange(scrollbarWidth: number): void;
+}
+export interface MountManagers {
+    dimensionManager: DimensionManager;
+    scrollManager: ScrollManager;
+    sectionScrollController: SectionScrollController;
+    autoScaleManager: AutoScaleManager | null;
+    scrollbarVisibilityManager: ScrollbarVisibilityManager | null;
+    windowResizeManager: WindowResizeManager;
+    handleOutsideClickManager: HandleOutsideClickManager | null;
+    scrollbarWidth: number;
+}
+/**
+ * Constructs managers that need the mounted DOM (dimensions, scroll sync,
+ * auto-expand, scrollbar, outside-click).
+ */
+export declare const wireMountManagers: (host: MountManagersHost, refs: DOMRefs) => MountManagers | null;