@gp-grid/core 0.7.2

package/dist/index.d.ts

@@ -0,0 +1,2067 @@
+//#region src/types/basic.d.ts
+/** Cell data type primitive types */
+type CellDataType = "text" | "number" | "boolean" | "date" | "dateString" | "dateTime" | "dateTimeString" | "object";
+/** Cell value type */
+type CellValue = string | number | boolean | Date | object | null;
+/** Row type */
+type Row = unknown;
+/** Row ID type for transaction operations */
+type RowId = string | number;
+/** Sort direction type */
+type SortDirection = "asc" | "desc";
+/** Sort model type */
+type SortModel = {
+  colId: string;
+  direction: SortDirection;
+};
+/** Cell position */
+interface CellPosition {
+  row: number;
+  col: number;
+}
+/** Cell range */
+interface CellRange {
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+}
+/** Selection state */
+interface SelectionState {
+  /** Active cell position */
+  activeCell: CellPosition | null;
+  /** Selection range */
+  range: CellRange | null;
+  /** Anchor cell for shift-extend selection */
+  anchor: CellPosition | null;
+  /** Whether selection mode is active (ctrl held) */
+  selectionMode: boolean;
+}
+/** Edit state */
+interface EditState {
+  /** Row index */
+  row: number;
+  /** Column index */
+  col: number;
+  /** Initial value */
+  initialValue: CellValue;
+  /** Current value */
+  currentValue: CellValue;
+}
+/** Fill handle state */
+interface FillHandleState {
+  /** Source range */
+  sourceRange: CellRange;
+  /** Target row */
+  targetRow: number;
+  /** Target column */
+  targetCol: number;
+}
+/** The slot is the virtualized row, this represents the state of the slot */
+interface SlotState {
+  /** Slot ID */
+  slotId: string;
+  /** Row index */
+  rowIndex: number;
+  /** Row data */
+  rowData: Row;
+  /** Translate Y position of the slot, we use translateY to optimize the rendering of the slots (Relies on the GP) */
+  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 {
+  field: string;
+  colId?: string;
+  cellDataType: CellDataType;
+  width: number;
+  headerName?: string;
+  editable?: boolean;
+  /** Whether column is sortable. Default: true when sortingEnabled */
+  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
+/** Text filter operators */
+type TextFilterOperator = "contains" | "notContains" | "equals" | "notEquals" | "startsWith" | "endsWith" | "blank" | "notBlank";
+/** Number filter operators (symbols for display) */
+type NumberFilterOperator = "=" | "!=" | ">" | "<" | ">=" | "<=" | "between" | "blank" | "notBlank";
+/** Date filter operators */
+type DateFilterOperator = "=" | "!=" | ">" | "<" | "between" | "blank" | "notBlank";
+/** Filter combination mode */
+type FilterCombination = "and" | "or";
+/** Text filter condition */
+interface TextFilterCondition {
+  type: "text";
+  operator: TextFilterOperator;
+  value?: string;
+  /** Selected distinct values for checkbox-style filtering */
+  selectedValues?: Set<string>;
+  /** Include blank values */
+  includeBlank?: boolean;
+  /** Operator connecting this condition to the next. Defaults to ColumnFilterModel.combination */
+  nextOperator?: FilterCombination;
+}
+/** Number filter condition */
+interface NumberFilterCondition {
+  type: "number";
+  operator: NumberFilterOperator;
+  value?: number;
+  /** Second value for "between" operator */
+  valueTo?: number;
+  /** Operator connecting this condition to the next. Defaults to ColumnFilterModel.combination */
+  nextOperator?: FilterCombination;
+}
+/** Date filter condition */
+interface DateFilterCondition {
+  type: "date";
+  operator: DateFilterOperator;
+  value?: Date | string;
+  /** Second value for "between" operator */
+  valueTo?: Date | string;
+  /** Operator connecting this condition to the next. Defaults to ColumnFilterModel.combination */
+  nextOperator?: FilterCombination;
+}
+/** Union of filter condition types */
+type FilterCondition = TextFilterCondition | NumberFilterCondition | DateFilterCondition;
+/** Column filter model with multiple conditions */
+interface ColumnFilterModel {
+  conditions: FilterCondition[];
+  combination: FilterCombination;
+}
+/** Filter model type - maps column ID to filter */
+type FilterModel = Record<string, ColumnFilterModel>;
+//#endregion
+//#region src/types/data-source.d.ts
+/** Data source request */
+interface DataSourceRequest {
+  /** Pagination */
+  pagination: {
+    /** Page index */
+    pageIndex: number;
+    /** Page size */
+    pageSize: number;
+  };
+  /** Sort */
+  sort?: SortModel[];
+  /** Filter */
+  filter?: FilterModel;
+}
+/** Data source response */
+interface DataSourceResponse<TData = Row> {
+  /** Rows */
+  rows: TData[];
+  /** Total rows */
+  totalRows: number;
+}
+/** Data source interface */
+interface DataSource<TData = Row> {
+  fetch(request: DataSourceRequest): Promise<DataSourceResponse<TData>>;
+  /** Optional cleanup method to release resources */
+  destroy?: () => void;
+}
+//#endregion
+//#region src/types/instructions.d.ts
+/** Create slot instruction */
+interface CreateSlotInstruction {
+  type: "CREATE_SLOT";
+  slotId: string;
+}
+/** Destroy slot instruction */
+interface DestroySlotInstruction {
+  type: "DESTROY_SLOT";
+  slotId: string;
+}
+/** Assign slot instruction */
+interface AssignSlotInstruction {
+  type: "ASSIGN_SLOT";
+  slotId: string;
+  rowIndex: number;
+  rowData: Row;
+}
+/** Move slot instruction */
+interface MoveSlotInstruction {
+  type: "MOVE_SLOT";
+  slotId: string;
+  translateY: number;
+}
+/** Set active cell instruction */
+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";
+  range: CellRange | null;
+}
+/** Update visible range instruction - emitted when selection moves outside visible viewport */
+interface UpdateVisibleRangeInstruction {
+  type: "UPDATE_VISIBLE_RANGE";
+  start: number;
+  end: number;
+}
+/** Start edit instruction */
+interface StartEditInstruction {
+  type: "START_EDIT";
+  row: number;
+  col: number;
+  initialValue: CellValue;
+}
+/** Stop edit instruction */
+interface StopEditInstruction {
+  type: "STOP_EDIT";
+}
+/** Commit edit instruction */
+interface CommitEditInstruction {
+  type: "COMMIT_EDIT";
+  row: number;
+  col: number;
+  value: CellValue;
+}
+/** Set content size instruction */
+interface SetContentSizeInstruction {
+  type: "SET_CONTENT_SIZE";
+  width: number;
+  height: number;
+  viewportWidth: number;
+}
+/** Update header instruction */
+interface UpdateHeaderInstruction {
+  type: "UPDATE_HEADER";
+  colIndex: number;
+  column: ColumnDefinition;
+  sortDirection?: SortDirection;
+  sortIndex?: number;
+  /** Whether column is sortable */
+  sortable: boolean;
+  /** Whether column is filterable */
+  filterable: boolean;
+  /** Whether column has an active filter */
+  hasFilter: boolean;
+}
+/** Open filter popup instruction */
+interface OpenFilterPopupInstruction {
+  type: "OPEN_FILTER_POPUP";
+  colIndex: number;
+  column: ColumnDefinition;
+  anchorRect: {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+  };
+  distinctValues: CellValue[];
+  currentFilter?: ColumnFilterModel;
+}
+/** Close filter popup instruction */
+interface CloseFilterPopupInstruction {
+  type: "CLOSE_FILTER_POPUP";
+}
+/** Start fill instruction */
+interface StartFillInstruction {
+  type: "START_FILL";
+  sourceRange: CellRange;
+}
+/** Update fill instruction */
+interface UpdateFillInstruction {
+  type: "UPDATE_FILL";
+  targetRow: number;
+  targetCol: number;
+}
+/** Commit fill instruction */
+interface CommitFillInstruction {
+  type: "COMMIT_FILL";
+  filledCells: Array<{
+    row: number;
+    col: number;
+    value: CellValue;
+  }>;
+}
+/** Cancel fill instruction */
+interface CancelFillInstruction {
+  type: "CANCEL_FILL";
+}
+/** Data loading instruction */
+interface DataLoadingInstruction {
+  type: "DATA_LOADING";
+}
+/** Data loaded instruction */
+interface DataLoadedInstruction {
+  type: "DATA_LOADED";
+  totalRows: number;
+}
+/** Data error instruction */
+interface DataErrorInstruction {
+  type: "DATA_ERROR";
+  error: string;
+}
+/** Rows added instruction */
+interface RowsAddedInstruction {
+  type: "ROWS_ADDED";
+  indices: number[];
+  count: number;
+  totalRows: number;
+}
+/** Rows removed instruction */
+interface RowsRemovedInstruction {
+  type: "ROWS_REMOVED";
+  indices: number[];
+  totalRows: number;
+}
+/** Rows updated instruction */
+interface RowsUpdatedInstruction {
+  type: "ROWS_UPDATED";
+  indices: number[];
+}
+/** Transaction processed instruction */
+interface TransactionProcessedInstruction {
+  type: "TRANSACTION_PROCESSED";
+  added: number;
+  removed: number;
+  updated: number;
+}
+/** Union type of all instructions */
+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
+/** Fill handle */ | StartFillInstruction | UpdateFillInstruction | CommitFillInstruction | CancelFillInstruction
+/** Data */ | DataLoadingInstruction | DataLoadedInstruction | DataErrorInstruction
+/** Transactions */ | RowsAddedInstruction | RowsRemovedInstruction | RowsUpdatedInstruction | TransactionProcessedInstruction;
+/** Instruction listener: Single instruction Listener that receives a single instruction, used by frameworks to update their state */
+type InstructionListener = (instruction: GridInstruction) => void;
+/** Batch instruction listener: Batch instruction Listener that receives an array of instructions, used by frameworks to update their state */
+type BatchInstructionListener = (instructions: GridInstruction[]) => void;
+//#endregion
+//#region src/types/renderers.d.ts
+/** Cell renderer params */
+interface CellRendererParams<TData extends Row = Row> {
+  /** Cell value */
+  value: CellValue;
+  /** Row data */
+  rowData: TData;
+  /** Column definition */
+  column: ColumnDefinition;
+  /** Row index */
+  rowIndex: number;
+  /** Column index */
+  colIndex: number;
+  /** Is active cell */
+  isActive: boolean;
+  /** Is selected cell */
+  isSelected: boolean;
+  /** Is editing cell */
+  isEditing: boolean;
+}
+/** Edit renderer params */
+interface EditRendererParams<TData extends Row = Row> extends CellRendererParams<TData> {
+  /** Initial value */
+  initialValue: CellValue;
+  /** On value change */
+  onValueChange: (newValue: CellValue) => void;
+  /** On commit */
+  onCommit: () => void;
+  /** On cancel */
+  onCancel: () => void;
+}
+/** Header renderer params */
+interface HeaderRendererParams {
+  /** Column definition */
+  column: ColumnDefinition;
+  /** Column index */
+  colIndex: number;
+  /** Sort direction */
+  sortDirection?: SortDirection;
+  /** Sort index */
+  sortIndex?: number;
+  /** Whether column is sortable */
+  sortable: boolean;
+  /** Whether column is filterable */
+  filterable: boolean;
+  /** Whether column has an active filter */
+  hasFilter: boolean;
+  /** On sort */
+  onSort: (direction: SortDirection | null, addToExisting: boolean) => void;
+  /** On filter click */
+  onFilterClick: () => void;
+}
+//#endregion
+//#region src/types/options.d.ts
+/** Grid core options */
+interface GridCoreOptions<TData = Row> {
+  /** Column definitions */
+  columns: ColumnDefinition[];
+  /** Data source */
+  dataSource: DataSource<TData>;
+  /** Row height */
+  rowHeight: number;
+  /** Header height: Default to row height */
+  headerHeight?: number;
+  /** Overscan: How many rows to render outside the viewport */
+  overscan?: number;
+  /** Enable/disable sorting globally. Default: true */
+  sortingEnabled?: boolean;
+  /** Debounce time for transactions in ms. Default 50. Set to 0 for sync. */
+  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
+/** Framework-agnostic pointer/mouse event data */
+interface PointerEventData {
+  /** X coordinate relative to viewport */
+  clientX: number;
+  /** Y coordinate relative to viewport */
+  clientY: number;
+  /** Mouse button (0 = left, 1 = middle, 2 = right) */
+  button: number;
+  /** Whether Shift key is pressed */
+  shiftKey: boolean;
+  /** Whether Ctrl key is pressed */
+  ctrlKey: boolean;
+  /** Whether Meta/Command key is pressed */
+  metaKey: boolean;
+}
+/** Framework-agnostic keyboard event data */
+interface KeyEventData {
+  /** Key value (e.g., 'Enter', 'ArrowUp', 'a') */
+  key: string;
+  /** Whether Shift key is pressed */
+  shiftKey: boolean;
+  /** Whether Ctrl key is pressed */
+  ctrlKey: boolean;
+  /** Whether Meta/Command key is pressed */
+  metaKey: boolean;
+}
+/** Container bounds and scroll position */
+interface ContainerBounds {
+  /** Top position relative to viewport */
+  top: number;
+  /** Left position relative to viewport */
+  left: number;
+  /** Container width */
+  width: number;
+  /** Container height */
+  height: number;
+  /** Current scroll top position */
+  scrollTop: number;
+  /** Current scroll left position */
+  scrollLeft: number;
+}
+/** Result from mouse/pointer input handlers */
+interface InputResult {
+  /** Whether to call preventDefault() on the event */
+  preventDefault: boolean;
+  /** Whether to call stopPropagation() on the event */
+  stopPropagation: boolean;
+  /** Whether framework should focus the container element */
+  focusContainer?: boolean;
+  /** Type of drag operation to start (framework manages global listeners) */
+  startDrag?: "selection" | "fill";
+}
+/** Result from keyboard input handler */
+interface KeyboardResult {
+  /** Whether to call preventDefault() on the event */
+  preventDefault: boolean;
+  /** Cell to scroll into view (if navigation occurred) */
+  scrollToCell?: CellPosition;
+}
+/** Result from drag move handler */
+interface DragMoveResult {
+  /** Target row index */
+  targetRow: number;
+  /** Target column index */
+  targetCol: number;
+  /** Auto-scroll deltas (null if no auto-scroll needed) */
+  autoScroll: {
+    dx: number;
+    dy: number;
+  } | null;
+}
+/** Options for InputHandler constructor */
+interface InputHandlerDeps {
+  /** Get header height */
+  getHeaderHeight: () => number;
+  /** Get row height */
+  getRowHeight: () => number;
+  /** Get column positions array (indexed by visible column) */
+  getColumnPositions: () => number[];
+  /** 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 {
+  /** Whether any drag operation is active */
+  isDragging: boolean;
+  /** Type of active drag operation */
+  dragType: "selection" | "fill" | null;
+  /** Source range for fill operations */
+  fillSourceRange: CellRange | null;
+  /** Current fill target position */
+  fillTarget: {
+    row: number;
+    col: number;
+  } | 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 {
+  getRowCount: () => number;
+  getColumnCount: () => number;
+  getCellValue: (row: number, col: number) => CellValue;
+  getRowData: (row: number) => Row | undefined;
+  getColumn: (col: number) => ColumnDefinition | undefined;
+}
+/**
+ * Manages Excel-style cell selection, keyboard navigation, and clipboard operations.
+ */
+declare class SelectionManager {
+  private state;
+  private options;
+  private emitter;
+  onInstruction: (listener: InstructionListener) => () => void;
+  private emit;
+  constructor(options: SelectionManagerOptions);
+  getState(): SelectionState;
+  getActiveCell(): CellPosition | null;
+  getSelectionRange(): CellRange | null;
+  isSelected(row: number, col: number): boolean;
+  isActiveCell(row: number, col: number): boolean;
+  /**
+   * Start a selection at the given cell.
+   * @param cell - The cell to select
+   * @param opts.shift - Extend selection from anchor (range select)
+   * @param opts.ctrl - Toggle selection mode
+   */
+  startSelection(cell: CellPosition, opts?: {
+    shift?: boolean;
+    ctrl?: boolean;
+  }): void;
+  /**
+   * Move focus in a direction, optionally extending the selection.
+   */
+  moveFocus(direction: Direction, extend?: boolean): void;
+  /**
+   * Select all cells in the grid (Ctrl+A).
+   */
+  selectAll(): void;
+  /**
+   * Clear the current selection.
+   */
+  clearSelection(): void;
+  /**
+   * Set the active cell directly.
+   */
+  setActiveCell(row: number, col: number): void;
+  /**
+   * Set the selection range directly.
+   */
+  setSelectionRange(range: CellRange): void;
+  /**
+   * Get the data from the currently selected cells as a 2D array.
+   */
+  getSelectedData(): CellValue[][];
+  /**
+   * Copy the selected data to the clipboard (Ctrl+C).
+   */
+  copySelectionToClipboard(): Promise<void>;
+  /**
+   * Clean up resources for garbage collection.
+   */
+  destroy(): void;
+  private clampPosition;
+}
+//#endregion
+//#region src/fill.d.ts
+interface FillManagerOptions {
+  getRowCount: () => number;
+  getColumnCount: () => number;
+  getCellValue: (row: number, col: number) => CellValue;
+  getColumn: (col: number) => ColumnDefinition | undefined;
+  setCellValue: (row: number, col: number, value: CellValue) => void;
+}
+/**
+ * Manages fill handle operations including pattern detection and auto-fill.
+ */
+declare class FillManager {
+  private state;
+  private options;
+  private emitter;
+  onInstruction: (listener: InstructionListener) => () => void;
+  private emit;
+  constructor(options: FillManagerOptions);
+  getState(): FillHandleState | null;
+  isActive(): boolean;
+  /**
+   * Start a fill drag operation from a source range.
+   */
+  startFillDrag(sourceRange: CellRange): void;
+  /**
+   * Update the fill drag target position.
+   */
+  updateFillDrag(targetRow: number, targetCol: number): void;
+  /**
+   * Commit the fill operation - apply pattern to target cells.
+   */
+  commitFillDrag(): void;
+  /**
+   * Cancel the fill operation.
+   */
+  cancelFillDrag(): void;
+  /**
+   * Clean up resources for garbage collection.
+   */
+  destroy(): void;
+  /**
+   * Calculate the values to fill based on source pattern.
+   */
+  private calculateFilledCells;
+  private getSourceColumnValues;
+  private detectPattern;
+  private applyPattern;
+}
+//#endregion
+//#region src/input-handler.d.ts
+declare class InputHandler<TData extends Row = Row> {
+  private core;
+  private deps;
+  private isDraggingSelection;
+  private isDraggingFill;
+  private fillSourceRange;
+  private fillTarget;
+  constructor(core: GridCore<TData>, deps: InputHandlerDeps);
+  /**
+   * Update dependencies (called when options change)
+   */
+  updateDeps(deps: Partial<InputHandlerDeps>): void;
+  /**
+   * Get current drag state for UI rendering
+   */
+  getDragState(): DragState;
+  /**
+   * Handle cell mouse down event
+   */
+  handleCellMouseDown(rowIndex: number, colIndex: number, event: PointerEventData): InputResult;
+  /**
+   * 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
+   */
+  handleFillHandleMouseDown(activeCell: CellPosition | null, selectionRange: CellRange | null, _event: PointerEventData): InputResult;
+  /**
+   * Handle header click event (cycle sort direction)
+   */
+  handleHeaderClick(colId: string, addToExisting: boolean): void;
+  /**
+   * Start selection drag (called by framework after handleCellMouseDown returns startDrag: 'selection')
+   */
+  startSelectionDrag(): void;
+  /**
+   * Handle drag move event (selection or fill)
+   */
+  handleDragMove(event: PointerEventData, bounds: ContainerBounds): DragMoveResult | null;
+  /**
+   * Handle drag end event
+   */
+  handleDragEnd(): void;
+  /**
+   * Handle wheel event with dampening for large datasets
+   * Returns scroll deltas or null if no dampening needed
+   */
+  handleWheel(deltaY: number, deltaX: number, dampening: number): {
+    dy: number;
+    dx: number;
+  } | null;
+  /**
+   * Handle keyboard event
+   */
+  handleKeyDown(event: KeyEventData, activeCell: CellPosition | null, editingCell: {
+    row: number;
+    col: number;
+  } | null, filterPopupOpen: boolean): KeyboardResult;
+  /**
+   * 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;
+  /**
+   * Update highlighting options. Clears all caches.
+   */
+  updateOptions(options: HighlightingOptions<TData>): void;
+  /**
+   * 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;
+  private dataSource;
+  private rowHeight;
+  private headerHeight;
+  private overscan;
+  private sortingEnabled;
+  private scrollTop;
+  private scrollLeft;
+  private viewportWidth;
+  private viewportHeight;
+  private cachedRows;
+  private totalRows;
+  private currentPageIndex;
+  private pageSize;
+  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 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>);
+  /**
+   * Initialize the grid and load initial data.
+   */
+  initialize(): Promise<void>;
+  /**
+   * Update viewport measurements and sync slots.
+   * When scroll virtualization is active, maps the DOM scroll position to the actual row position.
+   */
+  setViewport(scrollTop: number, scrollLeft: number, width: number, height: number): void;
+  private fetchData;
+  private fetchAllData;
+  setSort(colId: string, direction: SortDirection | null, addToExisting?: boolean): Promise<void>;
+  setFilter(colId: string, filter: ColumnFilterModel | string | null): Promise<void>;
+  hasActiveFilter(colId: string): boolean;
+  isColumnSortable(colIndex: number): boolean;
+  isColumnFilterable(colIndex: number): boolean;
+  getDistinctValuesForColumn(colId: string, maxValues?: number): CellValue[];
+  openFilterPopup(colIndex: number, anchorRect: {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+  }): void;
+  closeFilterPopup(): void;
+  getSortModel(): SortModel[];
+  getFilterModel(): FilterModel;
+  startEdit(row: number, col: number): void;
+  updateEditValue(value: CellValue): void;
+  commitEdit(): void;
+  cancelEdit(): void;
+  getEditState(): EditState | null;
+  getCellValue(row: number, col: number): CellValue;
+  setCellValue(row: number, col: number, value: CellValue): void;
+  private computeColumnPositions;
+  private emitContentSize;
+  private emitHeaders;
+  getColumns(): ColumnDefinition[];
+  getColumnPositions(): number[];
+  getRowCount(): number;
+  getRowHeight(): number;
+  getHeaderHeight(): number;
+  getTotalWidth(): number;
+  getTotalHeight(): number;
+  /**
+   * Check if scroll scaling is active (large datasets exceeding browser scroll limits).
+   * When scaling is active, scrollRatio < 1 and scroll positions are compressed.
+   */
+  isScalingActive(): boolean;
+  /**
+   * Get the natural (uncapped) content height.
+   * Useful for debugging or displaying actual content size.
+   */
+  getNaturalHeight(): number;
+  /**
+   * Get the scroll ratio used for scroll virtualization.
+   * Returns 1 when no virtualization is needed, < 1 when content exceeds browser limits.
+   */
+  getScrollRatio(): number;
+  /**
+   * Get the visible row range (excluding overscan).
+   * Returns the first and last row indices that are actually visible in the viewport.
+   * Includes partially visible rows to avoid false positives when clicking on edge rows.
+   */
+  getVisibleRowRange(): {
+    start: number;
+    end: number;
+  };
+  /**
+   * Get the scroll position needed to bring a row into view.
+   * Accounts for scroll scaling when active.
+   */
+  getScrollTopForRow(rowIndex: number): number;
+  /**
+   * Get the row index at a given viewport Y position.
+   * Accounts for scroll scaling when active.
+   * @param viewportY Y position in viewport (physical pixels below header, NOT including scroll)
+   * @param virtualScrollTop Current scroll position from container.scrollTop (virtual/scaled)
+   */
+  getRowIndexAtDisplayY(viewportY: number, virtualScrollTop: number): number;
+  getRowData(rowIndex: number): TData | undefined;
+  /**
+   * Refresh data from the data source.
+   */
+  refresh(): Promise<void>;
+  /**
+   * Refresh slot display without refetching data.
+   * 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.
+   */
+  setDataSource(dataSource: DataSource<TData>): Promise<void>;
+  /**
+   * 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
+interface SlotPoolManagerOptions {
+  /** Get current row height */
+  getRowHeight: () => number;
+  /** Get current header height */
+  getHeaderHeight: () => number;
+  /** Get overscan count */
+  getOverscan: () => number;
+  /** Get current scroll top position (natural, not virtual) */
+  getScrollTop: () => number;
+  /** Get viewport height */
+  getViewportHeight: () => number;
+  /** Get total row count */
+  getTotalRows: () => number;
+  /** Get scroll ratio for virtualization (1 = no virtualization) */
+  getScrollRatio: () => number;
+  /** Get virtual content height */
+  getVirtualContentHeight: () => number;
+  /** Get row data by index */
+  getRowData: (rowIndex: number) => Row | undefined;
+}
+/**
+ * Manages the slot pool for virtual scrolling.
+ * Handles slot creation, recycling, positioning, and destruction.
+ */
+declare class SlotPoolManager {
+  private state;
+  private options;
+  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.
+   */
+  getSlotForRow(rowIndex: number): string | undefined;
+  /**
+   * Get all current slots.
+   */
+  getSlots(): Map<string, SlotState>;
+  /**
+   * Synchronize slots with current viewport position.
+   * This implements the slot recycling strategy.
+   */
+  syncSlots(): void;
+  /**
+   * Destroy all slots.
+   */
+  destroyAllSlots(): void;
+  /**
+   * Clean up resources for garbage collection.
+   * This method is idempotent - safe to call multiple times.
+   */
+  destroy(): void;
+  /**
+   * Refresh all slot data without changing which rows are displayed.
+   * Used after filtering/sorting when data changes.
+   */
+  refreshAllSlots(): void;
+  /**
+   * Update a single slot's data.
+   */
+  updateSlot(rowIndex: number): void;
+  /**
+   * Calculate the translateY position for a row.
+   * Handles scroll virtualization for very large datasets.
+   */
+  private getRowTranslateY;
+}
+//#endregion
+//#region src/edit-manager.d.ts
+interface EditManagerOptions {
+  /** Get column definition by index */
+  getColumn: (colIndex: number) => ColumnDefinition | undefined;
+  /** Get cell value */
+  getCellValue: (row: number, col: number) => CellValue;
+  /** Set cell value */
+  setCellValue: (row: number, col: number, value: CellValue) => void;
+  /** Callback when edit is committed (to update slot display) */
+  onCommit?: (row: number, col: number, value: CellValue) => void;
+}
+/**
+ * Manages cell editing state and operations.
+ */
+declare class EditManager {
+  private editState;
+  private options;
+  private emitter;
+  onInstruction: (listener: InstructionListener) => () => void;
+  private emit;
+  constructor(options: EditManagerOptions);
+  /**
+   * Get the current edit state.
+   */
+  getState(): EditState | null;
+  /**
+   * Check if currently editing.
+   */
+  isEditing(): boolean;
+  /**
+   * Check if a specific cell is being edited.
+   */
+  isEditingCell(row: number, col: number): boolean;
+  /**
+   * Start editing a cell.
+   * Returns true if edit was started, false if cell is not editable.
+   */
+  startEdit(row: number, col: number): boolean;
+  /**
+   * Update the current edit value.
+   */
+  updateValue(value: CellValue): void;
+  /**
+   * Commit the current edit.
+   * Saves the value and closes the editor.
+   */
+  commit(): void;
+  /**
+   * Cancel the current edit.
+   * Discards changes and closes the editor.
+   */
+  cancel(): void;
+  /**
+   * Clean up resources for garbage collection.
+   */
+  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.
+ * Sorting and filtering are performed client-side.
+ * For large datasets, sorting is automatically offloaded to a Web Worker.
+ */
+declare function createClientDataSource<TData extends Row = Row>(data: TData[], options?: ClientDataSourceOptions<TData>): DataSource<TData>;
+/**
+ * Convenience function to create a data source from an array.
+ * This provides backwards compatibility with the old `rowData` prop.
+ */
+declare function createDataSourceFromArray<TData extends Row = Row>(data: TData[]): DataSource<TData>;
+//#endregion
+//#region src/data-source/server-data-source.d.ts
+type ServerFetchFunction<TData> = (request: DataSourceRequest) => Promise<DataSourceResponse<TData>>;
+/**
+ * Creates a server-side data source that delegates all operations to the server.
+ * The fetch function receives sort/filter/pagination params to pass to the API.
+ */
+declare function createServerDataSource<TData extends Row = Row>(fetchFn: ServerFetchFunction<TData>): DataSource<TData>;
+//#endregion
+//#region src/indexed-data-store/indexed-data-store.d.ts
+interface IndexedDataStoreOptions<TData> {
+  /** Function to extract unique ID from row. Required for mutations. */
+  getRowId: (row: TData) => RowId;
+  /** Custom field accessor for nested properties */
+  getFieldValue?: (row: TData, field: string) => CellValue;
+}
+/** Hash cache for a single row */
+interface RowSortCache {
+  /** Map: sortModelHash -> computed hashes for that sort configuration */
+  hashes: Map<string, number[]>;
+}
+/**
+ * Efficient data structure for incremental operations on grid data.
+ * Supports:
+ * - O(1) lookup by row ID
+ * - O(log n) binary insertion to maintain sort order
+ * - Filter state caching with distinct values
+ * - Hash caching for fast sorted comparisons
+ */
+declare class IndexedDataStore<TData extends Row = Row> {
+  private rows;
+  private rowById;
+  private sortedIndices;
+  private sortModel;
+  private sortModelHash;
+  private filterModel;
+  private filteredIndices;
+  private distinctValues;
+  private rowSortCache;
+  private options;
+  constructor(initialData: TData[] | undefined, options: IndexedDataStoreOptions<TData>);
+  /**
+   * Clear all data and internal caches.
+   * Used for proper memory cleanup when the store is no longer needed.
+   */
+  clear(): void;
+  /**
+   * Replace all data (used for initial load or full refresh).
+   */
+  setData(data: TData[]): void;
+  /**
+   * Query data with sorting, filtering, and pagination.
+   * Compatible with DataSource.fetch() interface.
+   */
+  query(request: DataSourceRequest): DataSourceResponse<TData>;
+  /**
+   * Get row by ID.
+   */
+  getRowById(id: RowId): TData | undefined;
+  /**
+   * Get row by index.
+   */
+  getRowByIndex(index: number): TData | undefined;
+  /**
+   * Get total row count (unfiltered).
+   */
+  getTotalRowCount(): number;
+  /**
+   * Get visible row count (after filtering).
+   */
+  getVisibleRowCount(): number;
+  /**
+   * Get distinct values for a field (for filter UI).
+   */
+  getDistinctValues(field: string): CellValue[];
+  /**
+   * Add rows to the store.
+   * Rows are inserted at their correct sorted position.
+   */
+  addRows(rows: TData[]): void;
+  /**
+   * Add a single row.
+   */
+  private addRow;
+  /**
+   * Remove rows by ID.
+   */
+  removeRows(ids: RowId[]): void;
+  /**
+   * Remove a single row by index.
+   */
+  private removeRowByIndex;
+  /**
+   * Update indices after a row removal.
+   */
+  private reindexAfterRemoval;
+  /**
+   * Update a cell value.
+   */
+  updateCell(id: RowId, field: string, value: CellValue): void;
+  /**
+   * Update multiple fields on a row.
+   */
+  updateRow(id: RowId, data: Partial<TData>): void;
+  /**
+   * Set the sort model. Triggers full re-sort if model changed.
+   */
+  setSortModel(model: SortModel[]): void;
+  /**
+   * Get current sort model.
+   */
+  getSortModel(): SortModel[];
+  /**
+   * Set the filter model.
+   */
+  setFilterModel(model: FilterModel): void;
+  /**
+   * Get current filter model.
+   */
+  getFilterModel(): FilterModel;
+  /**
+   * Rebuild sorted indices (full re-sort).
+   */
+  private rebuildSortedIndices;
+  /**
+   * Rebuild hash cache for all rows.
+   */
+  private rebuildHashCache;
+  /**
+   * Compute and cache sort hashes for a row.
+   */
+  private computeRowHashes;
+  /**
+   * Compare two rows using cached hashes.
+   */
+  private compareRows;
+  /**
+   * Binary search for insertion position in sortedIndices.
+   */
+  private binarySearchInsertPosition;
+  /**
+   * Rebuild filtered indices.
+   */
+  private rebuildFilteredIndices;
+  /**
+   * Check if a row passes the current filter.
+   */
+  private rowPassesFilter;
+  /**
+   * Get visible indices (filtered + sorted).
+   */
+  private getVisibleIndices;
+  /**
+   * Rebuild distinct values cache for all fields.
+   */
+  private rebuildDistinctValues;
+  /**
+   * Update distinct values when a row is added or removed.
+   */
+  private updateDistinctValuesForRow;
+  /**
+   * Update distinct value for a specific field when cell value changes.
+   */
+  private updateDistinctValueForField;
+}
+//#endregion
+//#region src/indexed-data-store/field-helpers.d.ts
+/**
+ * Default field value accessor supporting dot notation.
+ * @example
+ * getFieldValue({ user: { name: "John" } }, "user.name") // "John"
+ */
+declare function getFieldValue<TData extends Row>(row: TData, field: string): CellValue;
+/**
+ * Set field value supporting dot notation.
+ * Creates nested objects if they don't exist.
+ * @example
+ * const obj = { user: {} };
+ * setFieldValue(obj, "user.name", "John");
+ * // obj is now { user: { name: "John" } }
+ */
+declare function setFieldValue<TData extends Row>(row: TData, field: string, value: CellValue): void;
+//#endregion
+//#region src/indexed-data-store/sorting.d.ts
+/**
+ * Convert a string to a sortable number using first 10 characters.
+ * Uses base-36 encoding (a-z = 0-25, 0-9 = 26-35).
+ */
+declare function stringToSortableNumber(str: string): number;
+/**
+ * Compare two cell values for sorting.
+ * Handles null/undefined, arrays, numbers, dates, and strings.
+ */
+declare function compareValues(a: CellValue, b: CellValue): number;
+/**
+ * Compute a sortable hash for a cell value.
+ * Used for fast comparisons in sorted indices.
+ */
+declare function computeValueHash(value: CellValue): number;
+//#endregion
+//#region src/filtering/index.d.ts
+/**
+ * Check if two dates are on the same day.
+ */
+declare function isSameDay(date1: Date, date2: Date): boolean;
+/**
+ * Evaluate a text filter condition against a cell value.
+ */
+declare function evaluateTextCondition(cellValue: CellValue, condition: TextFilterCondition): boolean;
+/**
+ * Evaluate a number filter condition against a cell value.
+ */
+declare function evaluateNumberCondition(cellValue: CellValue, condition: NumberFilterCondition): boolean;
+/**
+ * Evaluate a date filter condition against a cell value.
+ */
+declare function evaluateDateCondition(cellValue: CellValue, condition: DateFilterCondition): boolean;
+/**
+ * Evaluate a column filter model against a cell value.
+ * Uses left-to-right evaluation with per-condition operators.
+ */
+declare function evaluateColumnFilter(cellValue: CellValue, filter: ColumnFilterModel): boolean;
+/**
+ * Check if a row passes all filters in a filter model.
+ */
+declare function rowPassesFilter<TData extends Row>(row: TData, filterModel: FilterModel, getFieldValue: (row: TData, field: string) => CellValue): boolean;
+//#endregion
+//#region src/transaction-manager.d.ts
+interface AddTransaction<TData> {
+  type: "ADD";
+  rows: TData[];
+}
+interface RemoveTransaction {
+  type: "REMOVE";
+  rowIds: RowId[];
+}
+interface UpdateCellTransaction {
+  type: "UPDATE_CELL";
+  rowId: RowId;
+  field: string;
+  value: CellValue;
+}
+interface UpdateRowTransaction<TData> {
+  type: "UPDATE_ROW";
+  rowId: RowId;
+  data: Partial<TData>;
+}
+type Transaction<TData> = AddTransaction<TData> | RemoveTransaction | UpdateCellTransaction | UpdateRowTransaction<TData>;
+interface TransactionResult {
+  added: number;
+  removed: number;
+  updated: number;
+}
+interface TransactionManagerOptions<TData extends Row> {
+  /** Debounce time in milliseconds. Default 50. Set to 0 for sync. */
+  debounceMs: number;
+  /** The indexed data store to apply transactions to */
+  store: IndexedDataStore<TData>;
+  /** Callback when transactions are processed */
+  onProcessed?: (result: TransactionResult) => void;
+}
+/**
+ * Manages a queue of data mutations with debounced batch processing.
+ * Supports ADD, REMOVE, UPDATE_CELL, and UPDATE_ROW operations.
+ */
+declare class TransactionManager<TData extends Row = Row> {
+  private queue;
+  private debounceTimer;
+  private pendingPromise;
+  private options;
+  constructor(options: TransactionManagerOptions<TData>);
+  /**
+   * Queue rows to be added.
+   */
+  add(rows: TData[]): void;
+  /**
+   * Queue rows to be removed by ID.
+   */
+  remove(rowIds: RowId[]): void;
+  /**
+   * Queue a cell update.
+   */
+  updateCell(rowId: RowId, field: string, value: CellValue): void;
+  /**
+   * Queue a row update (multiple fields).
+   */
+  updateRow(rowId: RowId, data: Partial<TData>): void;
+  /**
+   * Force immediate processing of queued transactions.
+   * Returns a promise that resolves when processing is complete.
+   */
+  flush(): Promise<void>;
+  /**
+   * Check if there are pending transactions.
+   */
+  hasPending(): boolean;
+  /**
+   * Get count of pending transactions.
+   */
+  getPendingCount(): number;
+  /**
+   * Clear all pending transactions without processing.
+   */
+  clear(): void;
+  /**
+   * Schedule processing after throttle delay.
+   * Uses throttle pattern: if a timer is already pending, new transactions
+   * are added to the queue but don't reset the timer. This ensures updates
+   * are processed even when they arrive faster than the throttle interval.
+   */
+  private scheduleProcessing;
+  /**
+   * Process all queued transactions.
+   */
+  private processQueue;
+}
+//#endregion
+//#region src/data-source/mutable-data-source.d.ts
+/** Callback for data change notifications */
+type DataChangeListener = (result: TransactionResult) => void;
+/**
+ * Data source with mutation capabilities.
+ * Extends DataSource with add, remove, and update operations.
+ */
+interface MutableDataSource<TData = Row> extends DataSource<TData> {
+  /** Add rows to the data source. Queued and processed after debounce. */
+  addRows(rows: TData[]): void;
+  /** Remove rows by ID. Queued and processed after debounce. */
+  removeRows(ids: RowId[]): void;
+  /** Update a cell value. Queued and processed after debounce. */
+  updateCell(id: RowId, field: string, value: CellValue): void;
+  /** Update multiple fields on a row. Queued and processed after debounce. */
+  updateRow(id: RowId, data: Partial<TData>): void;
+  /** Force immediate processing of queued transactions. */
+  flushTransactions(): Promise<void>;
+  /** Check if there are pending transactions. */
+  hasPendingTransactions(): boolean;
+  /** Get distinct values for a field (for filter UI). */
+  getDistinctValues(field: string): CellValue[];
+  /** Get a row by ID. */
+  getRowById(id: RowId): TData | undefined;
+  /** Get total row count. */
+  getTotalRowCount(): number;
+  /** Subscribe to data change notifications. Returns unsubscribe function. */
+  subscribe(listener: DataChangeListener): () => void;
+  /** Clear all data from the data source. */
+  clear(): void;
+}
+interface MutableClientDataSourceOptions<TData> {
+  /** Function to extract unique ID from row. Required. */
+  getRowId: (row: TData) => RowId;
+  /** Custom field accessor for nested properties. */
+  getFieldValue?: (row: TData, field: string) => CellValue;
+  /** Debounce time for transactions in ms. Default 50. Set to 0 for sync. */
+  debounceMs?: number;
+  /** Callback when transactions are processed. */
+  onTransactionProcessed?: (result: TransactionResult) => void;
+}
+/**
+ * Creates a mutable client-side data source with transaction support.
+ * Uses IndexedDataStore for efficient incremental operations.
+ */
+declare function createMutableClientDataSource<TData extends Row = Row>(data: TData[], options: MutableClientDataSourceOptions<TData>): MutableDataSource<TData>;
+//#endregion
+//#region src/styles/variables.d.ts
+declare const variablesStyles: string;
+//#endregion
+//#region src/styles/container.d.ts
+declare const containerStyles: string;
+//#endregion
+//#region src/styles/header.d.ts
+declare const headerStyles: string;
+//#endregion
+//#region src/styles/cells.d.ts
+declare const cellStyles: string;
+//#endregion
+//#region src/styles/states.d.ts
+declare const statesStyles: string;
+//#endregion
+//#region src/styles/scrollbar.d.ts
+declare const scrollbarStyles: string;
+//#endregion
+//#region src/styles/filters.d.ts
+declare const filtersStyles: string;
+//#endregion
+//#region src/styles/index.d.ts
+/**
+ * Combined grid styles from all modules
+ */
+declare const gridStyles: string;
+/**
+ * Inject grid styles into the document head.
+ * This is called automatically when the Grid component mounts.
+ * Styles are only injected once, even if multiple Grid instances exist.
+ */
+declare function injectStyles(): void;
+//#endregion
+//#region src/types/ui-state.d.ts
+interface SlotData<TData = Row> {
+  slotId: string;
+  rowIndex: number;
+  rowData: TData;
+  translateY: number;
+}
+interface HeaderData {
+  column: ColumnDefinition;
+  sortDirection?: SortDirection;
+  sortIndex?: number;
+  sortable: boolean;
+  filterable: boolean;
+  hasFilter: boolean;
+}
+interface FilterPopupState {
+  isOpen: boolean;
+  colIndex: number;
+  column: ColumnDefinition | null;
+  anchorRect: {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+  } | null;
+  distinctValues: CellValue[];
+  currentFilter?: ColumnFilterModel;
+}
+interface GridState<TData = Row> {
+  slots: Map<string, SlotData<TData>>;
+  activeCell: CellPosition | null;
+  selectionRange: CellRange | null;
+  editingCell: {
+    row: number;
+    col: number;
+    initialValue: CellValue;
+  } | null;
+  contentWidth: number;
+  contentHeight: number;
+  /** Viewport width (container's visible width) for column scaling */
+  viewportWidth: number;
+  headers: Map<number, HeaderData>;
+  filterPopup: FilterPopupState | null;
+  isLoading: boolean;
+  error: string | null;
+  totalRows: number;
+  /** Visible row range (start inclusive, end inclusive). Used to prevent selection showing in overscan. */
+  visibleRowRange: {
+    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, 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 };
+//# sourceMappingURL=index.d.ts.map