@gp-grid/core 0.10.3 → 0.11.0

package/dist/index.d.ts

@@ -890,138 +890,144 @@ declare class FillManager {
   private applyPattern;
 }
 //#endregion
+//#region src/input/column-resize-drag.d.ts
+declare class ColumnResizeDrag<TData = unknown> {
+  private active;
+  private colIndex;
+  private startX;
+  private initialWidth;
+  private currentWidth;
+  private readonly core;
+  constructor(core: GridCore<TData>);
+  get isActive(): boolean;
+  start(colIndex: number, colWidth: number, event: PointerEventData): InputResult;
+  move(event: PointerEventData, bounds: ContainerBounds): DragMoveResult;
+  end(): void;
+  getState(): ColumnResizeDragState | null;
+}
+//#endregion
+//#region src/input/column-move-drag.d.ts
+declare class ColumnMoveDrag<TData = unknown> {
+  private active;
+  private sourceColIndex;
+  private startX;
+  private startY;
+  private thresholdMet;
+  private shiftKey;
+  private ghostWidth;
+  private ghostHeight;
+  private currentX;
+  private currentY;
+  private dropTargetIndex;
+  private readonly core;
+  private deps;
+  constructor(core: GridCore<TData>, deps: InputHandlerDeps);
+  updateDeps(deps: InputHandlerDeps): void;
+  get isActive(): boolean;
+  get isDraggingForDisplay(): boolean;
+  start(colIndex: number, colWidth: number, colHeight: number, event: PointerEventData): InputResult;
+  move(event: PointerEventData, bounds: ContainerBounds): DragMoveResult | null;
+  end(cycleSortDirection: (current: SortDirection | null | undefined) => SortDirection | null): void;
+  private commitMove;
+  private treatAsHeaderClick;
+  private reset;
+  getState(): ColumnMoveDragState | null;
+}
+//#endregion
+//#region src/input/row-drag.d.ts
+declare class RowDrag<TData = unknown> {
+  private active;
+  private sourceRowIndex;
+  private startX;
+  private startY;
+  private thresholdMet;
+  private currentX;
+  private currentY;
+  private dropTargetIndex;
+  private readonly core;
+  private deps;
+  constructor(core: GridCore<TData>, deps: InputHandlerDeps);
+  updateDeps(deps: InputHandlerDeps): void;
+  get isActive(): boolean;
+  get isDraggingForDisplay(): boolean;
+  start(sourceRowIndex: number, clientX: number, clientY: number): void;
+  move(event: PointerEventData, bounds: ContainerBounds): DragMoveResult | null;
+  end(): void;
+  getState(): RowDragState | null;
+}
+//#endregion
+//#region src/input/selection-drag.d.ts
+declare class SelectionDrag<TData = unknown> {
+  private active;
+  private readonly core;
+  constructor(core: GridCore<TData>);
+  get isActive(): boolean;
+  start(): void;
+  moveToTarget(row: number, col: number): void;
+  end(): void;
+}
+//#endregion
+//#region src/input/fill-drag.d.ts
+declare class FillDrag<TData = unknown> {
+  private active;
+  private sourceRange;
+  private target;
+  private readonly core;
+  constructor(core: GridCore<TData>);
+  get isActive(): boolean;
+  get stateSnapshot(): {
+    sourceRange: CellRange | null;
+    target: {
+      row: number;
+      col: number;
+    } | null;
+  };
+  start(activeCell: CellPosition | null, selectionRange: CellRange | null): InputResult;
+  moveToTarget(row: number, col: number): void;
+  end(): void;
+}
+//#endregion
 //#region src/input-handler.d.ts
 declare class InputHandler<TData = unknown> {
   private readonly core;
   private deps;
-  private isDraggingSelection;
-  private isDraggingFill;
-  private fillSourceRange;
-  private fillTarget;
-  private isDraggingColumnResize;
-  private resizeColIndex;
-  private resizeStartX;
-  private resizeInitialWidth;
-  private resizeCurrentWidth;
-  private isDraggingColumnMove;
-  private moveSourceColIndex;
-  private moveStartX;
-  private moveStartY;
-  private moveThresholdMet;
-  private moveShiftKey;
-  private moveGhostWidth;
-  private moveGhostHeight;
-  private moveCurrentX;
-  private moveCurrentY;
-  private moveDropTargetIndex;
-  private isDraggingRow;
-  private rowDragSourceIndex;
-  private rowDragStartX;
-  private rowDragStartY;
-  private rowDragThresholdMet;
-  private rowDragCurrentX;
-  private rowDragCurrentY;
-  private rowDragDropTargetIndex;
-  private pendingRowDrag;
+  readonly columnResize: ColumnResizeDrag<TData>;
+  readonly columnMove: ColumnMoveDrag<TData>;
+  readonly rowDrag: RowDrag<TData>;
+  readonly selectionDrag: SelectionDrag<TData>;
+  readonly fillDrag: FillDrag<TData>;
+  private readonly pendingRowDrag;
+  private readonly keyboard;
   constructor(core: GridCore<TData>, deps: InputHandlerDeps);
-  /**
-   * Update dependencies (called when options change)
-   */
+  /** Update dependencies (called when options change) */
   updateDeps(deps: Partial<InputHandlerDeps>): void;
-  /**
-   * Get current drag state for UI rendering
-   */
   getDragState(): DragState;
   private getDragType;
-  /**
-   * Handle cell mouse down event
-   */
+  handleHeaderMouseDown(colIndex: number, colWidth: number, colHeight: number, event: PointerEventData): InputResult;
+  handleHeaderResizeMouseDown(colIndex: number, colWidth: number, event: PointerEventData): InputResult;
   handleCellMouseDown(rowIndex: number, colIndex: number, event: PointerEventData): InputResult;
-  /**
-   * Handle cell double click event (start editing)
-   */
+  private startPendingRowDrag;
+  private startRowDrag;
+  private startSelectionClick;
   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;
-  /**
-   * Handle mousedown on the resize handle of a header cell.
-   * Returns InputResult with startDrag: "column-resize".
-   */
-  handleHeaderResizeMouseDown(colIndex: number, colWidth: number, event: PointerEventData): InputResult;
-  /**
-   * Handle mousedown on a header cell for potential column move.
-   * Uses a drag threshold to distinguish click (sort) vs drag (move).
-   */
-  handleHeaderMouseDown(colIndex: number, colWidth: number, colHeight: number, event: PointerEventData): InputResult;
-  /**
-   * Start selection drag (called by framework after handleCellMouseDown returns startDrag: 'selection')
-   */
   startSelectionDrag(): void;
-  /**
-   * Confirm a pending row drag (called by framework after long-press timer fires).
-   * Returns true if the row drag was activated, false if the pending drag was already cancelled.
-   */
   confirmPendingRowDrag(): boolean;
-  /**
-   * Cancel a pending row drag (called when the pointer moves before the hold timer fires).
-   */
   cancelPendingRowDrag(): void;
-  /**
-   * Handle drag move event (selection, fill, column-resize, column-move, or row-drag)
-   */
   handleDragMove(event: PointerEventData, bounds: ContainerBounds): DragMoveResult | null;
-  private handleColumnResizeDragMove;
-  private handleColumnMoveDragMove;
-  private handleRowDragDragMove;
-  private handleSelectionFillDragMove;
-  /**
-   * Handle drag end event
-   */
+  private selectionFillMove;
   handleDragEnd(): void;
-  private endColumnResizeDrag;
-  private endColumnMoveDrag;
-  private endRowDrag;
-  private endSelectionFillDrag;
-  /**
-   * 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;
-  private handleKeyAction;
-  private handleNonEditingKey;
-  private keyToDirection;
-  /**
-   * Cycle sort direction: undefined/null → asc → desc → null
-   */
-  private cycleSortDirection;
-  /**
-   * Calculate auto-scroll deltas based on mouse position
-   */
-  private calculateAutoScroll;
 }
 //#endregion
 //#region src/managers/highlight-manager.d.ts
@@ -1283,8 +1289,14 @@ declare class SortFilterManager<TData = Record<string, unknown>> {
    * For array-type columns (like tags), each unique array combination is returned.
    * Arrays are sorted internally for consistent comparison.
    * Limited to maxValues distinct results and maxScanRows rows scanned.
-   * The row scan cap prevents hangs on low-cardinality columns (e.g. a tags column
-   * with only ~100 distinct combinations in 1.5M rows would otherwise scan every row).
+   *
+   * When the total exceeds maxScanRows we stride-sample across the full
+   * dataset instead of scanning the first N rows. Sequential scan was
+   * broken under an active sort: Map iteration follows insertion order,
+   * which after sort is the sorted order — so the first 100k rows only
+   * covered the "smallest" values of the column. Stride sampling covers
+   * the whole range at the cost of possibly missing rare values, which
+   * the maxValues cap would have dropped anyway.
    */
   getDistinctValuesForColumn(colId: string, maxValues?: number, maxScanRows?: number): CellValue[];
   /**
@@ -1402,9 +1414,10 @@ declare class IndexedDataStore<TData = unknown> {
    */
   private addRow;
   /**
-   * Remove rows by ID.
+   * Remove rows by ID. Returns the number of rows actually removed (unknown
+   * ids are ignored).
    */
-  removeRows(ids: RowId[]): void;
+  removeRows(ids: RowId[]): number;
   /**
    * Remove a single row by index.
    */
@@ -1474,18 +1487,29 @@ declare class IndexedDataStore<TData = unknown> {
    */
   private rebuildDistinctValues;
   /**
-   * Update distinct values when a row is added or removed.
+   * Update distinct-value refcounts when a row is added or removed.
+   * Skips null/undefined cell values — they never enter the filter popup.
    */
   private updateDistinctValuesForRow;
   /**
-   * Update distinct value for a specific field when cell value changes.
+   * Update distinct-value refcounts when a cell value changes: decrement
+   * the old value's count (evicting it if this was the last reference)
+   * and increment the new value's count.
    */
   private updateDistinctValueForField;
   /**
-   * Add a value (scalar or array) to the distinct values set for a field.
-   * Creates the set if it doesn't exist. For arrays, adds each non-null item individually.
+   * Add a value (scalar or array) to the distinct-value refcount map.
+   * Creates the field's count map lazily. For arrays, each non-null item
+   * is counted individually so tag-column filters see element-level
+   * distinct values.
    */
   private addToDistinctValues;
+  /**
+   * Decrement refcount(s) for a value (scalar or array). When a count
+   * reaches zero the key is deleted so getDistinctValues() no longer
+   * returns stale values after the last holder is removed.
+   */
+  private decrementDistinctValues;
 }
 //#endregion
 //#region src/indexed-data-store/field-helpers.d.ts
@@ -1653,10 +1677,7 @@ declare class GridCore<TData = unknown> {
   private readonly onRowDragEnd?;
   private readonly onColumnResized?;
   private readonly onColumnMoved?;
-  private scrollTop;
-  private scrollLeft;
-  private viewportWidth;
-  private viewportHeight;
+  private readonly viewport;
   private readonly currentPageIndex;
   private readonly pageSize;
   private cachedRows;
@@ -1670,8 +1691,7 @@ declare class GridCore<TData = unknown> {
   private readonly slotPool;
   private readonly editManager;
   private columnPositions;
-  private batchListeners;
-  private instructionBuffer;
+  private readonly batcher;
   private readonly scrollVirtualization;
   private isDestroyed;
   private _isDataLoading;
@@ -1681,18 +1701,6 @@ declare class GridCore<TData = unknown> {
    * Batch listeners receive arrays of instructions instead of individual ones.
    */
   onBatchInstruction(listener: BatchInstructionListener): () => void;
-  /**
-   * Start buffering instructions. All emit/emitBatch calls will accumulate
-   * into an internal buffer until flushBatch() is called.
-   */
-  private startBatch;
-  /**
-   * Flush buffered instructions to listeners as a single batch, then
-   * stop buffering.
-   */
-  private flushBatch;
-  private emit;
-  private emitBatch;
   /**
    * Initialize the grid and load initial data.
    */
@@ -1727,6 +1735,7 @@ declare class GridCore<TData = unknown> {
   private computeColumnPositions;
   private emitContentSize;
   private emitHeaders;
+  private emitVisibleRange;
   /**
    * Set the width of a column and recompute layout.
    */
@@ -1744,12 +1753,6 @@ declare class GridCore<TData = unknown> {
    * performed, then only update the affected slots.
    */
   commitRowDrag(sourceIndex: number, targetIndex: number): void;
-  /**
-   * Update cachedRows in-place to mirror the splice the data source performed.
-   * The data source does: splice(from, 1) then splice(adjustedTo, 0, row).
-   * Uses a unified loop with step direction instead of two separate branch loops.
-   */
-  private reorderCachedRows;
   /**
    * Whether the entire row is draggable.
    */
@@ -1994,7 +1997,7 @@ declare const findSlotForRow: (slots: Map<string, SlotData>, rowIndex: number) =
  */
 declare const scrollCellIntoView: (core: {
   getScrollTopForRow(row: number): number;
-}, container: HTMLDivElement, row: number, rowHeight: number, slots: Map<string, SlotData>, rowsWrapperOffset?: number) => void;
+}, container: HTMLElement, row: number, rowHeight: number, slots: Map<string, SlotData>, rowsWrapperOffset?: number) => void;
 //#endregion
 //#region src/utils/format-helpers.d.ts
 /**
@@ -2235,51 +2238,20 @@ declare class ParallelSortManager {
   private readonly 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: "asc" | "desc"): Promise<Uint32Array>;
-  /**
-   * Sort string hashes with collision detection.
-   * Automatically uses parallel sorting for large datasets.
-   */
   sortStringHashes(hashChunks: Float64Array[], direction: "asc" | "desc", originalStrings: string[]): Promise<Uint32Array>;
-  /**
-   * Multi-column sort.
-   * Automatically uses parallel sorting for large datasets.
-   */
   sortMultiColumn(columns: number[][], directions: ("asc" | "desc")[]): Promise<Uint32Array>;
+  private assertNotTerminated;
   private sortIndicesSingle;
   private sortStringHashesSingle;
   private sortMultiColumnSingle;
+  private boundariesFor;
+  private runChunks;
   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
@@ -2517,15 +2489,10 @@ declare const rowDragStyles: string;
 //#endregion
 //#region src/styles/index.d.ts
 /**
- * Combined grid styles from all modules
+ * Combined grid styles from all modules.
+ * Use `@gp-grid/core/dist/styles.css` in your app instead of consuming this directly.
  */
 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/state-reducer.d.ts
 /**
@@ -2536,4 +2503,204 @@ declare function injectStyles(): void;
  */
 declare const applyInstruction: <TData = unknown>(instruction: GridInstruction, slots: Map<string, SlotData<TData>>, headers: Map<number, HeaderData>) => Partial<GridState<TData>> | null;
 //#endregion
-export { type AssignSlotInstruction, type BatchInstructionListener, type CalculateFillHandlePositionParams, type CancelColumnMoveInstruction, type CancelColumnResizeInstruction, type CancelFillInstruction, type CancelRowDragInstruction, type CellDataType, type CellPosition, type CellRange, type CellRendererParams, type CellValue, type CellValueChangedEvent, type CloseFilterPopupInstruction, type ColumnDefinition, type ColumnFilterModel, type ColumnMoveDragState, type ColumnResizeDragState, type ColumnsChangedInstruction, type CommitColumnMoveInstruction, type CommitColumnResizeInstruction, type CommitEditInstruction, type CommitFillInstruction, type CommitRowDragInstruction, 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 FillHandlePosition, 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, type InitialStateArgs, 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 PopupPosition, type RowDragState, type RowId, RowMutationManager, type RowMutationManagerOptions, type RowSortCache, type RowsAddedInstruction, type RowsRemovedInstruction, type RowsUpdatedInstruction, ScrollVirtualizationManager, type ScrollVirtualizationManagerOptions, 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, SortFilterManager, type SortFilterManagerOptions, type SortModel, type SortedChunk, type StartColumnMoveInstruction, type StartColumnResizeInstruction, type StartEditInstruction, type StartFillInstruction, type StartRowDragInstruction, type StopEditInstruction, type TextFilterCondition, type TextFilterOperator, type Transaction, TransactionManager, type TransactionManagerOptions, type TransactionProcessedInstruction, type TransactionResult, type UpdateColumnMoveInstruction, type UpdateColumnResizeInstruction, type UpdateFillInstruction, type UpdateHeaderInstruction, type UpdateRowDragInstruction, type VisibleColumnInfo, WorkerPool, type WorkerPoolOptions, applyInstruction, buildCellClasses, calculateColumnPositions, calculateFillHandlePosition, calculateFilterPopupPosition, calculateScaledColumnPositions, cellStyles, compareValues, computeValueHash, containerStyles, createClientDataSource, createDataSourceFromArray, createInitialState, createMutableClientDataSource, createServerDataSource, detectBoundaryCollisions, evaluateColumnFilter, evaluateDateCondition, evaluateNumberCondition, evaluateTextCondition, filtersStyles, findColumnAtX, findSlotForRow, formatCellValue, getFieldValue, getTotalWidth, gridStyles, headerStyles, injectStyles, isCellActive, isCellEditing, isCellInFillPreview, isCellSelected, isColumnInSelectionRange, isRowInSelectionRange, isRowVisible, isSameDay, kWayMerge, kWayMergeMultiColumn, rowDragStyles, rowPassesFilter, scrollCellIntoView, scrollbarStyles, setFieldValue, statesStyles, stringToSortableNumber, variablesStyles };
+//#region src/adapter/pointer-event.d.ts
+/**
+ * Convert a DOM PointerEvent into the framework-agnostic PointerEventData
+ * shape consumed by core.input.*.
+ *
+ * Used by framework wrappers so each pointer-down handler doesn't have to
+ * spell out the 8-field literal.
+ */
+declare const toPointerEventData: (event: PointerEvent) => PointerEventData;
+//#endregion
+//#region src/adapter/auto-scroll.d.ts
+/**
+ * Continuous scroll driver used while a drag (selection, fill, row-drag)
+ * leaves the viewport. The caller provides the scroll element getter and
+ * a tick callback that re-processes the most recent pointer event after
+ * each programmatic scroll, so the visible region catches up under the
+ * pointer.
+ *
+ * Framework-agnostic: accepts plain getter/callback functions and relies
+ * only on setInterval + element.scrollTop/scrollLeft.
+ */
+declare class AutoScrollDriver {
+  private intervalId;
+  private lastPointerEvent;
+  private readonly getBodyEl;
+  private readonly onTick;
+  constructor(getBodyEl: () => HTMLElement | null, onTick: (event: PointerEvent) => void);
+  recordPointer(event: PointerEvent): void;
+  clearPointer(): void;
+  start(dx: number, dy: number): void;
+  stop(): void;
+}
+//#endregion
+//#region src/adapter/pending-row-drag.d.ts
+interface PendingRowDragDeps<TData = unknown> {
+  getCore: () => GridCore<TData> | null;
+  getContainer: () => HTMLElement | null;
+  isBrowser: boolean;
+  onDragConfirmed: (state: DragState) => void;
+}
+/**
+ * Row-drag pending state machine. When a row-drag handle is pressed, we
+ * must distinguish a tap/click (no drag) from an intentional hold (drag).
+ *
+ * Algorithm:
+ *  - start() arms a 300ms timer and listens for pointermove/up on document.
+ *  - If the pointer moves >10px before the timer fires → cancel (treat as tap).
+ *  - If the pointer releases before the timer fires → cancel.
+ *  - If the timer fires first → confirm: lock container overflow, block
+ *    touchmove, capture the pointer, and tell the caller the drag is live.
+ *
+ * Framework-agnostic: accepts plain getter/callback deps and touches only
+ * the document/element DOM APIs. Wrappers gate construction on browser.
+ */
+declare class PendingRowDragController<TData = unknown> {
+  private timer;
+  private capture;
+  private savedContainerOverflow;
+  private readonly blockTouchMove;
+  private readonly deps;
+  constructor(deps: PendingRowDragDeps<TData>);
+  start(event: PointerEvent): void;
+  cancel(): void;
+  releaseLocks(): void;
+  private confirm;
+  private lockContainer;
+  private applyPointerCapture;
+}
+//#endregion
+//#region src/adapter/batch-applier.d.ts
+type EditingCell = {
+  row: number;
+  col: number;
+  initialValue: CellValue;
+} | null;
+/**
+ * A "setters bag" the wrapper provides. Each setter pokes a framework-
+ * specific reactive primitive (signal.set, ref.value =, dispatch action).
+ * The batch applier itself is pure and reactivity-agnostic.
+ */
+interface BatchChangeSetters {
+  setContentWidth: (v: number) => void;
+  setContentHeight: (v: number) => void;
+  setRowsWrapperOffset: (v: number) => void;
+  setIsLoading: (v: boolean) => void;
+  setErrorMessage: (v: string | null) => void;
+  setPendingScrollTop: (v: number | null) => void;
+  setActiveCell: (v: CellPosition | null) => void;
+  setSelectionRange: (v: CellRange | null) => void;
+  setEditingCell: (v: EditingCell) => void;
+  setHoverPosition: (v: CellPosition | null) => void;
+  setColumnsOverride: (v: ColumnDefinition[]) => void;
+  onFilterPopupChange: (v: FilterPopupState | null) => void;
+}
+type MutableMaps = {
+  slots: Map<string, SlotData>;
+  headers: Map<number, HeaderData>;
+};
+/**
+ * Apply a batch of grid instructions to a snapshot of slots/headers while
+ * dispatching scalar changes through the provided setters. Returns the
+ * new slot/header maps so the wrapper can commit them to its reactive
+ * containers in one step.
+ */
+declare const applyBatchInstructions: (instructions: readonly GridInstruction[], currentSlots: Map<string, SlotData>, currentHeaders: Map<number, HeaderData>, setters: BatchChangeSetters) => MutableMaps;
+//#endregion
+//#region src/adapter/data-source-owner.d.ts
+/**
+ * Manages the "owned vs. provided" DataSource lifecycle shared by every
+ * framework wrapper: wrap a raw `rows` array when the user didn't provide
+ * their own DataSource, detect changes to `rows` / `columns` between
+ * renders so we don't re-apply unchanged inputs, and destroy the owned
+ * DataSource on teardown.
+ *
+ * The owner is framework-agnostic: it doesn't subscribe to anything.
+ * Wrappers drive it from their own reactivity system (signal effects,
+ * useEffect, watch) and react to its return values.
+ */
+declare class DataSourceOwner<TData = unknown> {
+  private owned;
+  private lastAppliedRows;
+  private lastAppliedColumns;
+  /**
+   * Call once on setup. If the user provided a DataSource, use it.
+   * Otherwise build one from the initial rows array and remember it
+   * for later destruction.
+   */
+  initialize(provided: DataSource<TData> | null, initialRows: TData[]): DataSource<TData>;
+  /**
+   * Call when the `rows` input changes. Returns a new owned DataSource
+   * if one was rebuilt (caller should push it to core via setDataSource),
+   * or null if nothing changed or a provided DataSource is in use.
+   */
+  syncRows(rows: TData[], provided: DataSource<TData> | null): DataSource<TData> | null;
+  /**
+   * Call when the `columns` input changes. Returns true if the reference
+   * is new and the caller should push to core via setColumns; false if
+   * unchanged.
+   */
+  syncColumns(columns: ColumnDefinition[]): boolean;
+  /** Destroy the owned DataSource, if any. Safe to call multiple times. */
+  destroy(): void;
+}
+//#endregion
+//#region src/adapter/input-event-adapter.d.ts
+interface InputEventAdapterDeps<TData = unknown> {
+  getCore: () => GridCore<TData> | null;
+  getBodyEl: () => HTMLElement | null;
+  autoScroll: AutoScrollDriver;
+  pendingRowDrag: PendingRowDragController<TData>;
+  onDragStateChange: (state: DragState) => void;
+}
+interface CellPointerAction {
+  preventDefault: boolean;
+  focusContainer: boolean;
+}
+interface FillPointerAction {
+  preventDefault: boolean;
+  stopPropagation: boolean;
+}
+interface DragEndResult {
+  wasRowDrag: boolean;
+}
+/**
+ * Shared event-to-core adapter consumed by every framework wrapper.
+ *
+ * Each method accepts a DOM event (PointerEvent/KeyboardEvent) plus any
+ * caller-side state the core needs, converts the event to the framework-
+ * agnostic PointerEventData/KeyEventData shape, forwards it to core's
+ * input handler, and performs the side effects that would otherwise be
+ * reimplemented in each wrapper (drag-start dispatch, pointer capture,
+ * auto-scroll start/stop, row-drag teardown).
+ *
+ * Methods return primitive "hint" objects so the wrapper can apply the
+ * DOM actions that are framework-specific (preventDefault, focus, scroll
+ * to cell, release container locks).
+ */
+declare class InputEventAdapter<TData = unknown> {
+  private readonly deps;
+  constructor(deps: InputEventAdapterDeps<TData>);
+  headerPointerDown(colIndex: number, colWidth: number, colHeight: number, event: PointerEvent): boolean;
+  resizePointerDown(colIndex: number, colWidth: number, event: PointerEvent): boolean;
+  cellPointerDown(rowIndex: number, colIndex: number, event: PointerEvent): CellPointerAction;
+  cellPointerEnter(rowIndex: number, colIndex: number): void;
+  cellPointerLeave(): void;
+  fillHandlePointerDown(activeCell: CellPosition | null, selectionRange: CellRange | null, event: PointerEvent): FillPointerAction;
+  dragMove(event: PointerEvent): void;
+  documentPointerMove(event: PointerEvent): boolean;
+  documentPointerUp(): DragEndResult;
+  wheel(deltaY: number, deltaX: number, dampening: number): {
+    dy: number;
+    dx: number;
+  } | null;
+  keyDown(event: KeyboardEvent, activeCell: CellPosition | null, editingCell: {
+    row: number;
+    col: number;
+  } | null, filterPopupOpen: boolean): KeyboardResult;
+  private dispatchCellDragStart;
+}
+//#endregion
+export { type AssignSlotInstruction, AutoScrollDriver, type BatchChangeSetters, type BatchInstructionListener, type CalculateFillHandlePositionParams, type CancelColumnMoveInstruction, type CancelColumnResizeInstruction, type CancelFillInstruction, type CancelRowDragInstruction, type CellDataType, type CellPointerAction, type CellPosition, type CellRange, type CellRendererParams, type CellValue, type CellValueChangedEvent, type CloseFilterPopupInstruction, type ColumnDefinition, type ColumnFilterModel, type ColumnMoveDragState, type ColumnResizeDragState, type ColumnsChangedInstruction, type CommitColumnMoveInstruction, type CommitColumnResizeInstruction, type CommitEditInstruction, type CommitFillInstruction, type CommitRowDragInstruction, type ContainerBounds, type CreateSlotInstruction, type DataChangeListener, type DataErrorInstruction, type DataLoadedInstruction, type DataLoadingInstruction, type DataSource, DataSourceOwner, type DataSourceRequest, type DataSourceResponse, type DateFilterCondition, type DateFilterOperator, type DestroySlotInstruction, type Direction, type DragEndResult, type DragMoveResult, type DragState, EditManager, type EditManagerOptions, type EditRendererParams, type EditState, type FillHandlePosition, type FillHandleState, FillManager, type FillPointerAction, 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, type InitialStateArgs, InputEventAdapter, type InputEventAdapterDeps, 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, PendingRowDragController, type PendingRowDragDeps, type PointerEventData, type PopupPosition, type RowDragState, type RowId, RowMutationManager, type RowMutationManagerOptions, type RowSortCache, type RowsAddedInstruction, type RowsRemovedInstruction, type RowsUpdatedInstruction, ScrollVirtualizationManager, type ScrollVirtualizationManagerOptions, 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, SortFilterManager, type SortFilterManagerOptions, type SortModel, type SortedChunk, type StartColumnMoveInstruction, type StartColumnResizeInstruction, type StartEditInstruction, type StartFillInstruction, type StartRowDragInstruction, type StopEditInstruction, type TextFilterCondition, type TextFilterOperator, type Transaction, TransactionManager, type TransactionManagerOptions, type TransactionProcessedInstruction, type TransactionResult, type UpdateColumnMoveInstruction, type UpdateColumnResizeInstruction, type UpdateFillInstruction, type UpdateHeaderInstruction, type UpdateRowDragInstruction, type VisibleColumnInfo, WorkerPool, type WorkerPoolOptions, applyBatchInstructions, applyInstruction, buildCellClasses, calculateColumnPositions, calculateFillHandlePosition, calculateFilterPopupPosition, calculateScaledColumnPositions, cellStyles, compareValues, computeValueHash, containerStyles, createClientDataSource, createDataSourceFromArray, createInitialState, createMutableClientDataSource, createServerDataSource, detectBoundaryCollisions, evaluateColumnFilter, evaluateDateCondition, evaluateNumberCondition, evaluateTextCondition, filtersStyles, findColumnAtX, findSlotForRow, formatCellValue, getFieldValue, getTotalWidth, gridStyles, headerStyles, isCellActive, isCellEditing, isCellInFillPreview, isCellSelected, isColumnInSelectionRange, isRowInSelectionRange, isRowVisible, isSameDay, kWayMerge, kWayMergeMultiColumn, rowDragStyles, rowPassesFilter, scrollCellIntoView, scrollbarStyles, setFieldValue, statesStyles, stringToSortableNumber, toPointerEventData, variablesStyles };