@ishibashi0112/spreadsheet-grid 0.35.0 → 0.37.0

package/dist/controllers/clipboardController.d.ts

@@ -0,0 +1,31 @@
+import { type GridUiAction } from '../model/gridActions';
+import type { GridColumn, GridSelection, GridUiState, RowModel, SpreadsheetGridProps } from '../model/gridTypes';
+import type { ServerSideCellEditInput } from '../logic/serverSideEdits';
+export type ClipboardEventLike = {
+    clipboardData: {
+        getData: (type: string) => string;
+    } | null;
+    preventDefault: () => void;
+};
+export type ClipboardControllerArgs<T extends object> = {
+    rows: T[];
+    rowModel: RowModel<T>;
+    visibleColumns: GridColumn<T>[];
+    uiState: GridUiState;
+    readOnly: boolean;
+    canEditCell: SpreadsheetGridProps<T>['canEditCell'];
+    createRow?: () => T;
+    createOverflowColumn?: (columnIndex: number) => GridColumn<T>;
+    onRowsChange?: (nextRows: T[]) => void;
+    onColumnsChange?: (nextColumns: GridColumn<T>[]) => void;
+    applyServerSideCellEdits?: (edits: ServerSideCellEditInput<T>[]) => number;
+    isRowExportable?: SpreadsheetGridProps<T>['isRowExportable'];
+    dispatch: (action: GridUiAction) => void;
+};
+export type ClipboardController<T extends object> = {
+    update: (args: ClipboardControllerArgs<T>) => void;
+    handleCopy: () => Promise<void>;
+    handlePaste: (event: ClipboardEventLike) => void;
+};
+export declare const computeIsWholeGridSelected: (selection: GridSelection, viewRowCount: number, columnCount: number) => boolean;
+export declare const createClipboardController: <T extends object>() => ClipboardController<T>;

package/dist/controllers/columnAutosizeRunner.d.ts

@@ -0,0 +1,20 @@
+import { gridActions } from '../model/gridActions';
+import type { GridColumn, RowModel } from '../model/gridTypes';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type ColumnAutosizeRunnerArgs<T> = {
+    rowModelRef: ReadonlyRef<RowModel<T>>;
+    gridRootRef: ReadonlyRef<HTMLElement | null>;
+    columnWidthsRef: ReadonlyRef<Record<string, number>>;
+    dispatch: (action: ReturnType<typeof gridActions.syncColumnWidths>) => void;
+};
+export type ColumnAutosizeRunner<T> = {
+    update: (args: ColumnAutosizeRunnerArgs<T>) => void;
+    runAutosize: (columns: GridColumn<T>[]) => Promise<void>;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => boolean;
+    dispose: () => void;
+};
+export declare const createColumnAutosizeRunner: <T>() => ColumnAutosizeRunner<T>;
+export {};

package/dist/controllers/columnHeaderDragController.d.ts

@@ -0,0 +1,44 @@
+import type { GridColumn, GridColumnPinned, GridResolvedSlot } from '../model/gridTypes';
+import { type ColumnPane, type GridPaneLayout } from '../logic/geometry';
+type ApplyColumnOrderAndPin = (orderedKeys: string[], pinOverride?: Map<string, GridColumnPinned | undefined>) => void;
+export declare function computeHeaderReorderedKeys<T>(columns: GridColumn<T>[], draggedKey: string, targetPane: ColumnPane, slotInTargetVisible: number): string[] | null;
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type ColumnHeaderDragArgs<T> = {
+    enabled: boolean;
+    columns: GridColumn<T>[];
+    paneLayout: GridPaneLayout<T>;
+    leftPaneScrollRef: ReadonlyRef<HTMLElement | null>;
+    rightPaneScrollRef: ReadonlyRef<HTMLElement | null>;
+    bodyScrollRef: ReadonlyRef<HTMLElement | null>;
+    scrollContainerRef: ReadonlyRef<HTMLElement | null>;
+    leftIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    centerIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    rightIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    leftLeadingWidth: number;
+    centerLeadingWidth: number;
+    rightLeadingWidth: number;
+    applyColumnOrderAndPin: ApplyColumnOrderAndPin;
+    ghostSlot?: GridResolvedSlot;
+};
+export type ColumnDragHandlePointerEvent = {
+    button: number;
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+    currentTarget: {
+        setPointerCapture: (pointerId: number) => void;
+        releasePointerCapture: (pointerId: number) => void;
+    };
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export type ColumnHeaderDragController<T> = {
+    update: (args: ColumnHeaderDragArgs<T>) => void;
+    onColumnDragHandlePointerDown: (column: GridColumn<T>, event: ColumnDragHandlePointerEvent) => void;
+    applyReorderSettle: () => void;
+    dispose: () => void;
+};
+export declare const createColumnHeaderDragController: <T>() => ColumnHeaderDragController<T>;
+export {};

package/dist/controllers/columnMenuController.d.ts

@@ -0,0 +1,49 @@
+import type { GridColumn } from '../model/gridTypes';
+import { type ReadonlyElementRef } from './popoverSupport';
+export type ColumnMenuLayout = {
+    top: number;
+    left: number;
+    width: number;
+    maxHeight?: number;
+};
+export type ColumnMenuSnapshot = {
+    columnKey: string | null;
+    layout: ColumnMenuLayout | null;
+};
+export type ColumnMenuControllerArgs<T> = {
+    visibleColumns: GridColumn<T>[];
+    enableColumnMenu: boolean;
+    gridRootRef: ReadonlyElementRef;
+};
+export type MenuButtonPointerEvent = {
+    button: number;
+    pointerType: string;
+    currentTarget: HTMLButtonElement;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export type MenuButtonClickEvent = {
+    currentTarget: HTMLButtonElement;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export type MenuContextEvent = {
+    clientX: number;
+    clientY: number;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export type ColumnMenuController<T> = {
+    update: (args: ColumnMenuControllerArgs<T>) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ColumnMenuSnapshot;
+    panelRef: {
+        current: HTMLDivElement | null;
+    };
+    openFromButton: (column: GridColumn<T>, event: MenuButtonPointerEvent) => void;
+    openFromButtonClick: (column: GridColumn<T>, event: MenuButtonClickEvent) => void;
+    openFromContextMenu: (column: GridColumn<T>, event: MenuContextEvent) => void;
+    close: () => void;
+    dispose: () => void;
+};
+export declare const createColumnMenuController: <T>() => ColumnMenuController<T>;

package/dist/controllers/contextMenuController.d.ts

@@ -0,0 +1,30 @@
+import type { GridContextMenuItem, GridContextMenuParams } from '../model/gridTypes';
+import { type ReadonlyElementRef } from './popoverSupport';
+export type CellContextMenuLayout = {
+    top: number;
+    left: number;
+    width: number;
+};
+export type CellContextMenuState<T> = {
+    params: GridContextMenuParams<T>;
+    items: GridContextMenuItem[];
+};
+export type ContextMenuSnapshot<T> = {
+    state: CellContextMenuState<T> | null;
+    layout: CellContextMenuLayout | null;
+};
+export type ContextMenuControllerArgs = {
+    gridRootRef: ReadonlyElementRef;
+};
+export type ContextMenuController<T> = {
+    update: (args: ContextMenuControllerArgs) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ContextMenuSnapshot<T>;
+    panelRef: {
+        current: HTMLDivElement | null;
+    };
+    open: (params: GridContextMenuParams<T>, items: GridContextMenuItem[]) => void;
+    close: () => void;
+    dispose: () => void;
+};
+export declare const createContextMenuController: <T>() => ContextMenuController<T>;

package/dist/controllers/editController.d.ts

@@ -0,0 +1,27 @@
+import { type GridUiAction } from '../model/gridActions';
+import type { CellCoord, EditorCommitDirection, EditorCommitResult, GridColumn, GridUiState, RowModel } from '../model/gridTypes';
+import type { ServerSideCellEditInput } from '../logic/serverSideEdits';
+export type EditControllerArgs<T extends object> = {
+    uiState: GridUiState;
+    rows: T[];
+    visibleColumns: GridColumn<T>[];
+    rowModel: RowModel<T>;
+    setEditorInitialValue: (value: string) => void;
+    onRowsChange?: (nextRows: T[]) => void;
+    applyServerSideCellEdits?: (edits: ServerSideCellEditInput<T>[]) => number;
+    dispatch: (action: GridUiAction) => void;
+    gridRootRef: {
+        readonly current: HTMLElement | null;
+    };
+    editorActionGuardRef: {
+        current: boolean;
+    };
+};
+export type EditController<T extends object> = {
+    update: (args: EditControllerArgs<T>) => void;
+    activateSingleCell: (cell: CellCoord) => void;
+    startEditWithValue: (cell: CellCoord, initialValue: string) => void;
+    commitEdit: (committedValue: unknown, direction?: EditorCommitDirection) => EditorCommitResult;
+    cancelEdit: () => void;
+};
+export declare const createEditController: <T extends object>() => EditController<T>;

package/dist/controllers/filterPopoverController.d.ts

@@ -0,0 +1,53 @@
+import type { ColumnFilterUiType, ColumnFilterValue, GridColumn } from '../model/gridTypes';
+import { type NumberFilterConditionDraft } from '../logic/numberFilterCondition';
+import { type TextFilterConditionDraft } from '../logic/textFilterCondition';
+import { type DateFilterConditionDraft } from '../logic/dateFilterCondition';
+import { type ReadonlyElementRef } from './popoverSupport';
+export type HeaderFilterPopoverState = {
+    columnKey: string;
+    filterType: ColumnFilterUiType;
+    draftValue: string;
+    numberDraft: NumberFilterConditionDraft | null;
+    textDraft: TextFilterConditionDraft | null;
+    dateDraft: DateFilterConditionDraft | null;
+};
+export type FilterPopoverLayout = {
+    top: number;
+    left: number;
+    width: number;
+    maxHeight: number;
+};
+export type FilterPopoverSnapshot = {
+    state: HeaderFilterPopoverState | null;
+    layout: FilterPopoverLayout | null;
+};
+export type FilterPopoverControllerArgs<T> = {
+    visibleColumns: GridColumn<T>[];
+    columnFilterValues: Record<string, ColumnFilterValue>;
+    enableColumnFilter: boolean;
+    gridRootRef: ReadonlyElementRef;
+    resolveColumnFilterType?: (column: GridColumn<T>) => ColumnFilterUiType;
+};
+export type FilterPopoverController<T> = {
+    update: (args: FilterPopoverControllerArgs<T>) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => FilterPopoverSnapshot;
+    panelRef: {
+        current: HTMLDivElement | null;
+    };
+    textInputRef: {
+        current: HTMLInputElement | null;
+    };
+    selectRef: {
+        current: HTMLSelectElement | null;
+    };
+    open: (column: GridColumn<T>) => void;
+    close: () => void;
+    updateDraft: (value: string) => void;
+    updateNumberDraft: (draft: NumberFilterConditionDraft) => void;
+    updateTextDraft: (draft: TextFilterConditionDraft) => void;
+    updateDateDraft: (draft: DateFilterConditionDraft) => void;
+    dispose: () => void;
+};
+export declare const resolveOpenedFilterColumn: <T>(visibleColumns: GridColumn<T>[], state: HeaderFilterPopoverState | null) => GridColumn<T> | null;
+export declare const createFilterPopoverController: <T>() => FilterPopoverController<T>;

package/dist/controllers/globalFilteredOrder.d.ts

@@ -0,0 +1,38 @@
+import type { GlobalFilterStatus, GridColumn } from '../model/gridTypes';
+import { type RowOrder } from '../logic/filtering';
+export declare const ASYNC_GLOBAL_FILTER_ROW_THRESHOLD = 50000;
+export type GlobalFilteredOrderResult = {
+    order: RowOrder;
+    status: GlobalFilterStatus;
+    progress: number;
+};
+export type GlobalFilterKey<T> = {
+    rows: T[];
+    baseOrder: RowOrder;
+    columns: GridColumn<T>[];
+    needle: string;
+};
+export declare const resolveSyncGlobalFilteredOrder: <T>(key: GlobalFilterKey<T>, deferredText: string, enabled: boolean) => GlobalFilteredOrderResult | null;
+export type GlobalFilteredOrderArgs<T> = GlobalFilterKey<T> & {
+    needsAsync: boolean;
+};
+type ReadyState<T> = GlobalFilterKey<T> & {
+    order: RowOrder;
+    rowsLength: number;
+};
+type ProgressState<T> = GlobalFilterKey<T> & {
+    progress: number;
+};
+export type GlobalFilteredOrderSnapshot<T> = {
+    ready: ReadyState<T> | null;
+    progress: ProgressState<T> | null;
+};
+export declare const selectGlobalFilteredOrderResult: <T>(syncResult: GlobalFilteredOrderResult | null, snapshot: GlobalFilteredOrderSnapshot<T>, key: GlobalFilterKey<T>) => GlobalFilteredOrderResult;
+export type GlobalFilteredOrderRunner<T> = {
+    update: (args: GlobalFilteredOrderArgs<T>) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => GlobalFilteredOrderSnapshot<T>;
+    dispose: () => void;
+};
+export declare const createGlobalFilteredOrderRunner: <T>() => GlobalFilteredOrderRunner<T>;
+export {};

package/dist/controllers/historyController.d.ts

@@ -0,0 +1,28 @@
+import { type GridUiAction } from '../model/gridActions';
+import type { CellCoord, GridSelection, UndoRedoState } from '../model/gridTypes.core';
+export type GridHistoryEntry<T> = {
+    rows: T[];
+    selection: GridSelection;
+    activeCell: CellCoord | null;
+};
+export type HistoryControllerArgs<T> = {
+    rows: T[];
+    selection: GridSelection;
+    activeCell: CellCoord | null;
+    onRowsChange?: (nextRows: T[]) => void;
+    dispatch: (action: GridUiAction) => void;
+    enabled: boolean;
+    limit: number;
+    onUndoRedoStateChange?: (state: UndoRedoState) => void;
+    onAfterRestore?: (activeCell: CellCoord | null) => void;
+};
+export type HistoryController<T> = {
+    update: (args: HistoryControllerArgs<T>) => void;
+    handleRowsChange: (nextRows: T[]) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    clearHistory: () => void;
+};
+export declare const createHistoryController: <T>() => HistoryController<T>;

package/dist/controllers/keyboardController.d.ts

@@ -0,0 +1,36 @@
+import { type GridUiAction } from '../model/gridActions';
+import type { CellCoord, GridColumn, GridUiState, RowModel, SpreadsheetGridProps } from '../model/gridTypes';
+export type GridKeyboardEventLike = {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    isComposing: boolean;
+    target: EventTarget | null;
+    preventDefault: () => void;
+};
+export type KeyboardControllerArgs<T> = {
+    uiState: GridUiState;
+    rowModel: RowModel<T>;
+    visibleColumns: GridColumn<T>[];
+    readOnly: boolean;
+    canEditCell: SpreadsheetGridProps<T>['canEditCell'];
+    setEditorInitialValue: (value: string) => void;
+    dispatch: (action: GridUiAction) => void;
+    handleCopy: () => Promise<void>;
+    handleCellDoubleClick: (cell: CellCoord) => void;
+    isWholeGridSelected: boolean;
+    selectEntireGrid: () => void;
+    onUndo: () => void;
+    onRedo: () => void;
+    onClearSelection: () => void;
+    enableClearOnDelete: boolean;
+    onToggleCheckboxCell: (cell: CellCoord) => void;
+    onToggleGroup: (groupKey: string) => void;
+};
+export type KeyboardController<T> = {
+    update: (args: KeyboardControllerArgs<T>) => void;
+    handleKeyDown: (event: GridKeyboardEventLike) => Promise<void>;
+};
+export declare const createKeyboardController: <T>() => KeyboardController<T>;

package/dist/controllers/panelHeaderDragController.d.ts

@@ -0,0 +1,21 @@
+export type PanelHeaderDragPointerDown = {
+    button: number;
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+    target: EventTarget | null;
+    preventDefault: () => void;
+};
+export type PanelHeaderDragStartArgs = {
+    layout: {
+        top: number;
+        left: number;
+    } | null;
+    onMove: (top: number, left: number) => void;
+};
+export type PanelHeaderDragController = {
+    startFromPointerDown: (event: PanelHeaderDragPointerDown, args: PanelHeaderDragStartArgs) => boolean;
+    isActive: () => boolean;
+    dispose: () => void;
+};
+export declare const createPanelHeaderDragController: () => PanelHeaderDragController;

package/dist/controllers/pointerInteractionsController.d.ts

@@ -0,0 +1,74 @@
+import { type GridUiAction } from '../model/gridActions';
+import type { CellCoord, GridColumn, GridUiState } from '../model/gridTypes';
+import { type GridPaneLayout } from '../logic/geometry';
+import { type RowMetrics } from '../logic/verticalGeometry';
+export declare const TOUCH_TAP_SLOP_PX = 10;
+export declare const TOUCH_DOUBLE_TAP_MS = 300;
+type MutableRef<V> = {
+    current: V;
+};
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type GridPointerEventLike = {
+    button: number;
+    pointerType: string;
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+    shiftKey: boolean;
+    preventDefault: () => void;
+};
+export type PointerInteractionsArgs<T> = {
+    gridRootRef: ReadonlyRef<HTMLElement | null>;
+    bodyScrollRef: ReadonlyRef<HTMLElement | null>;
+    scrollContainerRef: ReadonlyRef<HTMLElement | null>;
+    leftPaneScrollRef: ReadonlyRef<HTMLElement | null>;
+    rightPaneScrollRef: ReadonlyRef<HTMLElement | null>;
+    pointerClientRef: MutableRef<{
+        x: number;
+        y: number;
+    } | null>;
+    autoScrollFrameRef: MutableRef<number | null>;
+    uiState: GridUiState;
+    dispatch: (action: GridUiAction) => void;
+    enableRangeSelection: boolean;
+    enableSorting: boolean;
+    orderedColumns: GridColumn<T>[];
+    filteredRowsLength: number;
+    visibleColumnsLength: number;
+    paneLayout: GridPaneLayout<T>;
+    leftLeadingWidth: number;
+    centerLeadingWidth: number;
+    rightLeadingWidth: number;
+    headerHeight: number;
+    rowMetrics: RowMetrics;
+    verticalScaleFactor: number;
+    setHoveredRowIndex: (value: number | null) => void;
+    setHoveredColumnIndex: (value: number | null) => void;
+    enableRowHover: boolean;
+    enableColumnHeaderHover: boolean;
+    enableRowSelection: boolean;
+    onGutterRowSelect: (viewIndex: number, opts: {
+        shiftKey: boolean;
+    }) => void;
+    onGutterRowSelectDrag: (viewIndex: number) => void;
+    onCellDoubleClickRef: ReadonlyRef<(cell: CellCoord) => void>;
+};
+export type PointerInteractionsController<T> = {
+    update: (args: PointerInteractionsArgs<T>) => void;
+    updateSelectionFromPointer: (clientX: number, clientY: number) => void;
+    handleCellPointerDown: (cell: CellCoord, event: GridPointerEventLike) => void;
+    handleCellDoubleClick: (cell: CellCoord) => void;
+    handleCellPointerEnter: (cell: CellCoord, event: GridPointerEventLike) => void;
+    handleNativeDragStart: (event: {
+        preventDefault: () => void;
+    }) => void;
+    handleRowHeaderPointerDown: (rowIndex: number, event: GridPointerEventLike) => void;
+    handleRowHeaderPointerEnter: (rowIndex: number, event: GridPointerEventLike) => void;
+    handleColumnHeaderPointerDown: (colIndex: number, event: GridPointerEventLike) => void;
+    handleColumnHeaderPointerEnter: (colIndex: number, event: GridPointerEventLike) => void;
+    dispose: () => void;
+};
+export declare const createPointerInteractionsController: <T>() => PointerInteractionsController<T>;
+export {};

package/dist/controllers/popoverSupport.d.ts

@@ -0,0 +1,18 @@
+export type ReadonlyElementRef<E extends HTMLElement = HTMLElement> = {
+    readonly current: E | null;
+};
+export declare const blurForPopover: (gridRoot: HTMLElement | null) => void;
+export declare const restoreGridFocus: (gridRootRef: ReadonlyElementRef) => void;
+export type PopoverWindowHandlers = {
+    onResize?: () => void;
+    onScroll?: (event: Event) => void;
+    isInside: (target: Node) => boolean;
+    onOutsidePointerDown: () => void;
+    onKeyDown?: (event: KeyboardEvent) => void;
+};
+export type PopoverWindowBindings = {
+    attach: () => void;
+    detach: () => void;
+    isAttached: () => boolean;
+};
+export declare const createPopoverWindowBindings: (handlers: PopoverWindowHandlers) => PopoverWindowBindings;

package/dist/controllers/rowDragController.d.ts

@@ -0,0 +1,40 @@
+import type { RowMetrics } from '../logic/verticalGeometry';
+import type { GridResolvedSlot } from '../model/gridTypes';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type RowDragArgs = {
+    enabled: boolean;
+    rowMetrics: RowMetrics;
+    headerHeight: number;
+    verticalScaleFactor: number;
+    windowBaseOffsetPx: number;
+    scrollContainerRef: ReadonlyRef<HTMLElement | null>;
+    bodyScrollRef: ReadonlyRef<HTMLElement | null>;
+    leftIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    centerIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    rightIndicatorRef: ReadonlyRef<HTMLElement | null>;
+    getRowDragLabel: (viewIndex: number) => string;
+    commitRowMove: (fromIndex: number, toIndex: number) => void;
+    ghostSlot?: GridResolvedSlot;
+};
+export type RowDragHandlePointerEvent = {
+    button: number;
+    pointerId: number;
+    clientX: number;
+    clientY: number;
+    currentTarget: {
+        setPointerCapture: (pointerId: number) => void;
+        releasePointerCapture: (pointerId: number) => void;
+    };
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export type RowDragController = {
+    update: (args: RowDragArgs) => void;
+    onRowDragHandlePointerDown: (viewIndex: number, event: RowDragHandlePointerEvent) => void;
+    applyReorderSettle: () => void;
+    dispose: () => void;
+};
+export declare const createRowDragController: () => RowDragController;
+export {};

package/dist/controllers/selectOptionsCollector.d.ts

@@ -0,0 +1,31 @@
+import type { GridColumn } from '../model/gridTypes';
+import { type SelectOptionEntry } from '../logic/selectOptions';
+export declare const ASYNC_SELECT_COLLECT_ROW_THRESHOLD = 50000;
+export type ColumnSelectOptionsStatus = 'idle' | 'collecting' | 'ready';
+export type ColumnSelectOptionsResult = {
+    status: ColumnSelectOptionsStatus;
+    options: SelectOptionEntry[];
+    allValues: ReadonlySet<string>;
+    progress: number;
+};
+export declare const IDLE_SELECT_OPTIONS_RESULT: ColumnSelectOptionsResult;
+export type RawValueAccessor = (index: number) => unknown;
+export declare const resolveSyncSelectOptions: <T>(column: GridColumn<T> | null, rowCount: number, getRawValueAt: RawValueAccessor) => ColumnSelectOptionsResult | null;
+export type SelectOptionsCollectorArgs = {
+    needsAsync: boolean;
+    rowCount: number;
+    getRawValueAt: RawValueAccessor;
+};
+export type SelectOptionsCollectSnapshot = {
+    source: RawValueAccessor | null;
+    rowCount: number;
+    result: ColumnSelectOptionsResult;
+};
+export declare const selectCollectorResult: (snapshot: SelectOptionsCollectSnapshot, rowCount: number, getRawValueAt: RawValueAccessor) => ColumnSelectOptionsResult;
+export type SelectOptionsCollector = {
+    update: (args: SelectOptionsCollectorArgs) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => SelectOptionsCollectSnapshot;
+    dispose: () => void;
+};
+export declare const createSelectOptionsCollector: () => SelectOptionsCollector;

package/dist/controllers/serverSideRowModel.d.ts

@@ -0,0 +1,36 @@
+import type { GridRowKey, RowModel, ServerSideDataSource, ServerSideLoadErrorParams, ServerSideQuery, ServerSideWriteErrorParams } from '../model/gridTypes';
+import { type ServerSideCellEditInput } from '../logic/serverSideEdits';
+export type ServerSideRowModelArgs<T> = {
+    dataSource?: ServerSideDataSource<T>;
+    rowKeyGetter: (row: T, index: number) => GridRowKey;
+    query: ServerSideQuery;
+    queryKey: string;
+    refreshToken?: number;
+    onLoadError?: (error: unknown, params: ServerSideLoadErrorParams) => void;
+    onWriteError?: (error: unknown, params: ServerSideWriteErrorParams<T>) => void;
+    debounceMs?: number;
+};
+export type ServerSideLoadErrorState = {
+    failedBlockCount: number;
+};
+export type ServerSideWriteErrorState = {
+    failedRowCount: number;
+};
+export type ServerSideRowModelSnapshot<T> = {
+    rowModel: RowModel<T>;
+    rowCount: number;
+    loadError: ServerSideLoadErrorState | null;
+    writeError: ServerSideWriteErrorState | null;
+};
+export type ServerSideRowModelController<T> = {
+    update: (args: ServerSideRowModelArgs<T>) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ServerSideRowModelSnapshot<T>;
+    isRowLoaded: (viewIndex: number) => boolean;
+    requestRange: (startIndex: number, endIndex: number) => void;
+    refresh: () => void;
+    retryFailedBlocks: () => void;
+    applyCellEdits: (edits: ServerSideCellEditInput<T>[]) => number;
+    dispose: () => void;
+};
+export declare const createServerSideRowModel: <T>(initial: ServerSideRowModelArgs<T>) => ServerSideRowModelController<T>;

package/dist/controllers/systemColorSchemeStore.d.ts

@@ -0,0 +1,5 @@
+export declare const systemColorSchemeStore: {
+    subscribe(onChange: () => void): () => void;
+    getSnapshot(): boolean;
+    getServerSnapshot(): boolean;
+};

package/dist/controllers/toolPanelController.d.ts

@@ -0,0 +1,36 @@
+import { type ReadonlyElementRef } from './popoverSupport';
+export type ToolPanelTab = 'filter' | 'columns' | 'sort';
+export type ToolPanelLayout = {
+    top: number;
+    left: number;
+    width: number;
+};
+export type ToolPanelControllerArgs = {
+    canUseFilterTab: boolean;
+    canUseColumnsTab: boolean;
+    canUseSortTab: boolean;
+    gridRootRef: ReadonlyElementRef;
+    alliedRef?: ReadonlyElementRef;
+    suppressEscape?: boolean;
+    onSuppressedEscape?: () => void;
+};
+export type ToolPanelSnapshot = {
+    requestedTab: ToolPanelTab | null;
+    layout: ToolPanelLayout | null;
+    flashTick: number;
+};
+export type ToolPanelController = {
+    update: (args: ToolPanelControllerArgs) => void;
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ToolPanelSnapshot;
+    panelRef: {
+        current: HTMLDivElement | null;
+    };
+    open: (tab: ToolPanelTab) => void;
+    close: () => void;
+    move: (top: number, left: number) => void;
+    dispose: () => void;
+};
+export declare const resolveAvailableToolPanelTabs: (args: Pick<ToolPanelControllerArgs, "canUseFilterTab" | "canUseColumnsTab" | "canUseSortTab">) => ToolPanelTab[];
+export declare const resolveActiveToolPanelTab: (requestedTab: ToolPanelTab | null, availableTabs: ToolPanelTab[]) => ToolPanelTab | null;
+export declare const createToolPanelController: () => ToolPanelController;

package/dist/controllers/tooltipController.d.ts

@@ -0,0 +1,6 @@
+import type { GridResolvedSlot } from '../model/gridTypes.core';
+export type TooltipController = {
+    setSlot: (slot: GridResolvedSlot | undefined) => void;
+    dispose: () => void;
+};
+export declare function acquireTooltipController(slot?: GridResolvedSlot): TooltipController;