simple-table-core 4.0.1 → 4.0.2

package/dist/{src/managers → managers}/SelectionManager/SelectionManager.d.ts

@@ -1,251 +1,251 @@
-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;
-    private static readonly HEADER_SELECTION_CLASSES;
-    /**
-     * Keep column header highlight in sync with cell/column selection during drag.
-     * Body cells are patched here; headers normally update only on full render.
-     */
-    private syncHeaderSelectionClasses;
-    private clearHeaderSelectionHighlightClasses;
-    /**
-     * 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;
-    /**
-     * 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.
-     * Uses the pointer position to resolve the cell under the cursor (same as continuousScroll)
-     * so virtualization/recycled DOM does not apply stale cellData from the firing element.
-     */
-    handleMouseOver(cellFromElement: Cell, clientX: number, clientY: number): void;
-}
+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;
+    private static readonly HEADER_SELECTION_CLASSES;
+    /**
+     * Keep column header highlight in sync with cell/column selection during drag.
+     * Body cells are patched here; headers normally update only on full render.
+     */
+    private syncHeaderSelectionClasses;
+    private clearHeaderSelectionHighlightClasses;
+    /**
+     * 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;
+    /**
+     * 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.
+     * Uses the pointer position to resolve the cell under the cursor (same as continuousScroll)
+     * so virtualization/recycled DOM does not apply stale cellData from the firing element.
+     */
+    handleMouseOver(cellFromElement: Cell, clientX: number, clientY: number): void;
+}

package/dist/{src/managers → managers}/SelectionManager/index.d.ts

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

package/dist/{src/managers → managers}/SelectionManager/keyboardUtils.d.ts

@@ -1,7 +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;
-};
+/**
+ * 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;
+};

package/dist/{cjs/src/managers → managers}/SelectionManager/mouseUtils.d.ts

@@ -1,16 +1,16 @@
-import type Cell from "../../types/Cell";
-/**
- * Calculate the nearest cell to a given mouse position.
- * Uses row buckets: one getBoundingClientRect per row to find the row, then only
- * measures cells in that row (O(rows + cols) instead of O(rows * cols)).
- */
-export declare function calculateNearestCell(clientX: number, clientY: number, root?: Document | HTMLElement): Cell | null;
-/**
- * Get cell from mouse position (element under point, or nearest cell).
- */
-export declare function getCellFromMousePosition(clientX: number, clientY: number, root?: Document | HTMLElement): Cell | null;
-/**
- * Handle auto-scrolling when dragging near table edges.
- * @param root - Table root (e.g. `.simple-table-root`); limits queries to this instance.
- */
-export declare function handleAutoScroll(clientX: number, clientY: number, root?: Document | HTMLElement): void;
+import type Cell from "../../types/Cell";
+/**
+ * Calculate the nearest cell to a given mouse position.
+ * Uses row buckets: one getBoundingClientRect per row to find the row, then only
+ * measures cells in that row (O(rows + cols) instead of O(rows * cols)).
+ */
+export declare function calculateNearestCell(clientX: number, clientY: number, root?: Document | HTMLElement): Cell | null;
+/**
+ * Get cell from mouse position (element under point, or nearest cell).
+ */
+export declare function getCellFromMousePosition(clientX: number, clientY: number, root?: Document | HTMLElement): Cell | null;
+/**
+ * Handle auto-scrolling when dragging near table edges.
+ * @param root - Table root (e.g. `.simple-table-root`); limits queries to this instance.
+ */
+export declare function handleAutoScroll(clientX: number, clientY: number, root?: Document | HTMLElement): void;

package/dist/{src/managers → managers}/SelectionManager/selectionRangeUtils.d.ts

@@ -1,7 +1,7 @@
-import type Cell from "../../types/Cell";
-import type TableRowType from "../../types/TableRow";
-/**
- * Compute the set of cell IDs for a selection range.
- * Resolves rowId to current row index (for virtualized/sorted tables) then fills the rectangle.
- */
-export declare function computeSelectionRange(startCell: Cell, endCell: Cell, tableRows: TableRowType[], enableRowSelection: boolean): Set<string>;
+import type Cell from "../../types/Cell";
+import type TableRowType from "../../types/TableRow";
+/**
+ * Compute the set of cell IDs for a selection range.
+ * Resolves rowId to current row index (for virtualized/sorted tables) then fills the rectangle.
+ */
+export declare function computeSelectionRange(startCell: Cell, endCell: Cell, tableRows: TableRowType[], enableRowSelection: boolean): Set<string>;

package/dist/{src/managers → managers}/SelectionManager/types.d.ts

@@ -1,28 +1,28 @@
-import type HeaderObject from "../../types/HeaderObject";
-import type { Accessor } from "../../types/HeaderObject";
-import type TableRowType from "../../types/TableRow";
-import type Cell from "../../types/Cell";
-import type { CustomTheme } from "../../types/CustomTheme";
-export declare const createSetString: ({ rowIndex, colIndex, rowId }: Cell) => string;
-export interface SelectionManagerConfig {
-    selectableCells: boolean;
-    /**
-     * When true, column header click selects columns (`st-header-selected` on headers).
-     * Cell-in-column header tint (`st-header-has-highlighted-cell`) also applies when `selectableCells` is true
-     * even if this is false.
-     */
-    selectableColumns?: boolean;
-    headers: HeaderObject[];
-    tableRows: TableRowType[];
-    onCellEdit?: (props: any) => void;
-    cellRegistry?: Map<string, any>;
-    collapsedHeaders?: Set<Accessor>;
-    rowHeight: number;
-    enableRowSelection?: boolean;
-    copyHeadersToClipboard?: boolean;
-    customTheme: CustomTheme;
-    /** Called when a selection drag ends so the table can re-render and apply selection classes. */
-    onSelectionDragEnd?: () => void;
-    /** Root element of the table; sync scopes cell queries to this so only this table's cells are updated. */
-    tableRoot?: HTMLElement;
-}
+import type HeaderObject from "../../types/HeaderObject";
+import type { Accessor } from "../../types/HeaderObject";
+import type TableRowType from "../../types/TableRow";
+import type Cell from "../../types/Cell";
+import type { CustomTheme } from "../../types/CustomTheme";
+export declare const createSetString: ({ rowIndex, colIndex, rowId }: Cell) => string;
+export interface SelectionManagerConfig {
+    selectableCells: boolean;
+    /**
+     * When true, column header click selects columns (`st-header-selected` on headers).
+     * Cell-in-column header tint (`st-header-has-highlighted-cell`) also applies when `selectableCells` is true
+     * even if this is false.
+     */
+    selectableColumns?: boolean;
+    headers: HeaderObject[];
+    tableRows: TableRowType[];
+    onCellEdit?: (props: any) => void;
+    cellRegistry?: Map<string, any>;
+    collapsedHeaders?: Set<Accessor>;
+    rowHeight: number;
+    enableRowSelection?: boolean;
+    copyHeadersToClipboard?: boolean;
+    customTheme: CustomTheme;
+    /** Called when a selection drag ends so the table can re-render and apply selection classes. */
+    onSelectionDragEnd?: () => void;
+    /** Root element of the table; sync scopes cell queries to this so only this table's cells are updated. */
+    tableRoot?: HTMLElement;
+}