simple-table-core 3.9.3 → 3.9.7

package/dist/src/consts/general-consts.d.ts

@@ -8,6 +8,15 @@ export declare const UNVIRTUALIZED_ROW_WARNING_THRESHOLD = 500;
 export declare const OVERSCAN_PIXELS = 800;
 export declare const calculateBufferRowCount: (rowHeight: number) => number;
 export declare const COLUMN_EDIT_WIDTH = 29.5;
+/**
+ * Horizontal space reserved for the built-in column-editor toggle strip.
+ * Returns 0 when editing is off or the strip is hidden via `showToggle: false`.
+ */
+export declare const getColumnEditorStripWidth: (editColumns: boolean | undefined, showToggle?: boolean) => number;
+/**
+ * Whether the built-in column-editor toggle strip is visible and takes layout space.
+ */
+export declare const isColumnEditorStripVisible: (editColumns: boolean | undefined, showToggle?: boolean) => boolean;
 export declare const TABLE_HEADER_CELL_WIDTH_DEFAULT = 150;
 export declare const PINNED_BORDER_WIDTH = 1;
 export declare const CHART_COLUMN_TYPES: string[];

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

@@ -60,6 +60,12 @@ export declare class SimpleTableVanilla {
     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;
@@ -337,6 +343,11 @@ export declare class SimpleTableVanilla {
     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/api/TableAPIImpl.d.ts

@@ -5,6 +5,7 @@ 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";
@@ -43,6 +44,7 @@ export interface TableAPIContext {
     columnEditorOpen: boolean;
     expandedDepthsManager: any;
     selectionManager: SelectionManager | null;
+    rowSelectionManager: RowSelectionManager | null;
     sortManager: SortManager | null;
     filterManager: FilterManager | null;
     getCachedFlattenResult?: () => FlattenRowsResult | null;

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

@@ -16,6 +16,7 @@ export interface ResolvedIcons {
 }
 export interface MergedColumnEditorConfig {
     text: string;
+    showToggle: boolean;
     searchEnabled: boolean;
     searchPlaceholder: string;
     allowColumnPinning: boolean;

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

@@ -49,6 +49,11 @@ export interface RenderContext {
     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;
     };

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

@@ -46,6 +46,8 @@ export interface TableRendererDeps {
     getRowStateMap: () => Map<string | number, any>;
     headerRegistry: Map<string, any>;
     headers: HeaderObject[];
+    /** Unique id for this table instance — scopes row-hover cell tracking. */
+    hoverScopeId: string;
     hoveredHeaderRef: {
         current: HeaderObject | null;
     };

package/dist/src/hooks/expandedDepths.d.ts

@@ -10,6 +10,8 @@ export declare const initializeExpandedDepths: (expandAll: boolean, rowGrouping?
 export declare class ExpandedDepthsManager {
     private expandedDepths;
     private observers;
+    /** Coalesce sync collapseAll→expandDepth into a single observer notification. */
+    private notifyMicrotaskScheduled;
     constructor(expandAll: boolean, rowGrouping?: Accessor[]);
     /**
      * Updates the expanded depths when rowGrouping changes
@@ -34,7 +36,9 @@ export declare class ExpandedDepthsManager {
      */
     subscribe(callback: (depths: Set<number>) => void): () => void;
     /**
-     * Notifies all observers of depth changes
+     * Notifies all observers of depth changes.
+     * Batched to a microtask so collapseAll() + expandDepth(0) in one turn
+     * (marketing "Only Divisions") triggers a single render with the final depths.
      */
     private notifyObservers;
     /**

package/dist/src/index.d.ts

@@ -23,6 +23,7 @@ import type { FilterCondition, TableFilterState, FilterOperator, StringFilterOpe
 import type { QuickFilterConfig, QuickFilterGetter, QuickFilterGetterProps, QuickFilterMode } from "./types/QuickFilterTypes";
 import type { ColumnVisibilityState } from "./types/ColumnVisibilityTypes";
 import type RowSelectionChangeProps from "./types/RowSelectionChangeProps";
+import type { RowSelectionMode } from "./types/RowSelectionMode";
 import type CellClickProps from "./types/CellClickProps";
 import type CellRendererProps from "./types/CellRendererProps";
 import type { CellRenderer } from "./types/CellRendererProps";
@@ -48,4 +49,4 @@ import type { RowId } from "./types/RowId";
 import type { PinnedSectionsState } from "./types/PinnedSectionsState";
 export { SimpleTableVanilla };
 export { asRows } from "./utils/asRows";
-export type { Accessor, AggregationConfig, AggregationType, AnimationsConfig, BoundingBox, Cell, CellChangeProps, CellClickProps, CellRenderer, CellRendererProps, CellValue, ChartOptions, ColumnEditorConfig, ColumnEditorCustomRenderer, ColumnEditorCustomRendererProps, ColumnEditorRowRenderer, ColumnEditorRowRendererComponents, ColumnEditorRowRendererProps, ColumnEditorSearchFunction, ColumnType, ColumnVisibilityState, Comparator, ComparatorProps, CustomTheme, CustomThemeProps, DragHandlerProps, EmptyStateRenderer, EmptyStateRendererProps, EnumOption, ErrorStateRenderer, ErrorStateRendererProps, ExportToCSVProps, ExportValueGetter, ExportValueProps, FilterCondition, FilterOperator, StringFilterOperator, NumberFilterOperator, BooleanFilterOperator, DateFilterOperator, EnumFilterOperator, FooterRendererProps, FooterPosition, GetRowId, GetRowIdParams, IconsConfig, LoadingStateRenderer, LoadingStateRendererProps, HeaderDropdown, HeaderDropdownProps, HeaderObject, HeaderRenderer, HeaderRendererProps, HeaderRendererComponents, OnRowGroupExpandProps, OnSortProps, QuickFilterConfig, QuickFilterGetter, QuickFilterGetterProps, QuickFilterMode, Row, RowButtonProps, RowId, RowSelectionChangeProps, RowState, SetHeaderRenameProps, SharedTableProps, ShowWhen, SimpleTableConfig, SimpleTableProps, SortColumn, TableAPI, TableFilterState, TableHeaderProps, TableRowProps, Theme, PinnedSectionsState, UpdateDataProps, ValueFormatter, ValueFormatterProps, ValueGetter, ValueGetterProps, };
+export type { Accessor, AggregationConfig, AggregationType, AnimationsConfig, BoundingBox, Cell, CellChangeProps, CellClickProps, CellRenderer, CellRendererProps, CellValue, ChartOptions, ColumnEditorConfig, ColumnEditorCustomRenderer, ColumnEditorCustomRendererProps, ColumnEditorRowRenderer, ColumnEditorRowRendererComponents, ColumnEditorRowRendererProps, ColumnEditorSearchFunction, ColumnType, ColumnVisibilityState, Comparator, ComparatorProps, CustomTheme, CustomThemeProps, DragHandlerProps, EmptyStateRenderer, EmptyStateRendererProps, EnumOption, ErrorStateRenderer, ErrorStateRendererProps, ExportToCSVProps, ExportValueGetter, ExportValueProps, FilterCondition, FilterOperator, StringFilterOperator, NumberFilterOperator, BooleanFilterOperator, DateFilterOperator, EnumFilterOperator, FooterRendererProps, FooterPosition, GetRowId, GetRowIdParams, IconsConfig, LoadingStateRenderer, LoadingStateRendererProps, HeaderDropdown, HeaderDropdownProps, HeaderObject, HeaderRenderer, HeaderRendererProps, HeaderRendererComponents, OnRowGroupExpandProps, OnSortProps, QuickFilterConfig, QuickFilterGetter, QuickFilterGetterProps, QuickFilterMode, Row, RowButtonProps, RowId, RowSelectionChangeProps, RowSelectionMode, RowState, SetHeaderRenameProps, SharedTableProps, ShowWhen, SimpleTableConfig, SimpleTableProps, SortColumn, TableAPI, TableFilterState, TableHeaderProps, TableRowProps, Theme, PinnedSectionsState, UpdateDataProps, ValueFormatter, ValueFormatterProps, ValueGetter, ValueGetterProps, };

package/dist/src/managers/DimensionManager.d.ts

@@ -26,8 +26,17 @@ type StateChangeCallback = (state: DimensionManagerState) => void;
  * notifying subscribers. Coalesces CSS-transition / animated layout shifts
  * (e.g. a collapsible nav) into a single trailing update instead of one full
  * table render per animation frame.
+ *
+ * Kept above typical frame-budget jank (~50–80ms) so a hitch mid-transition
+ * does not look like "animation ended" and fire an extra full relayout.
  */
-export declare const CONTAINER_RESIZE_NOTIFY_DEBOUNCE_MS = 50;
+export declare const CONTAINER_RESIZE_NOTIFY_DEBOUNCE_MS = 100;
+/**
+ * After a trailing notify, keep the burst open this long. A jank-sized quiet
+ * gap mid-animation must not start a fresh burst (which would allow another
+ * pair of notifies and thrash subscribers).
+ */
+export declare const CONTAINER_RESIZE_BURST_END_MS = 150;
 export declare class DimensionManager {
     private config;
     private state;
@@ -35,6 +44,11 @@ export declare class DimensionManager {
     private resizeObserver;
     private rafId;
     private resizeNotifyDebounceId;
+    private resizeBurstEndId;
+    /** Notifies emitted in the current continuous resize burst (capped at 2). */
+    private resizeBurstNotifyCount;
+    /** True when a 3rd+ trailing tick was suppressed; flush latest width on burst end. */
+    private resizeBurstNeedsFinalFlush;
     /** Set when applyContainerWidthSync updates state before any subscriber exists. */
     private initialNotifyPending;
     constructor(config: DimensionManagerConfig);
@@ -44,7 +58,16 @@ export declare class DimensionManager {
     private convertHeightToPixels;
     private calculateContentHeight;
     private cancelPendingResizeNotify;
-    /** Trailing debounce for animated / continuous container resizes. */
+    private cancelResizeBurstEnd;
+    private scheduleResizeBurstEnd;
+    /**
+     * Trailing debounce for animated / continuous container resizes.
+     *
+     * Per burst (continuous RO ticks separated by less than {@link CONTAINER_RESIZE_BURST_END_MS}):
+     * - 1st quiet gap → notify immediately (sole update, or mid-animation pass)
+     * - later quiet gaps → defer to burst-end so subscribers always see the final
+     *   width without a 3rd+ notify when frame timing is janky
+     */
     private scheduleResizeNotify;
     private observeContainer;
     private applyContainerWidthSync;

package/dist/src/managers/RowSelectionManager.d.ts

@@ -1,36 +1,72 @@
 import TableRow from "../types/TableRow";
+import Row from "../types/Row";
 import RowSelectionChangeProps from "../types/RowSelectionChangeProps";
+import type { RowSelectionMode } from "../types/RowSelectionMode";
 export interface RowSelectionManagerConfig {
     tableRows: TableRow[];
     onRowSelectionChange?: (props: RowSelectionChangeProps) => void;
     enableRowSelection?: boolean;
+    rowSelectionMode?: RowSelectionMode;
+    selectRowOnClick?: boolean;
+    showRowSelectionColumn?: boolean;
+    /** When true, Arrow/Home/End/Ctrl+A are left to SelectionManager; Space still toggles rows. */
+    selectableCells?: boolean;
+    /** Table root element used to decide whether keyboard events apply. */
+    tableRoot?: HTMLElement | null;
 }
 export interface RowSelectionManagerState {
     selectedRows: Set<string>;
     selectedRowCount: number;
-    selectedRowsData: any[];
+    selectedRowsData: Row[];
+    /** Keyboard focus / navigation target row id */
+    activeRowId: string | null;
 }
 type StateChangeCallback = (state: RowSelectionManagerState) => void;
 export declare class RowSelectionManager {
     private config;
     private state;
     private subscribers;
+    /** Anchor for Shift+range selection */
+    private anchorRowId;
+    private keydownHandler;
     constructor(config: RowSelectionManagerConfig);
     updateConfig(config: Partial<RowSelectionManagerConfig>): void;
+    private getMode;
     private updateDerivedState;
     subscribe(callback: StateChangeCallback): () => void;
     private notifySubscribers;
+    private fireChange;
+    private applySelection;
     isRowSelected(rowId: string): boolean;
     areAllRowsSelected(): boolean;
     getSelectedRows(): Set<string>;
     getSelectedRowCount(): number;
-    getSelectedRowsData(): any[];
+    getSelectedRowsData(): Row[];
+    getRow(rowId: string): Row | undefined;
+    getActiveRowId(): string | null;
+    setActiveRowId(rowId: string | null): void;
     setSelectedRows(selectedRows: Set<string>): void;
+    /**
+     * Set a row's selected state (does not toggle). Respects single/multiple mode.
+     */
     handleRowSelect(rowId: string, isSelected: boolean): void;
+    selectRow(rowId: string): void;
+    deselectRow(rowId: string): void;
     handleSelectAll(isSelected: boolean): void;
     handleToggleRow(rowId: string): void;
+    /**
+     * Click-to-select: multiple toggles; single replaces.
+     */
+    handleRowClickSelect(rowId: string): void;
     clearSelection(): void;
     getState(): RowSelectionManagerState;
+    private setupKeyboardNavigation;
+    private isEventInsideTable;
+    private isTypingInFormField;
+    private findRowIndex;
+    private resolveActiveRowId;
+    private moveActiveRow;
+    private handleKeyDown;
     destroy(): void;
 }
 export {};

package/dist/src/types/ColumnEditorConfig.d.ts

@@ -14,6 +14,13 @@ export type ColumnEditorSearchFunction = (header: HeaderObject, searchTerm: stri
 export interface ColumnEditorConfig {
     /** Text displayed on the column editor button (default: "Columns") */
     text?: string;
+    /**
+     * When false, hides the built-in vertical "Columns" toggle strip while keeping
+     * the column editor popout and `toggleColumnEditor()` API available.
+     * Use this when opening the editor from an external toolbar button.
+     * Default: true.
+     */
+    showToggle?: boolean;
     /** Enable search functionality in the column editor (default: true) */
     searchEnabled?: boolean;
     /** Placeholder text for the search input (default: "Search columns...") */
@@ -32,4 +39,4 @@ export interface ColumnEditorConfig {
 }
 export declare const DEFAULT_COLUMN_EDITOR_CONFIG: Required<Omit<ColumnEditorConfig, "searchFunction" | "rowRenderer" | "customRenderer">>;
 /** Column editor config with defaults applied (text, searchEnabled, searchPlaceholder are required) */
-export type MergedColumnEditorConfig = Required<Pick<ColumnEditorConfig, "text" | "searchEnabled" | "searchPlaceholder" | "allowColumnPinning">> & Pick<ColumnEditorConfig, "searchFunction" | "rowRenderer" | "customRenderer">;
+export type MergedColumnEditorConfig = Required<Pick<ColumnEditorConfig, "text" | "showToggle" | "searchEnabled" | "searchPlaceholder" | "allowColumnPinning">> & Pick<ColumnEditorConfig, "searchFunction" | "rowRenderer" | "customRenderer">;

package/dist/src/types/RowSelectionMode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Row selection mode.
+ * - `multiple` (default): select any number of rows; select-all is available when the checkbox column is shown
+ * - `single`: selecting a row replaces the previous selection; select-all is hidden
+ */
+type RowSelectionMode = "single" | "multiple";
+export type { RowSelectionMode };
+export default RowSelectionMode;

package/dist/src/types/SimpleTableConfig.d.ts

@@ -11,6 +11,7 @@ import { TableFilterState } from "./FilterTypes";
 import OnNextPage from "./OnNextPage";
 import OnRowGroupExpandProps from "./OnRowGroupExpandProps";
 import RowSelectionChangeProps from "./RowSelectionChangeProps";
+import type { RowSelectionMode } from "./RowSelectionMode";
 import { RowButton } from "./RowButton";
 import Theme from "./Theme";
 import { CustomThemeProps } from "./CustomTheme";
@@ -45,6 +46,12 @@ export interface SimpleTableConfig {
     emptyStateRenderer?: VanillaEmptyStateRenderer;
     enableHeaderEditing?: boolean;
     enableRowSelection?: boolean;
+    /** @see SimpleTableProps.rowSelectionMode */
+    rowSelectionMode?: RowSelectionMode;
+    /** @see SimpleTableProps.selectRowOnClick */
+    selectRowOnClick?: boolean;
+    /** @see SimpleTableProps.showRowSelectionColumn */
+    showRowSelectionColumn?: boolean;
     enableStickyParents?: boolean;
     errorStateRenderer?: VanillaErrorStateRenderer;
     expandAll?: boolean;

package/dist/src/types/SimpleTableProps.d.ts

@@ -11,6 +11,7 @@ import { TableFilterState } from "./FilterTypes";
 import OnNextPage from "./OnNextPage";
 import OnRowGroupExpandProps from "./OnRowGroupExpandProps";
 import RowSelectionChangeProps from "./RowSelectionChangeProps";
+import type { RowSelectionMode } from "./RowSelectionMode";
 import { RowButton } from "./RowButton";
 import Theme from "./Theme";
 import { CustomThemeProps } from "./CustomTheme";
@@ -38,6 +39,23 @@ export interface SimpleTableProps {
     emptyStateRenderer?: EmptyStateRenderer;
     enableHeaderEditing?: boolean;
     enableRowSelection?: boolean;
+    /**
+     * Row selection mode when `enableRowSelection` is true.
+     * - `"multiple"` (default): select any number of rows
+     * - `"single"`: selecting a row replaces the previous selection
+     */
+    rowSelectionMode?: RowSelectionMode;
+    /**
+     * When true, clicking a data cell selects the row (toggles in multiple mode,
+     * replaces selection in single mode). Default false.
+     */
+    selectRowOnClick?: boolean;
+    /**
+     * When false, the checkbox selection column is not shown; selection still works
+     * via click, keyboard, or TableAPI. Default true. The column is still shown when
+     * `rowButtons` is set (buttons need a home).
+     */
+    showRowSelectionColumn?: boolean;
     enableStickyParents?: boolean;
     errorStateRenderer?: ErrorStateRenderer;
     expandAll?: boolean;

package/dist/src/types/TableAPI.d.ts

@@ -1,6 +1,7 @@
 import UpdateDataProps from "./UpdateCellProps";
 import HeaderObject, { Accessor } from "./HeaderObject";
 import TableRow from "./TableRow";
+import Row from "./Row";
 import SortColumn, { SortDirection } from "./SortColumn";
 import { TableFilterState, FilterCondition } from "./FilterTypes";
 import Cell from "./Cell";
@@ -59,4 +60,15 @@ export type TableAPI = {
     clearSelection: () => void;
     selectCell: (cell: Cell) => void;
     selectCellRange: (startCell: Cell, endCell: Cell) => void;
+    /** Selected row IDs when row selection is enabled. */
+    getSelectedRows: () => Set<string>;
+    /** Row data objects for currently selected rows (resolved from visible/current table rows). */
+    getSelectedRowsData: () => Row[];
+    /** Look up a row by its string row id in the current table rows. */
+    getRow: (rowId: string) => Row | undefined;
+    selectRow: (rowId: string) => void;
+    deselectRow: (rowId: string) => void;
+    toggleRowSelection: (rowId: string) => void;
+    /** Clears row selection only (does not clear cell selection). */
+    clearRowSelection: () => void;
 };

package/dist/src/utils/bodyCell/types.d.ts

@@ -64,11 +64,21 @@ export interface CellRenderContext {
     rowsWithSelectedCells: Set<string>;
     columnBorders: boolean;
     enableRowSelection?: boolean;
+    /** When true, clicking a data cell selects/toggles the row. */
+    selectRowOnClick?: boolean;
+    rowSelectionMode?: "single" | "multiple";
     /** Used for context cache invalidation when row selection changes */
     selectedRowCount?: number;
+    /** Keyboard active row id for focus styling */
+    activeRowId?: string | null;
     cellUpdateFlash?: boolean;
     useOddColumnBackground?: boolean;
     useHoverRowBackground?: boolean;
+    /**
+     * 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.
+     */
+    hoverScopeId: string;
     useOddEvenRowBackground?: boolean;
     rowGrouping?: string[];
     headers: HeaderObject[];
@@ -102,6 +112,8 @@ export interface CellRenderContext {
     onCellClick?: (params: CellClickParams) => void;
     onRowGroupExpand?: (props: OnRowGroupExpandProps) => void | Promise<void>;
     handleRowSelect?: (rowId: string, checked: boolean) => void;
+    /** Click-to-select / keyboard toggle entry point (mode-aware). */
+    handleToggleRow?: (rowId: string) => void;
     handleMouseDown: (cell: CellData) => void;
     handleMouseOver: (cell: CellData, clientX: number, clientY: number) => void;
     /**

package/dist/src/utils/headerCell/types.d.ts

@@ -35,6 +35,8 @@ export interface HeaderRenderContext {
     draggedHeaderRef: MutableRefObject<HeaderObject | null>;
     enableHeaderEditing?: boolean;
     enableRowSelection?: boolean;
+    /** When `"single"`, header select-all checkbox is hidden. */
+    rowSelectionMode?: "single" | "multiple";
     filters: TableFilterState;
     forceUpdate: () => void;
     getCollapsedHeaders?: () => Set<Accessor>; /** Get current collapsed headers (avoids stale closure in toggle handler). */

package/dist/src/utils/headerWidthUtils.d.ts

@@ -68,7 +68,14 @@ export declare const getAllVisibleLeafHeaders: (headers: HeaderObject[], collaps
  *
  * @param accessor - The accessor of the header to measure
  * @param options - Configuration options
- * @returns The optimal width in pixels
+ * @returns Measured width plus whether the result is final (`settled`). When a
+ *   custom `cellRenderer` / `headerRenderer` exists but its real DOM is not
+ *   measurable yet (async portal / loading skeleton), `settled` is false and
+ *   the width is provisional (header / minWidth only — never `valueFormatter`
+ *   or plain `label` as a stand-in for renderer output). Callers should apply
+ *   that provisional width once and re-measure later via an explicit refit
+ *   (rows / isLoading / `refitAutoSizeColumns`) — not by leaving the column
+ *   pending across every render.
  */
 export declare const calculateHeaderContentWidth: (accessor: Accessor, options?: {
     rows?: any[] | undefined;
@@ -108,4 +115,7 @@ export declare const calculateHeaderContentWidth: (accessor: Accessor, options?:
      * without this, autofit sampling leaks those registrations.
      */
     onRendererHostDiscard?: ((host: HTMLElement) => void) | undefined;
-} | undefined) => number;
+} | undefined) => {
+    width: number;
+    settled: boolean;
+};

package/dist/src/utils/horizontalScrollbarRenderer.d.ts

@@ -7,6 +7,7 @@ export interface HorizontalScrollbarProps {
     pinnedLeftContentWidth: number;
     pinnedRightContentWidth: number;
     tableBodyContainerRef: HTMLDivElement;
+    /** True when the column-editor toggle strip is visible and reserves horizontal space. */
     editColumns: boolean;
     sectionScrollController?: SectionScrollController | null;
     /**

package/dist/src/utils/rowSelectionUtils.d.ts

@@ -1,6 +1,16 @@
 import Row from "../types/Row";
 import TableRow from "../types/TableRow";
 import HeaderObject from "../types/HeaderObject";
+import type { RowSelectionMode } from "../types/RowSelectionMode";
+/**
+ * Whether the checkbox / row-buttons column should be injected into headers.
+ * Always shown when `rowButtons` is set (buttons need a home).
+ */
+export declare const shouldShowRowSelectionColumn: (config: {
+    enableRowSelection?: boolean;
+    showRowSelectionColumn?: boolean;
+    rowButtons?: unknown[];
+}) => boolean;
 /**
  * Get the set of selected row IDs from an array of table rows
  */
@@ -14,9 +24,18 @@ export declare const isRowSelected: (rowId: string, selectedRows: Set<string>) =
  */
 export declare const areAllRowsSelected: (tableRows: TableRow[], selectedRows: Set<string>) => boolean;
 /**
- * Toggle selection of a single row
+ * Toggle selection of a single row (multiple mode).
  */
 export declare const toggleRowSelection: (rowId: string, selectedRows: Set<string>) => Set<string>;
+/**
+ * Set whether a row is selected, respecting selection mode.
+ */
+export declare const setRowSelected: (rowId: string, isSelected: boolean, selectedRows: Set<string>, mode?: RowSelectionMode) => Set<string>;
+/**
+ * Select a range of visible rows (inclusive) by index into `tableRows`.
+ * Used for Shift+arrow keyboard range selection in multiple mode.
+ */
+export declare const selectRowRange: (tableRows: TableRow[], startIndex: number, endIndex: number, baseSelection?: Set<string>) => Set<string>;
 /**
  * Select all rows
  */
@@ -29,6 +48,10 @@ export declare const deselectAllRows: () => Set<string>;
  * Get the selected rows from the table rows array
  */
 export declare const getSelectedRows: (tableRows: TableRow[], selectedRows: Set<string>) => Row[];
+/**
+ * Find a row by its string row id in the current table rows.
+ */
+export declare const findRowById: (tableRows: TableRow[], rowId: string) => Row | undefined;
 /**
  * Get the count of selected rows
  */

package/dist/src/utils/stickyParentsRenderer.d.ts

@@ -41,6 +41,7 @@ export interface StickyParentsContainerProps {
 export interface StickyParentsRenderContext {
     collapsedHeaders: Set<string>;
     customTheme: CustomTheme;
+    /** True when the column-editor toggle strip is visible and reserves horizontal space. */
     editColumns: boolean;
     headers: HeaderObject[];
     rowHeight: number;

package/dist/stories/examples/RowSelectionExample.d.ts

@@ -5,6 +5,7 @@ export declare const rowSelectionExampleDefaults: {
     selectableCells: boolean;
     columnReordering: boolean;
     enableRowSelection: boolean;
+    selectRowOnClick: boolean;
     height: string;
 };
 export declare function renderRowSelectionExample(args?: Partial<UniversalVanillaArgs>): HTMLElement;

package/dist/stories/tests/07-RowSelectionTests.stories.d.ts

@@ -67,3 +67,35 @@ export declare const SelectionPersistsThroughFilter: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
+export declare const SingleSelectionMode: {
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const ClickToSelectWithoutCheckboxColumn: {
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const KeyboardRowSelection: {
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+export declare const TableAPIRowSelection: {
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};

package/dist/stories/tests/12-CellSelectionTests.stories.d.ts

@@ -154,6 +154,46 @@ export declare const ShiftArrowExtendsSelection: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
+/**
+ * Spreadsheet-style Shift+Arrow: expand a range, then contract it back toward the
+ * anchor. Shift+ArrowUp after expanding downward must shrink the selection (not
+ * jump/expand the opposite edge).
+ */
+export declare const ShiftArrowContractsSelection: {
+    tags: string[];
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/**
+ * After a mouse-drag range, Shift+Arrow must continue from the drag endpoint
+ * (spreadsheet active cell), contracting/expanding that free end — not restart
+ * from the mousedown anchor and collapse the range.
+ */
+export declare const ShiftArrowContractsAfterMouseDrag: {
+    tags: string[];
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/**
+ * Horizontal Shift+Arrow expand then contract toward the column anchor.
+ */
+export declare const ShiftArrowContractsHorizontalSelection: {
+    tags: string[];
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
 export declare const CtrlASelectsAllCells: {
     render: () => HTMLDivElement & {
         _table?: import("../../src/index").SimpleTableVanilla | undefined;

package/dist/stories/tests/15-ColumnVisibilityTests.stories.d.ts

@@ -133,3 +133,11 @@ export declare const ColumnEditorRowRenderer: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
+export declare const ColumnEditorConfigShowToggleFalse: {
+    render: () => HTMLDivElement & {
+        _table?: import("../../src/index").SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};

package/dist/stories/tests/22-LoadingStateTests.stories.d.ts

@@ -53,3 +53,35 @@ export declare const LoadingToLoadedRemovesStaleCells: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
+/**
+ * Repro: `updateBodyCellElement` skips content rebuilds for expandable cells
+ * so the expand-icon DOM node survives for CSS transitions. That bypass also
+ * skips loading-skeleton swaps, so toggling `isLoading` on already-rendered
+ * row-grouped rows leaves the expandable column out of sync with every other
+ * column.
+ *
+ * Entering loading: non-expandable columns show skeletons; expandable columns
+ * keep their stale expand icon + value.
+ */
+export declare const ExpandableCellsShowSkeletonWhenEnteringLoading: {
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
+/**
+ * Repro (exit path): expandable cells created while `isLoading` is true render
+ * as skeletons. When loading ends, content updates are still skipped for
+ * expandable cells, so they stay stuck on the skeleton instead of restoring
+ * the expand icon + value.
+ */
+export declare const ExpandableCellsRestoreContentWhenLeavingLoading: {
+    render: () => HTMLDivElement & {
+        _table?: SimpleTableVanilla | undefined;
+    };
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};

package/dist/stories/tests/32-ThemesTests.stories.d.ts

@@ -53,6 +53,12 @@ export declare const UseHoverRowBackground: {
         canvasElement: HTMLElement;
     }) => Promise<void>;
 };
+export declare const UseHoverRowBackgroundIsolatedAcrossTables: {
+    render: () => HTMLDivElement;
+    play: ({ canvasElement }: {
+        canvasElement: HTMLElement;
+    }) => Promise<void>;
+};
 export declare const UseOddEvenRowBackground: {
     tags: string[];
     render: () => HTMLDivElement & {