@simple-table/angular 3.0.0-beta.8

package/dist/cjs/core/src/icons/CheckIcon.d.ts

@@ -0,0 +1 @@
+export declare const createCheckIcon: (className?: string) => SVGSVGElement;

package/dist/cjs/core/src/icons/DescIcon.d.ts

@@ -0,0 +1 @@
+export declare const createDescIcon: (className?: string) => SVGSVGElement;

package/dist/cjs/core/src/icons/DragIcon.d.ts

@@ -0,0 +1 @@
+export declare const createDragIcon: (className?: string) => SVGSVGElement;

package/dist/cjs/core/src/icons/FilterIcon.d.ts

@@ -0,0 +1 @@
+export declare const createFilterIcon: (className?: string) => SVGSVGElement;

package/dist/cjs/core/src/icons/SelectIcon.d.ts

@@ -0,0 +1 @@
+export declare const createSelectIcon: () => SVGSVGElement;

package/dist/cjs/core/src/icons/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Internal icon factory functions
+ * These create vanilla JS SVG elements for use within the table component
+ */
+export { createAngleDownIcon } from "./AngleDownIcon";
+export { createAngleLeftIcon } from "./AngleLeftIcon";
+export { createAngleRightIcon } from "./AngleRightIcon";
+export { createAngleUpIcon } from "./AngleUpIcon";
+export { createAscIcon } from "./AscIcon";
+export { createCheckIcon } from "./CheckIcon";
+export { createDescIcon } from "./DescIcon";
+export { createDragIcon } from "./DragIcon";
+export { createFilterIcon } from "./FilterIcon";
+export { createSelectIcon } from "./SelectIcon";

package/dist/cjs/core/src/index.d.ts

@@ -0,0 +1,48 @@
+import { SimpleTableVanilla } from "./core/SimpleTableVanilla";
+import type BoundingBox from "./types/BoundingBox";
+import type Cell from "./types/Cell";
+import type CellChangeProps from "./types/CellChangeProps";
+import type CellValue from "./types/CellValue";
+import type DragHandlerProps from "./types/DragHandlerProps";
+import type EnumOption from "./types/EnumOption";
+import type HeaderObject from "./types/HeaderObject";
+import type { Accessor, ChartOptions, ColumnType, Comparator, ComparatorProps, ExportValueGetter, ExportValueProps, ShowWhen, ValueFormatter, ValueFormatterProps, ValueGetter, ValueGetterProps } from "./types/HeaderObject";
+import type { AggregationConfig, AggregationType } from "./types/AggregationTypes";
+import type OnSortProps from "./types/OnSortProps";
+import type OnRowGroupExpandProps from "./types/OnRowGroupExpandProps";
+import type Row from "./types/Row";
+import type RowState from "./types/RowState";
+import type SharedTableProps from "./types/SharedTableProps";
+import type SortColumn from "./types/SortColumn";
+import type TableHeaderProps from "./types/TableHeaderProps";
+import type { TableAPI, SetHeaderRenameProps, ExportToCSVProps } from "./types/TableAPI";
+import type TableRefType from "./types/TableRefType";
+import type TableRowProps from "./types/TableRowProps";
+import type Theme from "./types/Theme";
+import type UpdateDataProps from "./types/UpdateCellProps";
+import type { FilterCondition, TableFilterState } from "./types/FilterTypes";
+import type { QuickFilterConfig, QuickFilterGetter, QuickFilterGetterProps, QuickFilterMode } from "./types/QuickFilterTypes";
+import type { ColumnVisibilityState } from "./types/ColumnVisibilityTypes";
+import type RowSelectionChangeProps from "./types/RowSelectionChangeProps";
+import type CellClickProps from "./types/CellClickProps";
+import type CellRendererProps from "./types/CellRendererProps";
+import type { CellRenderer } from "./types/CellRendererProps";
+import type HeaderRendererProps from "./types/HeaderRendererProps";
+import type { HeaderRenderer, HeaderRendererComponents } from "./types/HeaderRendererProps";
+import type ColumnEditorRowRendererProps from "./types/ColumnEditorRowRendererProps";
+import type { ColumnEditorRowRenderer, ColumnEditorRowRendererComponents } from "./types/ColumnEditorRowRendererProps";
+import type HeaderDropdownProps from "./types/HeaderDropdownProps";
+import type { HeaderDropdown } from "./types/HeaderDropdownProps";
+import type { RowButtonProps } from "./types/RowButton";
+import type FooterRendererProps from "./types/FooterRendererProps";
+import type { LoadingStateRenderer, ErrorStateRenderer, EmptyStateRenderer, LoadingStateRendererProps, ErrorStateRendererProps, EmptyStateRendererProps } from "./types/RowStateRendererProps";
+import type { CustomTheme, CustomThemeProps } from "./types/CustomTheme";
+import type { ColumnEditorConfig, ColumnEditorSearchFunction } from "./types/ColumnEditorConfig";
+import type { IconsConfig } from "./types/IconsConfig";
+import type { GetRowId, GetRowIdParams } from "./types/GetRowId";
+import type { SimpleTableConfig } from "./types/SimpleTableConfig";
+import type { SimpleTableProps } from "./types/SimpleTableProps";
+import type { RowId } from "./types/RowId";
+import type { PinnedSectionsState } from "./types/PinnedSectionsState";
+export { SimpleTableVanilla };
+export type { Accessor, AggregationConfig, AggregationType, BoundingBox, Cell, CellChangeProps, CellClickProps, CellRenderer, CellRendererProps, CellValue, ChartOptions, ColumnEditorConfig, ColumnEditorRowRenderer, ColumnEditorRowRendererComponents, ColumnEditorRowRendererProps, ColumnEditorSearchFunction, ColumnType, ColumnVisibilityState, Comparator, ComparatorProps, CustomTheme, CustomThemeProps, DragHandlerProps, EmptyStateRenderer, EmptyStateRendererProps, EnumOption, ErrorStateRenderer, ErrorStateRendererProps, ExportToCSVProps, ExportValueGetter, ExportValueProps, FilterCondition, FooterRendererProps, 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, TableRefType, TableRowProps, Theme, PinnedSectionsState, UpdateDataProps, ValueFormatter, ValueFormatterProps, ValueGetter, ValueGetterProps, };

package/dist/cjs/core/src/managers/AutoScaleManager.d.ts

@@ -0,0 +1,26 @@
+import HeaderObject from "../types/HeaderObject";
+interface AutoScaleConfig {
+    autoExpandColumns: boolean;
+    containerWidth: number;
+    pinnedLeftWidth: number;
+    pinnedRightWidth: number;
+    mainBodyRef: {
+        current: HTMLDivElement | null;
+    };
+    isResizing?: boolean;
+}
+type HeaderUpdateCallback = (headers: HeaderObject[]) => void;
+export declare const applyAutoScaleToHeaders: (headers: HeaderObject[], options: AutoScaleConfig) => HeaderObject[];
+export declare class AutoScaleManager {
+    private config;
+    private onHeadersUpdate;
+    private isResizingTracker;
+    private containerWidthTracker;
+    constructor(config: AutoScaleConfig, onHeadersUpdate: HeaderUpdateCallback);
+    updateConfig(config: Partial<AutoScaleConfig>): void;
+    private triggerAutoScale;
+    applyAutoScale(headers: HeaderObject[]): HeaderObject[];
+    setHeaders(headersOrUpdater: HeaderObject[] | ((prev: HeaderObject[]) => HeaderObject[]), currentHeaders: HeaderObject[]): HeaderObject[];
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,42 @@
+import HeaderObject from "../types/HeaderObject";
+export interface DimensionManagerConfig {
+    effectiveHeaders: HeaderObject[];
+    headerHeight?: number;
+    rowHeight: number;
+    height?: string | number;
+    maxHeight?: string | number;
+    totalRowCount: number;
+    footerHeight?: number;
+    containerElement?: HTMLElement;
+}
+export interface DimensionManagerState {
+    containerWidth: number;
+    calculatedHeaderHeight: number;
+    maxHeaderDepth: number;
+    contentHeight: number | undefined;
+}
+type StateChangeCallback = (state: DimensionManagerState) => void;
+export declare class DimensionManager {
+    private config;
+    private state;
+    private subscribers;
+    private resizeObserver;
+    private rafId;
+    constructor(config: DimensionManagerConfig);
+    private getHeaderDepth;
+    private calculateMaxHeaderDepth;
+    private calculateHeaderHeight;
+    private convertHeightToPixels;
+    private calculateContentHeight;
+    private observeContainer;
+    updateConfig(config: Partial<DimensionManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    getState(): DimensionManagerState;
+    getContainerWidth(): number;
+    getCalculatedHeaderHeight(): number;
+    getMaxHeaderDepth(): number;
+    getContentHeight(): number | undefined;
+    destroy(): void;
+}
+export {};

package/dist/cjs/core/src/managers/DragHandlerManager.d.ts

@@ -0,0 +1,44 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+export declare const getHeaderIndexPath: (headers: HeaderObject[], targetAccessor: Accessor, currentPath?: number[]) => number[] | null;
+export declare const getSiblingArray: (headers: HeaderObject[], indexPath: number[]) => HeaderObject[];
+export declare const setSiblingArray: (headers: HeaderObject[], indexPath: number[], newSiblings: HeaderObject[]) => HeaderObject[];
+export declare const getHeaderSection: (header: HeaderObject) => "left" | "main" | "right";
+export declare const updateHeaderPinnedProperty: (header: HeaderObject, targetSection: "left" | "main" | "right") => HeaderObject;
+export declare function swapHeaders(headers: HeaderObject[], draggedPath: number[], hoveredPath: number[]): {
+    newHeaders: HeaderObject[];
+    emergencyBreak: boolean;
+};
+export declare function insertHeaderAcrossSections({ headers, draggedHeader, hoveredHeader, }: {
+    headers: HeaderObject[];
+    draggedHeader: HeaderObject;
+    hoveredHeader: HeaderObject;
+}): {
+    newHeaders: HeaderObject[];
+    emergencyBreak: boolean;
+};
+export interface DragHandlerManagerConfig {
+    headers: HeaderObject[];
+    essentialAccessors?: ReadonlySet<string>;
+    onTableHeaderDragEnd: (newHeaders: HeaderObject[]) => void;
+    onColumnOrderChange?: (newHeaders: HeaderObject[]) => void;
+    onHeadersChange?: (newHeaders: HeaderObject[]) => void;
+}
+export declare class DragHandlerManager {
+    private config;
+    private draggedHeader;
+    private hoveredHeader;
+    private prevUpdateTime;
+    private prevDraggingPosition;
+    private prevHeadersTracker;
+    constructor(config: DragHandlerManagerConfig);
+    updateConfig(config: Partial<DragHandlerManagerConfig>): void;
+    getDraggedHeader(): HeaderObject | null;
+    getHoveredHeader(): HeaderObject | null;
+    handleDragStart(header: HeaderObject): void;
+    handleDragOver({ event, hoveredHeader, }: {
+        event: DragEvent;
+        hoveredHeader: HeaderObject;
+    }): void;
+    handleDragEnd(): void;
+    destroy(): void;
+}

package/dist/cjs/core/src/managers/FilterManager.d.ts

@@ -0,0 +1,36 @@
+import { TableFilterState, FilterCondition } from "../types/FilterTypes";
+import Row from "../types/Row";
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+export interface FilterManagerConfig {
+    rows: Row[];
+    headers: HeaderObject[];
+    externalFilterHandling: boolean;
+    onFilterChange?: (filters: TableFilterState) => void;
+    announce?: (message: string) => void;
+}
+export interface FilterManagerState {
+    filters: TableFilterState;
+    filteredRows: Row[];
+}
+type StateChangeCallback = (state: FilterManagerState) => void;
+export declare class FilterManager {
+    private config;
+    private state;
+    private subscribers;
+    private headerLookup;
+    constructor(config: FilterManagerConfig);
+    private updateHeaderLookup;
+    private computeFilteredRows;
+    updateConfig(config: Partial<FilterManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    updateFilter(filter: FilterCondition): void;
+    clearFilter(accessor: Accessor): void;
+    clearAllFilters(): void;
+    computeFilteredRowsPreview(filter: FilterCondition): Row[];
+    getState(): FilterManagerState;
+    getFilters(): TableFilterState;
+    getFilteredRows(): Row[];
+    destroy(): void;
+}
+export {};

package/dist/cjs/core/src/managers/RowManager.d.ts

@@ -0,0 +1,56 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import Row from "../types/Row";
+import RowState from "../types/RowState";
+import TableRow from "../types/TableRow";
+import { HeightOffsets } from "../utils/infiniteScrollUtils";
+import { CustomTheme } from "../types/CustomTheme";
+import { GetRowId } from "../types/GetRowId";
+export interface RowManagerConfig {
+    rows: Row[];
+    headers: HeaderObject[];
+    rowGrouping?: Accessor[];
+    getRowId?: GetRowId;
+    rowHeight: number;
+    headerHeight: number;
+    customTheme: CustomTheme;
+    hasLoadingRenderer: boolean;
+    hasErrorRenderer: boolean;
+    hasEmptyRenderer: boolean;
+}
+export interface RowManagerState {
+    expandedRows: Map<string, number>;
+    collapsedRows: Map<string, number>;
+    expandedDepths: Set<number>;
+    rowStateMap: Map<string | number, RowState>;
+    aggregatedRows: Row[];
+    flattenedRows: TableRow[];
+    heightOffsets: HeightOffsets;
+    paginatableRows: TableRow[];
+    parentEndPositions: number[];
+}
+type StateChangeCallback = (state: RowManagerState) => void;
+export declare class RowManager {
+    private config;
+    private state;
+    private subscribers;
+    constructor(config: RowManagerConfig);
+    private getAllAggregationHeaders;
+    private calculateAggregation;
+    private computeAggregatedRows;
+    private computeFlattenedRows;
+    updateConfig(config: Partial<RowManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    setExpandedRows(expandedRows: Map<string, number>): void;
+    setCollapsedRows(collapsedRows: Map<string, number>): void;
+    setExpandedDepths(expandedDepths: Set<number>): void;
+    setRowStateMap(rowStateMap: Map<string | number, RowState>): void;
+    getState(): RowManagerState;
+    getAggregatedRows(): Row[];
+    getFlattenedRows(): TableRow[];
+    getHeightOffsets(): HeightOffsets;
+    getPaginatableRows(): TableRow[];
+    getParentEndPositions(): number[];
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import TableRow from "../types/TableRow";
+import RowSelectionChangeProps from "../types/RowSelectionChangeProps";
+export interface RowSelectionManagerConfig {
+    tableRows: TableRow[];
+    onRowSelectionChange?: (props: RowSelectionChangeProps) => void;
+    enableRowSelection?: boolean;
+}
+export interface RowSelectionManagerState {
+    selectedRows: Set<string>;
+    selectedRowCount: number;
+    selectedRowsData: any[];
+}
+type StateChangeCallback = (state: RowSelectionManagerState) => void;
+export declare class RowSelectionManager {
+    private config;
+    private state;
+    private subscribers;
+    constructor(config: RowSelectionManagerConfig);
+    updateConfig(config: Partial<RowSelectionManagerConfig>): void;
+    private updateDerivedState;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    isRowSelected(rowId: string): boolean;
+    areAllRowsSelected(): boolean;
+    getSelectedRows(): Set<string>;
+    getSelectedRowCount(): number;
+    getSelectedRowsData(): any[];
+    setSelectedRows(selectedRows: Set<string>): void;
+    handleRowSelect(rowId: string, isSelected: boolean): void;
+    handleSelectAll(isSelected: boolean): void;
+    handleToggleRow(rowId: string): void;
+    clearSelection(): void;
+    getState(): RowSelectionManagerState;
+    destroy(): void;
+}
+export {};

package/dist/cjs/core/src/managers/ScrollManager.d.ts

@@ -0,0 +1,35 @@
+export interface ScrollManagerConfig {
+    onLoadMore?: () => void;
+    infiniteScrollThreshold?: number;
+}
+export interface ScrollManagerState {
+    scrollTop: number;
+    scrollLeft: number;
+    scrollDirection: "up" | "down" | "none";
+    isScrolling: boolean;
+}
+type StateChangeCallback = (state: ScrollManagerState) => void;
+/**
+ * Manages vertical scroll state (scrollTop, direction, isScrolling) and infinite scroll.
+ * Horizontal header/body/scrollbar sync is handled by SectionScrollController.
+ */
+export declare class ScrollManager {
+    private config;
+    private state;
+    private subscribers;
+    private lastScrollTop;
+    private scrollTimeoutId;
+    constructor(config: ScrollManagerConfig);
+    updateConfig(config: Partial<ScrollManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    handleScroll(scrollTop: number, scrollLeft: number, containerHeight: number, contentHeight: number): void;
+    setScrolling(isScrolling: boolean): void;
+    getState(): ScrollManagerState;
+    getScrollTop(): number;
+    getScrollLeft(): number;
+    getScrollDirection(): "up" | "down" | "none";
+    isScrolling(): boolean;
+    destroy(): void;
+}
+export {};

package/dist/cjs/core/src/managers/SectionScrollController.d.ts

@@ -0,0 +1,50 @@
+export type SectionId = "pinned-left" | "main" | "pinned-right";
+export type SectionPaneRole = "sticky" | "scrollbar" | "header" | "body";
+export interface SectionScrollControllerConfig {
+    onMainSectionScrollLeft?: (scrollLeft: number) => void;
+}
+/**
+ * Single controller for horizontal scroll sync across all four panes per section:
+ * sticky parent, horizontal scrollbar segment, header, and body.
+ * Scrolling any one pane updates the other three in that section.
+ * All four panes must have the same scroll width (enforced by renderers).
+ */
+export declare class SectionScrollController {
+    private scrollLeftBySection;
+    private panesBySection;
+    private scrollHandlers;
+    private config;
+    /** Guard to avoid re-entrancy when we programmatically set scrollLeft on other panes */
+    private isSyncing;
+    /** Last scrollLeft at which we ran main-section virtualization; used to run heavy ops only every N px. */
+    private lastMainVirtualizationScrollLeft;
+    constructor(config?: SectionScrollControllerConfig);
+    updateConfig(config: Partial<SectionScrollControllerConfig>): void;
+    /**
+     * Register a pane (sticky, scrollbar, header, or body) for a section.
+     * When any registered pane scrolls, the others in the same section are updated.
+     * If a pane with the same role was already registered (e.g. after re-render), it is replaced.
+     */
+    registerPane(sectionId: SectionId, element: HTMLElement, role: SectionPaneRole): void;
+    /**
+     * Unregister a pane (e.g. when section is removed or re-created).
+     */
+    unregisterPane(sectionId: SectionId, element: HTMLElement): void;
+    /**
+     * Unregister all panes for a section (e.g. on cleanup).
+     */
+    unregisterSection(sectionId: SectionId): void;
+    /**
+     * Set scroll position for a section. Updates state and all registered panes.
+     * Used when a pane fires scroll and when restoring after render.
+     */
+    setSectionScrollLeft(sectionId: SectionId, value: number): void;
+    getSectionScrollLeft(sectionId: SectionId): number;
+    /**
+     * Restore scroll position to all registered panes from stored state (e.g. after render).
+     */
+    restoreAll(): void;
+    private addScrollListener;
+    private removeScrollListener;
+    destroy(): void;
+}

package/dist/cjs/core/src/managers/SelectionManager/SelectionManager.d.ts

@@ -0,0 +1,246 @@
+import type Cell from "../../types/Cell";
+import { type SelectionManagerConfig } from "./types";
+export type { SelectionManagerConfig } from "./types";
+export { createSetString } from "./types";
+export declare class SelectionManager {
+    private config;
+    private selectedCells;
+    private selectedColumns;
+    private lastSelectedColumnIndex;
+    private initialFocusedCell;
+    private copyFlashCells;
+    private warningFlashCells;
+    private isSelecting;
+    private startCell;
+    private keydownHandler;
+    private currentMouseX;
+    private currentMouseY;
+    private scrollAnimationFrame;
+    private lastSelectionUpdate;
+    private selectionThrottleMs;
+    private globalMouseMoveHandler;
+    private globalMouseUpHandler;
+    private columnsWithSelectedCells;
+    private rowsWithSelectedCells;
+    private leafHeaders;
+    /** rowId -> table row index; avoids O(tableRows) findIndex per cell in getBorderClass */
+    private rowIdToTableIndex;
+    /** Set of "rowId\tcolIndex" for O(1) selected membership in syncAllCellClasses */
+    private selectedByRowIdColIndex;
+    /** When true, all cells are selected without storing R×C cell IDs (fast path for Cmd+A). */
+    private fullTableSelected;
+    constructor(config: SelectionManagerConfig);
+    /**
+     * Update configuration when props change.
+     * When options.positionOnlyBody is true (e.g. scroll-only render), only updates rowIdToTableIndex and
+     * selectedByRowIdColIndex so lookups work for new cells; skips columnsWithSelectedCells/rowsWithSelectedCells.
+     */
+    updateConfig(config: Partial<SelectionManagerConfig>, options?: {
+        positionOnlyBody?: boolean;
+    }): void;
+    /**
+     * Update derived state based on current selections.
+     * When fullTableSelected, derives columns/rows from table shape (O(R+C)) instead of iterating selectedCells (O(R×C)).
+     * Otherwise, single pass over selectedCells to build selectedByRowIdColIndex, columnsWithSelectedCells, rowsWithSelectedCells.
+     */
+    private updateDerivedState;
+    /**
+     * Minimal update for scroll-only renders: only rowIdToTableIndex and selectedByRowIdColIndex
+     * so isSelected/getBorderClass work for new cells; skips columnsWithSelectedCells and rowsWithSelectedCells.
+     * When fullTableSelected, selectedByRowIdColIndex is left empty (isSelected uses the flag).
+     */
+    private updateRowIdAndSelectionLookupOnly;
+    /**
+     * Setup keyboard navigation event listener
+     */
+    private setupKeyboardNavigation;
+    /**
+     * Clean up event listeners and resources
+     */
+    destroy(): void;
+    /**
+     * Handle keyboard events for navigation and clipboard operations
+     */
+    private handleKeyDown;
+    /**
+     * Handle navigation keys (arrows, home, end, page up/down)
+     */
+    private handleNavigationKeys;
+    /**
+     * Helper function to find the edge of data in a direction
+     */
+    private findEdgeInDirection;
+    /**
+     * Handle arrow up key
+     */
+    private handleArrowUp;
+    /**
+     * Handle arrow down key
+     */
+    private handleArrowDown;
+    /**
+     * Handle arrow left key
+     */
+    private handleArrowLeft;
+    /**
+     * Handle arrow right key
+     */
+    private handleArrowRight;
+    /**
+     * Handle home key
+     */
+    private handleHome;
+    /**
+     * Handle end key
+     */
+    private handleEnd;
+    /**
+     * Handle page up key
+     */
+    private handlePageUp;
+    /**
+     * Handle page down key
+     */
+    private handlePageDown;
+    /**
+     * Copy selected cells to clipboard
+     */
+    private copyToClipboard;
+    /**
+     * Paste from clipboard to cells
+     */
+    private pasteFromClipboard;
+    /**
+     * Delete content from selected cells
+     */
+    private deleteSelectedCells;
+    /**
+     * Select all cells in the table. Uses fullTableSelected flag instead of storing R×C cell IDs for O(1) update.
+     */
+    private selectAll;
+    /**
+     * Build the full set of cell IDs when fullTableSelected. Used for copy/delete/getSelectedCells.
+     */
+    private buildFullTableSelectedSet;
+    /**
+     * Clear all selections
+     */
+    clearSelection(): void;
+    /**
+     * Set selected cells (for external control)
+     */
+    setSelectedCells(cells: Set<string>): void;
+    /**
+     * Set selected columns (for external control)
+     */
+    setSelectedColumns(columns: Set<number>): void;
+    /**
+     * Update flash classes on cells (copy/warning animations)
+     */
+    private updateCellFlashClasses;
+    private static readonly SELECTION_CLASSES;
+    /**
+     * Apply selection classes to all currently rendered cells. Used after drag ends
+     * so that the DOM (which may have been replaced during scroll) reflects selection.
+     * Only adds/removes classes that changed to reduce DOM writes.
+     * Fast path when there is no selection: one pass to clear all selection classes.
+     */
+    private syncAllCellClasses;
+    /**
+     * Update all cell classes based on current selection state
+     * Directly manipulates the DOM without triggering React re-renders.
+     * When isSelecting (drag) or fullTableSelected (Cmd+A), run synchronously so classes are applied
+     * before any scroll-triggered render or next frame.
+     */
+    private updateAllCellClasses;
+    /**
+     * Check if a cell is selected. Uses selectedByRowIdColIndex for O(1) membership.
+     * When fullTableSelected, returns true for any cell without lookup.
+     */
+    isSelected({ colIndex, rowIndex, rowId }: Cell): boolean;
+    /**
+     * Get border class for a cell based on its selection state. Uses rowIdToTableIndex for O(1) lookups.
+     * When fullTableSelected, short-circuits with border classes for the full grid (no neighbor lookups).
+     */
+    getBorderClass({ colIndex, rowIndex, rowId }: Cell): string;
+    /**
+     * Check if a cell is the initial focused cell
+     */
+    isInitialFocusedCell({ rowIndex, colIndex, rowId }: Cell): boolean;
+    /**
+     * Check if a cell is currently showing copy flash animation
+     */
+    isCopyFlashing({ colIndex, rowIndex, rowId }: Cell): boolean;
+    /**
+     * Check if a cell is currently showing warning flash animation
+     */
+    isWarningFlashing({ colIndex, rowIndex, rowId }: Cell): boolean;
+    /**
+     * Get columns that have selected cells
+     */
+    getColumnsWithSelectedCells(): Set<number>;
+    /**
+     * Get rows that have selected cells
+     */
+    getRowsWithSelectedCells(): Set<string>;
+    /**
+     * Get selected cells. When fullTableSelected, builds and returns the full set on demand.
+     */
+    getSelectedCells(): Set<string>;
+    /**
+     * Get selected columns
+     */
+    getSelectedColumns(): Set<number>;
+    /**
+     * Get last selected column index
+     */
+    getLastSelectedColumnIndex(): number | null;
+    /**
+     * Get start cell for range selection
+     */
+    getStartCell(): Cell | null;
+    /**
+     * Set the initial focused cell (e.g. when clearing selection from header drag).
+     */
+    setInitialFocusedCell(cell: Cell | null): void;
+    /**
+     * Select a single cell
+     */
+    selectSingleCell(cell: Cell): void;
+    /**
+     * Select a range of cells from startCell to endCell
+     */
+    selectCellRange(startCell: Cell, endCell: Cell): void;
+    /**
+     * Select one or more columns
+     */
+    selectColumns(columnIndices: number[], isShiftKey?: boolean): void;
+    /**
+     * Update selection range during mouse drag. Skips derived state and class sync when selection unchanged.
+     */
+    private updateSelectionRange;
+    /**
+     * Calculate the nearest cell to a given mouse position
+     */
+    private calculateNearestCell;
+    /**
+     * Get cell from mouse position
+     */
+    private getCellFromMousePosition;
+    /**
+     * Handle auto-scrolling when dragging near edges
+     */
+    private handleAutoScroll;
+    /**
+     * Continuous scroll loop during mouse drag
+     */
+    private continuousScroll;
+    /**
+     * Handle mouse down on a cell to start selection
+     */
+    handleMouseDown({ colIndex, rowIndex, rowId }: Cell): void;
+    /**
+     * Handle mouse over a cell during selection drag
+     */
+    handleMouseOver({ colIndex, rowIndex, rowId }: Cell): void;
+}

package/dist/cjs/core/src/managers/SelectionManager/index.d.ts

@@ -0,0 +1,2 @@
+export { SelectionManager, createSetString, } from "./SelectionManager";
+export type { SelectionManagerConfig } from "./SelectionManager";

package/dist/cjs/core/src/managers/SelectionManager/keyboardUtils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Find the edge of data in a direction (pure helper for keyboard navigation).
+ */
+export declare function findEdgeInDirection(tableRowsLength: number, leafHeadersLength: number, enableRowSelection: boolean, startRow: number, startCol: number, direction: "up" | "down" | "left" | "right"): {
+    rowIndex: number;
+    colIndex: number;
+};