gp-grid-core 0.5.3 → 0.7.0

package/dist/index.d.ts

@@ -69,6 +69,81 @@ interface SlotState {
   translateY: number;
 }
 //#endregion
+//#region src/types/highlighting.d.ts
+/**
+ * Minimal column info for highlighting context.
+ * Uses structural typing to avoid circular dependency with columns.ts.
+ */
+interface HighlightColumnInfo {
+  field: string;
+  colId?: string;
+}
+/**
+ * Unified context for row, column, and cell highlighting.
+ *
+ * - Row context: `rowIndex` is set, `colIndex` is null
+ * - Column context: `colIndex` is set, `rowIndex` is null
+ * - Cell context: both `rowIndex` and `colIndex` are set
+ */
+interface HighlightContext<TData = Record<string, unknown>> {
+  /** Row index. Null for column-only context. */
+  rowIndex: number | null;
+  /** Column index. Null for row-only context. */
+  colIndex: number | null;
+  /** Column definition. Present for column and cell contexts. */
+  column?: HighlightColumnInfo;
+  /** Row data. Present for row and cell contexts. */
+  rowData?: TData;
+  /** Currently hovered cell position, null if not hovering */
+  hoverPosition: CellPosition | null;
+  /** Currently active (focused) cell position */
+  activeCell: CellPosition | null;
+  /** Current selection range */
+  selectionRange: CellRange | null;
+  /** Whether this row/column/cell is hovered (respects hoverScope) */
+  isHovered: boolean;
+  /** Whether this row/column contains or is the active cell */
+  isActive: boolean;
+  /** Whether this row/column/cell overlaps or is in the selection range */
+  isSelected: boolean;
+}
+/**
+ * Grid-level highlighting options.
+ * Hover tracking is automatically enabled when any highlighting callback is defined.
+ * Each callback type has its own natural interpretation of `isHovered`:
+ * - computeRowClasses: isHovered = mouse is on any cell in this row
+ * - computeColumnClasses: isHovered = mouse is on any cell in this column
+ * - computeCellClasses: isHovered = mouse is on this exact cell
+ *
+ * For a crosshair effect, implement both computeRowClasses and computeColumnClasses.
+ */
+interface HighlightingOptions<TData = Record<string, unknown>> {
+  /**
+   * Row-level class callback.
+   * Classes returned are applied to the row container element.
+   * Context has `rowIndex` set, `colIndex` is null.
+   * `isHovered` is true when the mouse is on any cell in this row.
+   * @returns Array of CSS class names
+   */
+  computeRowClasses?: (context: HighlightContext<TData>) => string[];
+  /**
+   * Column-level class callback.
+   * Classes returned are applied to all cells in that column (not header).
+   * Context has `colIndex` set, `rowIndex` is null.
+   * `isHovered` is true when the mouse is on any cell in this column.
+   * @returns Array of CSS class names
+   */
+  computeColumnClasses?: (context: HighlightContext<TData>) => string[];
+  /**
+   * Cell-level class callback.
+   * Classes returned are applied to individual cells for fine-grained control.
+   * Context has both `rowIndex` and `colIndex` set.
+   * `isHovered` is true only when the mouse is on this exact cell.
+   * @returns Array of CSS class names
+   */
+  computeCellClasses?: (context: HighlightContext<TData>) => string[];
+}
+//#endregion
 //#region src/types/columns.d.ts
 /** Column definition */
 interface ColumnDefinition {
@@ -82,10 +157,26 @@ interface ColumnDefinition {
   sortable?: boolean;
   /** Whether column is filterable. Default: true */
   filterable?: boolean;
+  /** Whether column is hidden. Hidden columns are not rendered but still exist in the definition. Default: false */
+  hidden?: boolean;
   /** Renderer key for adapter lookup, or inline renderer function */
   cellRenderer?: string;
   editRenderer?: string;
   headerRenderer?: string;
+  /**
+   * Per-column override for column-level highlighting.
+   * If defined, overrides grid-level computeColumnClasses for this column.
+   * Context has `colIndex` set, `rowIndex` is null.
+   * @returns Array of CSS class names to apply to all cells in this column
+   */
+  computeColumnClasses?: (context: HighlightContext) => string[];
+  /**
+   * Per-column override for cell-level highlighting.
+   * If defined, overrides grid-level computeCellClasses for cells in this column.
+   * Context has both `rowIndex` and `colIndex` set.
+   * @returns Array of CSS class names to apply to individual cells
+   */
+  computeCellClasses?: (context: HighlightContext) => string[];
 }
 //#endregion
 //#region src/types/filters.d.ts
@@ -197,6 +288,11 @@ interface SetActiveCellInstruction {
   type: "SET_ACTIVE_CELL";
   position: CellPosition | null;
 }
+/** Set hover position instruction (for highlighting) */
+interface SetHoverPositionInstruction {
+  type: "SET_HOVER_POSITION";
+  position: CellPosition | null;
+}
 /** Set selection range instruction */
 interface SetSelectionRangeInstruction {
   type: "SET_SELECTION_RANGE";
@@ -306,19 +402,20 @@ interface DataErrorInstruction {
 /** Rows added instruction */
 interface RowsAddedInstruction {
   type: "ROWS_ADDED";
+  indices: number[];
   count: number;
   totalRows: number;
 }
 /** Rows removed instruction */
 interface RowsRemovedInstruction {
   type: "ROWS_REMOVED";
-  count: number;
+  indices: number[];
   totalRows: number;
 }
 /** Rows updated instruction */
 interface RowsUpdatedInstruction {
   type: "ROWS_UPDATED";
-  count: number;
+  indices: number[];
 }
 /** Transaction processed instruction */
 interface TransactionProcessedInstruction {
@@ -331,6 +428,7 @@ interface TransactionProcessedInstruction {
 type GridInstruction = /** Slot lifecycle */
 CreateSlotInstruction | DestroySlotInstruction | AssignSlotInstruction | MoveSlotInstruction
 /** Selection */ | SetActiveCellInstruction | SetSelectionRangeInstruction | UpdateVisibleRangeInstruction
+/** Highlighting */ | SetHoverPositionInstruction
 /** Editing */ | StartEditInstruction | StopEditInstruction | CommitEditInstruction
 /** Layout */ | SetContentSizeInstruction | UpdateHeaderInstruction
 /** Filter popup */ | OpenFilterPopupInstruction | CloseFilterPopupInstruction
@@ -414,6 +512,8 @@ interface GridCoreOptions<TData = Row> {
   transactionDebounceMs?: number;
   /** Function to extract unique ID from row. Required for mutations. */
   getRowId?: (row: TData) => RowId;
+  /** Row/column/cell highlighting configuration */
+  highlighting?: HighlightingOptions<TData>;
 }
 //#endregion
 //#region src/types/input.d.ts
@@ -494,10 +594,16 @@ interface InputHandlerDeps {
   getHeaderHeight: () => number;
   /** Get row height */
   getRowHeight: () => number;
-  /** Get column positions array */
+  /** Get column positions array (indexed by visible column) */
   getColumnPositions: () => number[];
-  /** Get column count */
+  /** Get visible column count */
   getColumnCount: () => number;
+  /**
+   * Convert visible column index to original column index.
+   * Used when columns can be hidden. Returns the original index for selection tracking.
+   * If not provided, visible index is used directly (no hidden columns).
+   */
+  getOriginalColumnIndex?: (visibleIndex: number) => number;
 }
 /** Current drag state for UI rendering */
 interface DragState {
@@ -514,6 +620,83 @@ interface DragState {
   } | null;
 }
 //#endregion
+//#region src/utils/positioning.d.ts
+/**
+ * Calculate cumulative column positions (prefix sums)
+ * Returns an array where positions[i] is the left position of column i
+ * positions[columns.length] is the total width
+ */
+declare const calculateColumnPositions: (columns: ColumnDefinition[]) => number[];
+/**
+ * Get total width from column positions
+ */
+declare const getTotalWidth: (columnPositions: number[]) => number;
+/**
+ * Calculate scaled column positions when container is wider than total column widths.
+ * Columns expand proportionally based on their original width ratios.
+ *
+ * @param columns - Column definitions with original widths
+ * @param containerWidth - Available container width
+ * @returns Object with positions array and widths array
+ */
+declare const calculateScaledColumnPositions: (columns: ColumnDefinition[], containerWidth: number) => {
+  positions: number[];
+  widths: number[];
+};
+/**
+ * Find column index at a given X coordinate
+ */
+declare const findColumnAtX: (x: number, columnPositions: number[]) => number;
+//#endregion
+//#region src/utils/classNames.d.ts
+/**
+ * Check if a cell is within the selection range
+ */
+declare const isCellSelected: (row: number, col: number, selectionRange: CellRange | null) => boolean;
+/**
+ * Check if a cell is the active cell
+ */
+declare const isCellActive: (row: number, col: number, activeCell: CellPosition | null) => boolean;
+/**
+ * Check if a row is within the visible range (not in overscan)
+ */
+declare const isRowVisible: (row: number, visibleRowRange: {
+  start: number;
+  end: number;
+} | null) => boolean;
+/**
+ * Check if a cell is being edited
+ */
+declare const isCellEditing: (row: number, col: number, editingCell: {
+  row: number;
+  col: number;
+} | null) => boolean;
+/**
+ * Check if a cell is in the fill preview range (vertical-only fill)
+ */
+declare const isCellInFillPreview: (row: number, col: number, isDraggingFill: boolean, fillSourceRange: CellRange | null, fillTarget: {
+  row: number;
+  col: number;
+} | null) => boolean;
+/**
+ * Build cell CSS classes based on state
+ */
+declare const buildCellClasses: (isActive: boolean, isSelected: boolean, isEditing: boolean, inFillPreview: boolean) => string;
+/**
+ * Check if a row overlaps the selection range
+ */
+declare const isRowInSelectionRange: (rowIndex: number, range: CellRange | null) => boolean;
+/**
+ * Check if a column overlaps the selection range
+ */
+declare const isColumnInSelectionRange: (colIndex: number, range: CellRange | null) => boolean;
+//#endregion
+//#region src/utils/event-emitter.d.ts
+/**
+ * Batch instruction listener for efficient state updates
+ */
+type BatchInstructionListener$1 = (instructions: GridInstruction[]) => void;
+//#endregion
 //#region src/selection.d.ts
 type Direction = "up" | "down" | "left" | "right";
 interface SelectionManagerOptions {
@@ -529,10 +712,10 @@ interface SelectionManagerOptions {
 declare class SelectionManager {
   private state;
   private options;
-  private listeners;
-  constructor(options: SelectionManagerOptions);
-  onInstruction(listener: InstructionListener): () => void;
+  private emitter;
+  onInstruction: (listener: InstructionListener) => () => void;
   private emit;
+  constructor(options: SelectionManagerOptions);
   getState(): SelectionState;
   getActiveCell(): CellPosition | null;
   getSelectionRange(): CellRange | null;
@@ -597,10 +780,10 @@ interface FillManagerOptions {
 declare class FillManager {
   private state;
   private options;
-  private listeners;
-  constructor(options: FillManagerOptions);
-  onInstruction(listener: InstructionListener): () => void;
+  private emitter;
+  onInstruction: (listener: InstructionListener) => () => void;
   private emit;
+  constructor(options: FillManagerOptions);
   getState(): FillHandleState | null;
   isActive(): boolean;
   /**
@@ -657,6 +840,14 @@ declare class InputHandler<TData extends Row = Row> {
    * Handle cell double click event (start editing)
    */
   handleCellDoubleClick(rowIndex: number, colIndex: number): void;
+  /**
+   * Handle cell mouse enter event (for hover highlighting)
+   */
+  handleCellMouseEnter(rowIndex: number, colIndex: number): void;
+  /**
+   * Handle cell mouse leave event (for hover highlighting)
+   */
+  handleCellMouseLeave(): void;
   /**
    * Handle fill handle mouse down event
    */
@@ -692,16 +883,222 @@ declare class InputHandler<TData extends Row = Row> {
     row: number;
     col: number;
   } | null, filterPopupOpen: boolean): KeyboardResult;
-  /**
-   * Find column index at a given X coordinate
-   */
-  private findColumnAtX;
   /**
    * Calculate auto-scroll deltas based on mouse position
    */
   private calculateAutoScroll;
 }
 //#endregion
+//#region src/highlight-manager.d.ts
+interface HighlightManagerOptions {
+  getActiveCell: () => CellPosition | null;
+  getSelectionRange: () => CellRange | null;
+  getColumn: (colIndex: number) => ColumnDefinition | undefined;
+}
+/**
+ * Manages row/column/cell highlighting state and class computation.
+ * Emits SET_HOVER_POSITION instructions when hover position changes.
+ */
+declare class HighlightManager<TData = Record<string, unknown>> {
+  private options;
+  private highlightingOptions;
+  private hoverPosition;
+  private emitter;
+  onInstruction: (listener: InstructionListener) => () => void;
+  private emit;
+  private rowClassCache;
+  private columnClassCache;
+  private cellClassCache;
+  constructor(options: HighlightManagerOptions, highlightingOptions?: HighlightingOptions<TData>);
+  /**
+   * Check if highlighting is enabled (any callback defined).
+   * Hover tracking is automatically enabled when highlighting is enabled.
+   */
+  isEnabled(): boolean;
+  /**
+   * Set the current hover position. Clears caches and emits instruction.
+   * Hover tracking is automatically enabled when any highlighting callback is defined.
+   */
+  setHoverPosition(position: CellPosition | null): void;
+  /**
+   * Get the current hover position
+   */
+  getHoverPosition(): CellPosition | null;
+  /**
+   * Called when selection changes. Clears all caches.
+   */
+  onSelectionChange(): void;
+  /**
+   * Build context for row highlighting callback.
+   * Returns context with `rowIndex` set, `colIndex` is null.
+   * `isHovered` is true when the mouse is on any cell in this row.
+   */
+  buildRowContext(rowIndex: number, rowData?: TData): HighlightContext<TData>;
+  /**
+   * Build context for column highlighting callback.
+   * Returns context with `colIndex` set, `rowIndex` is null.
+   * `isHovered` is true when the mouse is on any cell in this column.
+   */
+  buildColumnContext(colIndex: number, column: ColumnDefinition): HighlightContext<TData>;
+  /**
+   * Build context for cell highlighting callback.
+   * Returns context with both `rowIndex` and `colIndex` set.
+   * `isHovered` is true only when the mouse is on this exact cell.
+   */
+  buildCellContext(rowIndex: number, colIndex: number, column: ColumnDefinition, rowData?: TData): HighlightContext<TData>;
+  /**
+   * Compute row classes using cache and user callback
+   */
+  computeRowClasses(rowIndex: number, rowData?: TData): string[];
+  /**
+   * Compute column classes using cache and user callback (or per-column override)
+   */
+  computeColumnClasses(colIndex: number, column: ColumnDefinition): string[];
+  /**
+   * Compute cell classes using cache and user callback (or per-column override)
+   */
+  computeCellClasses(rowIndex: number, colIndex: number, column: ColumnDefinition, rowData?: TData): string[];
+  /**
+   * Compute combined cell classes (column + cell classes flattened)
+   */
+  computeCombinedCellClasses(rowIndex: number, colIndex: number, column: ColumnDefinition, rowData?: TData): string[];
+  /**
+   * Clear all caches
+   */
+  clearAllCaches(): void;
+  /**
+   * Destroy the manager and release resources
+   */
+  destroy(): void;
+}
+//#endregion
+//#region src/sort-filter-manager.d.ts
+interface SortFilterManagerOptions<TData> {
+  /** Get all columns */
+  getColumns: () => ColumnDefinition[];
+  /** Check if sorting is enabled globally */
+  isSortingEnabled: () => boolean;
+  /** Get cached rows for distinct value computation */
+  getCachedRows: () => Map<number, TData>;
+  /** Called when sort/filter changes to trigger data refresh */
+  onSortFilterChange: () => Promise<void>;
+  /** Called after data refresh to update UI */
+  onDataRefreshed: () => void;
+}
+/**
+ * Manages sorting and filtering state and operations.
+ */
+declare class SortFilterManager<TData = Record<string, unknown>> {
+  private options;
+  private emitter;
+  private sortModel;
+  private filterModel;
+  private openFilterColIndex;
+  onInstruction: (listener: InstructionListener) => () => void;
+  private emit;
+  constructor(options: SortFilterManagerOptions<TData>);
+  setSort(colId: string, direction: SortDirection | null, addToExisting?: boolean): Promise<void>;
+  getSortModel(): SortModel[];
+  setFilter(colId: string, filter: ColumnFilterModel | string | null): Promise<void>;
+  getFilterModel(): FilterModel;
+  /**
+   * Check if a column has an active filter
+   */
+  hasActiveFilter(colId: string): boolean;
+  /**
+   * Check if a column is sortable
+   */
+  isColumnSortable(colIndex: number): boolean;
+  /**
+   * Check if a column is filterable
+   */
+  isColumnFilterable(colIndex: number): boolean;
+  /**
+   * Get distinct values for a column (for filter dropdowns)
+   * For array-type columns (like tags), each unique array combination is returned.
+   * Arrays are sorted internally for consistent comparison.
+   * Limited to maxValues to avoid performance issues with large datasets.
+   */
+  getDistinctValuesForColumn(colId: string, maxValues?: number): CellValue[];
+  /**
+   * Open filter popup for a column (toggles if already open for same column)
+   */
+  openFilterPopup(colIndex: number, anchorRect: {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+  }): void;
+  /**
+   * Close filter popup
+   */
+  closeFilterPopup(): void;
+  /**
+   * Get sort info map for header rendering
+   */
+  getSortInfoMap(): Map<string, {
+    direction: SortDirection;
+    index: number;
+  }>;
+  destroy(): void;
+}
+//#endregion
+//#region src/row-mutation-manager.d.ts
+interface RowMutationManagerOptions<TData> {
+  /** Get the cached rows map */
+  getCachedRows: () => Map<number, TData>;
+  /** Set the cached rows map (for bulk operations) */
+  setCachedRows: (rows: Map<number, TData>) => void;
+  /** Get total row count */
+  getTotalRows: () => number;
+  /** Set total row count */
+  setTotalRows: (count: number) => void;
+  /** Update a single slot after row change */
+  updateSlot: (rowIndex: number) => void;
+  /** Refresh all slots after bulk changes */
+  refreshAllSlots: () => void;
+  /** Emit content size change */
+  emitContentSize: () => void;
+  /** Clear selection if it references invalid rows */
+  clearSelectionIfInvalid: (maxValidRow: number) => void;
+}
+/**
+ * Manages row CRUD operations and cache management.
+ */
+declare class RowMutationManager<TData extends Row = Row> {
+  private options;
+  private emitter;
+  onInstruction: (listener: InstructionListener) => () => void;
+  private emit;
+  constructor(options: RowMutationManagerOptions<TData>);
+  /**
+   * Get a row by index.
+   */
+  getRow(index: number): TData | undefined;
+  /**
+   * Add rows to the grid at the specified index.
+   * If no index is provided, rows are added at the end.
+   */
+  addRows(rows: TData[], index?: number): void;
+  /**
+   * Update existing rows with partial data.
+   */
+  updateRows(updates: Array<{
+    index: number;
+    data: Partial<TData>;
+  }>): void;
+  /**
+   * Delete rows at the specified indices.
+   */
+  deleteRows(indices: number[]): void;
+  /**
+   * Set a complete row at the specified index.
+   * Use this for complete row replacement. For partial updates, use updateRows.
+   */
+  setRow(index: number, data: TData): void;
+  destroy(): void;
+}
+//#endregion
 //#region src/grid-core.d.ts
 declare class GridCore<TData extends Row = Row> {
   private columns;
@@ -718,29 +1115,25 @@ declare class GridCore<TData extends Row = Row> {
   private totalRows;
   private currentPageIndex;
   private pageSize;
-  private sortModel;
-  private filterModel;
-  private openFilterColIndex;
   readonly selection: SelectionManager;
   readonly fill: FillManager;
   readonly input: InputHandler<TData>;
+  readonly highlight: HighlightManager<TData> | null;
+  readonly sortFilter: SortFilterManager<TData>;
+  readonly rowMutation: RowMutationManager<TData>;
   private readonly slotPool;
   private readonly editManager;
   private columnPositions;
-  private listeners;
-  private batchListeners;
+  private emitter;
+  onInstruction: (listener: InstructionListener) => () => void;
+  onBatchInstruction: (listener: BatchInstructionListener$1) => () => void;
+  private emit;
+  private emitBatch;
   private naturalContentHeight;
   private virtualContentHeight;
   private scrollRatio;
+  private isDestroyed;
   constructor(options: GridCoreOptions<TData>);
-  onInstruction(listener: InstructionListener): () => void;
-  /**
-   * Subscribe to batched instructions for efficient React state updates.
-   * Batch listeners receive arrays of instructions instead of individual ones.
-   */
-  onBatchInstruction(listener: BatchInstructionListener): () => void;
-  private emit;
-  private emitBatch;
   /**
    * Initialize the grid and load initial data.
    */
@@ -754,37 +1147,16 @@ declare class GridCore<TData extends Row = Row> {
   private fetchAllData;
   setSort(colId: string, direction: SortDirection | null, addToExisting?: boolean): Promise<void>;
   setFilter(colId: string, filter: ColumnFilterModel | string | null): Promise<void>;
-  /**
-   * Check if a column has an active filter
-   */
   hasActiveFilter(colId: string): boolean;
-  /**
-   * Check if a column is sortable
-   */
   isColumnSortable(colIndex: number): boolean;
-  /**
-   * Check if a column is filterable
-   */
   isColumnFilterable(colIndex: number): boolean;
-  /**
-   * Get distinct values for a column (for filter dropdowns)
-   * For array-type columns (like tags), each unique array combination is returned.
-   * Arrays are sorted internally for consistent comparison.
-   * Limited to MAX_DISTINCT_VALUES to avoid performance issues with large datasets.
-   */
   getDistinctValuesForColumn(colId: string, maxValues?: number): CellValue[];
-  /**
-   * Open filter popup for a column (toggles if already open for same column)
-   */
   openFilterPopup(colIndex: number, anchorRect: {
     top: number;
     left: number;
     width: number;
     height: number;
   }): void;
-  /**
-   * Close filter popup
-   */
   closeFilterPopup(): void;
   getSortModel(): SortModel[];
   getFilterModel(): FilterModel;
@@ -795,8 +1167,6 @@ declare class GridCore<TData extends Row = Row> {
   getEditState(): EditState | null;
   getCellValue(row: number, col: number): CellValue;
   setCellValue(row: number, col: number, value: CellValue): void;
-  private getFieldValue;
-  private setFieldValue;
   private computeColumnPositions;
   private emitContentSize;
   private emitHeaders;
@@ -853,6 +1223,31 @@ declare class GridCore<TData extends Row = Row> {
    * Useful after in-place data modifications like fill operations.
    */
   refreshSlotData(): void;
+  /**
+   * Add rows to the grid at the specified index.
+   * If no index is provided, rows are added at the end.
+   */
+  addRows(rows: TData[], index?: number): void;
+  /**
+   * Update existing rows with partial data.
+   */
+  updateRows(updates: Array<{
+    index: number;
+    data: Partial<TData>;
+  }>): void;
+  /**
+   * Delete rows at the specified indices.
+   */
+  deleteRows(indices: number[]): void;
+  /**
+   * Get a row by index.
+   */
+  getRow(index: number): TData | undefined;
+  /**
+   * Set a complete row at the specified index.
+   * Use this for complete row replacement. For partial updates, use updateRows.
+   */
+  setRow(index: number, data: TData): void;
   /**
    * Update the data source and refresh.
    */
@@ -861,6 +1256,12 @@ declare class GridCore<TData extends Row = Row> {
    * Update columns and recompute layout.
    */
   setColumns(columns: ColumnDefinition[]): void;
+  /**
+   * Destroy the grid core and release all references.
+   * Call this before discarding the GridCore to ensure proper cleanup.
+   * This method is idempotent - safe to call multiple times.
+   */
+  destroy(): void;
 }
 //#endregion
 //#region src/slot-pool.d.ts
@@ -888,21 +1289,16 @@ interface SlotPoolManagerOptions {
  * Manages the slot pool for virtual scrolling.
  * Handles slot creation, recycling, positioning, and destruction.
  */
-/** Batch instruction listener for efficient React state updates */
-type BatchInstructionListener$1 = (instructions: GridInstruction[]) => void;
 declare class SlotPoolManager {
   private state;
   private options;
-  private listeners;
-  private batchListeners;
-  constructor(options: SlotPoolManagerOptions);
-  onInstruction(listener: InstructionListener): () => void;
-  /**
-   * Subscribe to batched instructions for efficient state updates.
-   */
-  onBatchInstruction(listener: BatchInstructionListener$1): () => void;
+  private emitter;
+  private isDestroyed;
+  onInstruction: (listener: InstructionListener) => () => void;
+  onBatchInstruction: (listener: BatchInstructionListener$1) => () => void;
   private emit;
   private emitBatch;
+  constructor(options: SlotPoolManagerOptions);
   /**
    * Get the slot ID for a given row index.
    */
@@ -922,6 +1318,7 @@ declare class SlotPoolManager {
   destroyAllSlots(): void;
   /**
    * Clean up resources for garbage collection.
+   * This method is idempotent - safe to call multiple times.
    */
   destroy(): void;
   /**
@@ -957,10 +1354,10 @@ interface EditManagerOptions {
 declare class EditManager {
   private editState;
   private options;
-  private listeners;
-  constructor(options: EditManagerOptions);
-  onInstruction(listener: InstructionListener): () => void;
+  private emitter;
+  onInstruction: (listener: InstructionListener) => () => void;
   private emit;
+  constructor(options: EditManagerOptions);
   /**
    * Get the current edit state.
    */
@@ -998,12 +1395,206 @@ declare class EditManager {
   destroy(): void;
 }
 //#endregion
+//#region src/sorting/parallel-sort-manager.d.ts
+interface ParallelSortOptions {
+  /** Maximum number of workers (default: navigator.hardwareConcurrency || 4) */
+  maxWorkers?: number;
+  /** Threshold for parallel sorting (default: 400000) */
+  parallelThreshold?: number;
+  /** Minimum chunk size (default: 50000) */
+  minChunkSize?: number;
+}
+/**
+ * Manages parallel sorting operations using a worker pool.
+ * Automatically decides between single-worker and parallel sorting based on data size.
+ */
+declare class ParallelSortManager {
+  private pool;
+  private parallelThreshold;
+  private minChunkSize;
+  private isTerminated;
+  constructor(options?: ParallelSortOptions);
+  /**
+   * Check if the manager is available for use.
+   */
+  isAvailable(): boolean;
+  /**
+   * Terminate all workers and clean up resources.
+   */
+  terminate(): void;
+  /**
+   * Sort indices using values array.
+   * Automatically uses parallel sorting for large datasets.
+   */
+  sortIndices(values: number[], direction: SortDirection): Promise<Uint32Array>;
+  /**
+   * Sort string hashes with collision detection.
+   * Automatically uses parallel sorting for large datasets.
+   */
+  sortStringHashes(hashChunks: Float64Array[], direction: SortDirection, originalStrings: string[]): Promise<Uint32Array>;
+  /**
+   * Multi-column sort.
+   * Automatically uses parallel sorting for large datasets.
+   */
+  sortMultiColumn(columns: number[][], directions: SortDirection[]): Promise<Uint32Array>;
+  private sortIndicesSingle;
+  private sortStringHashesSingle;
+  private sortMultiColumnSingle;
+  private sortIndicesParallel;
+  private sortStringHashesParallel;
+  private sortMultiColumnParallel;
+  /**
+   * Split data into chunks for parallel processing.
+   */
+  private splitIntoChunks;
+  /**
+   * Calculate chunk boundaries without copying data.
+   */
+  private calculateChunkBoundaries;
+  /**
+   * Detect collisions at chunk boundaries for string sorting.
+   */
+  private detectBoundaryCollisionsForStrings;
+  /**
+   * Resolve hash collisions using localeCompare.
+   */
+  private resolveCollisions;
+}
+//#endregion
+//#region src/sorting/worker-pool.d.ts
+interface WorkerPoolOptions {
+  /** Maximum number of workers (default: navigator.hardwareConcurrency ?? 4) */
+  maxWorkers?: number;
+  /** Whether to pre-warm workers on initialization */
+  preWarm?: boolean;
+}
+/**
+ * Manages a pool of Web Workers for parallel task execution.
+ * Workers are created lazily and reused across operations.
+ */
+declare class WorkerPool {
+  private workerCode;
+  private maxWorkers;
+  private workers;
+  private workerUrl;
+  private nextRequestId;
+  private isTerminated;
+  constructor(workerCode: string, options?: WorkerPoolOptions);
+  /**
+   * Get the current pool size (number of active workers).
+   */
+  getPoolSize(): number;
+  /**
+   * Get the maximum pool size.
+   */
+  getMaxWorkers(): number;
+  /**
+   * Check if the pool is available for use.
+   */
+  isAvailable(): boolean;
+  /**
+   * Execute a single task on an available worker.
+   * Returns the worker's response.
+   */
+  execute<TRequest extends {
+    id?: number;
+  }, TResponse>(request: TRequest, transferables?: Transferable[]): Promise<TResponse>;
+  /**
+   * Execute multiple tasks in parallel across available workers.
+   * Each task is assigned to a different worker if possible.
+   * Returns results in the same order as the input requests.
+   */
+  executeParallel<TRequest extends {
+    id?: number;
+  }, TResponse>(tasks: Array<{
+    request: TRequest;
+    transferables?: Transferable[];
+  }>): Promise<TResponse[]>;
+  /**
+   * Terminate all workers and clean up resources.
+   */
+  terminate(): void;
+  /**
+   * Pre-warm workers by creating them ahead of time.
+   */
+  private preWarmWorkers;
+  /**
+   * Ensure at least `count` workers exist in the pool.
+   */
+  private ensureWorkers;
+  /**
+   * Get an available worker, creating one if needed.
+   */
+  private getAvailableWorker;
+  /**
+   * Create a new worker and add it to the pool.
+   */
+  private createWorker;
+  /**
+   * Respawn a failed worker.
+   */
+  private respawnWorker;
+}
+//#endregion
+//#region src/sorting/k-way-merge.d.ts
+/**
+ * Represents a sorted chunk with its values and offset in the original array.
+ */
+interface SortedChunk {
+  /** Sorted indices (local to this chunk) */
+  indices: Uint32Array;
+  /** Values for comparison (in same order as indices) */
+  values: Float64Array;
+  /** Offset of this chunk in the original array */
+  offset: number;
+}
+/**
+ * Represents a sorted chunk for multi-column sorting.
+ */
+interface MultiColumnSortedChunk {
+  /** Sorted indices (local to this chunk) */
+  indices: Uint32Array;
+  /** Values for comparison - array of columns, each in same order as indices */
+  columns: Float64Array[];
+  /** Sort directions for each column (1 = asc, -1 = desc) */
+  directions: Int8Array;
+  /** Offset of this chunk in the original array */
+  offset: number;
+}
+/**
+ * Merge multiple sorted chunks into a single sorted result.
+ * Uses a min-heap for O(n log k) time complexity.
+ *
+ * @param chunks - Array of sorted chunks to merge
+ * @param direction - Sort direction ('asc' or 'desc')
+ * @returns Uint32Array of globally sorted indices
+ */
+declare function kWayMerge(chunks: SortedChunk[], direction: SortDirection): Uint32Array;
+/**
+ * Merge multiple sorted chunks for multi-column sorting.
+ *
+ * @param chunks - Array of multi-column sorted chunks
+ * @returns Uint32Array of globally sorted indices
+ */
+declare function kWayMergeMultiColumn(chunks: MultiColumnSortedChunk[]): Uint32Array;
+/**
+ * Detect collision runs at chunk boundaries after merge.
+ * This is used for string sorting where hashes may collide across chunks.
+ *
+ * @param chunks - Original sorted chunks with their hash values
+ * @param _direction - Sort direction
+ * @returns Array of boundary collision positions [start1, end1, start2, end2, ...]
+ */
+declare function detectBoundaryCollisions(chunks: SortedChunk[], _direction: SortDirection): Uint32Array;
+//#endregion
 //#region src/data-source/client-data-source.d.ts
 interface ClientDataSourceOptions<TData> {
   /** Custom field accessor for nested properties */
   getFieldValue?: (row: TData, field: string) => CellValue;
   /** Use Web Worker for sorting large datasets (default: true) */
   useWorker?: boolean;
+  /** Options for parallel sorting (only used when useWorker is true) */
+  parallelSort?: ParallelSortOptions | false;
 }
 /**
  * Creates a client-side data source that holds all data in memory.
@@ -1380,73 +1971,6 @@ interface MutableClientDataSourceOptions<TData> {
  */
 declare function createMutableClientDataSource<TData extends Row = Row>(data: TData[], options: MutableClientDataSourceOptions<TData>): MutableDataSource<TData>;
 //#endregion
-//#region src/worker-manager.d.ts
-/**
- * Manages a Web Worker for sorting large datasets off the main thread.
- * Uses an inline worker (Blob URL) for maximum compatibility across bundlers.
- */
-declare class SortWorkerManager {
-  private worker;
-  private workerUrl;
-  private pendingRequests;
-  private nextRequestId;
-  private isTerminated;
-  /**
-   * Sort data using a Web Worker.
-   * The worker is lazily initialized on first use.
-   */
-  sortInWorker<T>(data: T[], sortModel: SortModel[]): Promise<T[]>;
-  /**
-   * Sort indices using a Web Worker with Transferable typed arrays.
-   * This is much faster than sortInWorker for large datasets because
-   * it avoids the serialization overhead of transferring full objects.
-   */
-  sortIndices(values: number[], direction: SortDirection): Promise<Uint32Array>;
-  /**
-   * Sort by multiple columns using a Web Worker with Transferable typed arrays.
-   * Each column's values are passed as a Float64Array, enabling fast multi-column sorting.
-   * @param columns Array of column values (each as number[])
-   * @param directions Array of directions for each column ("asc" or "desc")
-   */
-  sortMultiColumn(columns: number[][], directions: SortDirection[]): Promise<Uint32Array>;
-  /**
-   * Sort string values using multiple hash chunks with collision detection.
-   * Returns sorted indices and handles hash collisions using localeCompare fallback.
-   * @param hashChunks Array of hash chunk arrays (one per chunk, each chunk as Float64Array)
-   * @param direction Sort direction ("asc" or "desc")
-   * @param originalStrings Original string values for collision fallback
-   */
-  sortStringHashes(hashChunks: Float64Array[], direction: SortDirection, originalStrings: string[]): Promise<Uint32Array>;
-  /**
-   * Resolve hash collisions by re-sorting collision runs using localeCompare.
-   * collisionRuns format: [start1, end1, start2, end2, ...] where each pair
-   * defines a run of indices in the sorted array with identical hashes.
-   */
-  private resolveCollisions;
-  /**
-   * Initialize the worker using an inline Blob URL.
-   * This works without bundler-specific configuration.
-   */
-  private initializeWorker;
-  /**
-   * Terminate the worker and clean up resources.
-   */
-  terminate(): void;
-  /**
-   * Check if the worker is currently available.
-   */
-  isAvailable(): boolean;
-}
-/**
- * Get a shared SortWorkerManager instance.
- * Useful when multiple data sources should share the same worker.
- */
-declare function getSharedSortWorker(): SortWorkerManager;
-/**
- * Terminate the shared worker and release resources.
- */
-declare function terminateSharedSortWorker(): void;
-//#endregion
 //#region src/styles/variables.d.ts
 declare const variablesStyles: string;
 //#endregion
@@ -1480,79 +2004,11 @@ declare const gridStyles: string;
  */
 declare function injectStyles(): void;
 //#endregion
-//#region src/utils/positioning.d.ts
-/**
- * Calculate cumulative column positions (prefix sums)
- * Returns an array where positions[i] is the left position of column i
- * positions[columns.length] is the total width
- */
-declare function calculateColumnPositions(columns: ColumnDefinition[]): number[];
-/**
- * Get total width from column positions
- */
-declare function getTotalWidth(columnPositions: number[]): number;
-/**
- * Calculate scaled column positions when container is wider than total column widths.
- * Columns expand proportionally based on their original width ratios.
- *
- * @param columns - Column definitions with original widths
- * @param containerWidth - Available container width
- * @returns Object with positions array and widths array
- */
-declare function calculateScaledColumnPositions(columns: ColumnDefinition[], containerWidth: number): {
-  positions: number[];
-  widths: number[];
-};
-/**
- * Find column index at a given X coordinate
- */
-declare function findColumnAtX(x: number, columnPositions: number[]): number;
-//#endregion
-//#region src/utils/classNames.d.ts
-/**
- * Check if a cell is within the selection range
- */
-declare function isCellSelected(row: number, col: number, selectionRange: CellRange | null): boolean;
-/**
- * Check if a cell is the active cell
- */
-declare function isCellActive(row: number, col: number, activeCell: CellPosition | null): boolean;
-/**
- * Check if a row is within the visible range (not in overscan)
- */
-declare function isRowVisible(row: number, visibleRowRange: {
-  start: number;
-  end: number;
-} | null): boolean;
-/**
- * Check if a cell is being edited
- */
-declare function isCellEditing(row: number, col: number, editingCell: {
-  row: number;
-  col: number;
-} | null): boolean;
-/**
- * Check if a cell is in the fill preview range (vertical-only fill)
- */
-declare function isCellInFillPreview(row: number, col: number, isDraggingFill: boolean, fillSourceRange: {
-  startRow: number;
-  startCol: number;
-  endRow: number;
-  endCol: number;
-} | null, fillTarget: {
-  row: number;
-  col: number;
-} | null): boolean;
-/**
- * Build cell CSS classes based on state
- */
-declare function buildCellClasses(isActive: boolean, isSelected: boolean, isEditing: boolean, inFillPreview: boolean): string;
-//#endregion
 //#region src/types/ui-state.d.ts
-interface SlotData {
+interface SlotData<TData = Row> {
   slotId: string;
   rowIndex: number;
-  rowData: Row;
+  rowData: TData;
   translateY: number;
 }
 interface HeaderData {
@@ -1576,8 +2032,8 @@ interface FilterPopupState {
   distinctValues: CellValue[];
   currentFilter?: ColumnFilterModel;
 }
-interface GridState {
-  slots: Map<string, SlotData>;
+interface GridState<TData = Row> {
+  slots: Map<string, SlotData<TData>>;
   activeCell: CellPosition | null;
   selectionRange: CellRange | null;
   editingCell: {
@@ -1599,6 +2055,8 @@ interface GridState {
     start: number;
     end: number;
   } | null;
+  /** Currently hovered cell position (for highlighting) */
+  hoverPosition: CellPosition | null;
 }
 //#endregion
-export { type AssignSlotInstruction, type BatchInstructionListener, type CancelFillInstruction, type CellDataType, type CellPosition, type CellRange, type CellRendererParams, type CellValue, type CloseFilterPopupInstruction, type ColumnDefinition, type ColumnFilterModel, type CommitEditInstruction, type CommitFillInstruction, type ContainerBounds, type CreateSlotInstruction, type DataChangeListener, type DataErrorInstruction, type DataLoadedInstruction, type DataLoadingInstruction, type DataSource, type DataSourceRequest, type DataSourceResponse, type DateFilterCondition, type DateFilterOperator, type DestroySlotInstruction, type Direction, type DragMoveResult, type DragState, EditManager, type EditManagerOptions, type EditRendererParams, type EditState, type FillHandleState, FillManager, type FilterCombination, type FilterCondition, type FilterModel, type FilterPopupState, GridCore, type GridCoreOptions, type GridInstruction, type GridState, type HeaderData, type HeaderRendererParams, IndexedDataStore, type IndexedDataStoreOptions, InputHandler, type InputHandlerDeps, type InputResult, type InstructionListener, type KeyEventData, type KeyboardResult, type MoveSlotInstruction, type MutableClientDataSourceOptions, type MutableDataSource, type NumberFilterCondition, type NumberFilterOperator, type OpenFilterPopupInstruction, type PointerEventData, type Row, type RowId, type RowSortCache, type RowsAddedInstruction, type RowsRemovedInstruction, type RowsUpdatedInstruction, SelectionManager, type SelectionState, type SetActiveCellInstruction, type SetContentSizeInstruction, type SetSelectionRangeInstruction, type SlotData, type BatchInstructionListener$1 as SlotPoolBatchListener, SlotPoolManager, type SlotPoolManagerOptions, type SlotState, type SortDirection, type SortModel, SortWorkerManager, type StartEditInstruction, type StartFillInstruction, type StopEditInstruction, type TextFilterCondition, type TextFilterOperator, type Transaction, TransactionManager, type TransactionManagerOptions, type TransactionProcessedInstruction, type TransactionResult, type UpdateFillInstruction, type UpdateHeaderInstruction, buildCellClasses, calculateColumnPositions, calculateScaledColumnPositions, cellStyles, compareValues, computeValueHash, containerStyles, createClientDataSource, createDataSourceFromArray, createMutableClientDataSource, createServerDataSource, evaluateColumnFilter, evaluateDateCondition, evaluateNumberCondition, evaluateTextCondition, filtersStyles, findColumnAtX, getFieldValue, getSharedSortWorker, getTotalWidth, gridStyles, headerStyles, injectStyles, isCellActive, isCellEditing, isCellInFillPreview, isCellSelected, isRowVisible, isSameDay, rowPassesFilter, scrollbarStyles, setFieldValue, statesStyles, stringToSortableNumber, terminateSharedSortWorker, variablesStyles };
+export { type AssignSlotInstruction, type BatchInstructionListener, type CancelFillInstruction, type CellDataType, type CellPosition, type CellRange, type CellRendererParams, type CellValue, type CloseFilterPopupInstruction, type ColumnDefinition, type ColumnFilterModel, type CommitEditInstruction, type CommitFillInstruction, type ContainerBounds, type CreateSlotInstruction, type DataChangeListener, type DataErrorInstruction, type DataLoadedInstruction, type DataLoadingInstruction, type DataSource, type DataSourceRequest, type DataSourceResponse, type DateFilterCondition, type DateFilterOperator, type DestroySlotInstruction, type Direction, type DragMoveResult, type DragState, EditManager, type EditManagerOptions, type EditRendererParams, type EditState, type FillHandleState, FillManager, type FilterCombination, type FilterCondition, type FilterModel, type FilterPopupState, GridCore, type GridCoreOptions, type GridInstruction, type GridState, type HeaderData, type HeaderRendererParams, type HighlightContext, HighlightManager, type HighlightingOptions, IndexedDataStore, type IndexedDataStoreOptions, InputHandler, type InputHandlerDeps, type InputResult, type InstructionListener, type KeyEventData, type KeyboardResult, type MoveSlotInstruction, type MultiColumnSortedChunk, type MutableClientDataSourceOptions, type MutableDataSource, type NumberFilterCondition, type NumberFilterOperator, type OpenFilterPopupInstruction, ParallelSortManager, type ParallelSortOptions, type PointerEventData, type Row, type RowId, type RowSortCache, type RowsAddedInstruction, type RowsRemovedInstruction, type RowsUpdatedInstruction, SelectionManager, type SelectionState, type SetActiveCellInstruction, type SetContentSizeInstruction, type SetHoverPositionInstruction, type SetSelectionRangeInstruction, type SlotData, type BatchInstructionListener$1 as SlotPoolBatchListener, SlotPoolManager, type SlotPoolManagerOptions, type SlotState, type SortDirection, type SortModel, type SortedChunk, type StartEditInstruction, type StartFillInstruction, type StopEditInstruction, type TextFilterCondition, type TextFilterOperator, type Transaction, TransactionManager, type TransactionManagerOptions, type TransactionProcessedInstruction, type TransactionResult, type UpdateFillInstruction, type UpdateHeaderInstruction, WorkerPool, type WorkerPoolOptions, buildCellClasses, calculateColumnPositions, calculateScaledColumnPositions, cellStyles, compareValues, computeValueHash, containerStyles, createClientDataSource, createDataSourceFromArray, createMutableClientDataSource, createServerDataSource, detectBoundaryCollisions, evaluateColumnFilter, evaluateDateCondition, evaluateNumberCondition, evaluateTextCondition, filtersStyles, findColumnAtX, getFieldValue, getTotalWidth, gridStyles, headerStyles, injectStyles, isCellActive, isCellEditing, isCellInFillPreview, isCellSelected, isColumnInSelectionRange, isRowInSelectionRange, isRowVisible, isSameDay, kWayMerge, kWayMergeMultiColumn, rowPassesFilter, scrollbarStyles, setFieldValue, statesStyles, stringToSortableNumber, variablesStyles };