@ishibashi0112/spreadsheet-grid 0.37.0 → 0.38.0

package/dist/controllers/autoHeightMeasurer.d.ts

@@ -0,0 +1,30 @@
+import type { GridRowKey, RowModel } from '../model/gridTypes';
+import { type RowHeightStore } from '../logic/rowHeightStore';
+import type { RowMetrics, VerticalGeometry } from '../logic/verticalGeometry';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type AutoHeightMeasureArgs<T> = {
+    scrollContainerRef: ReadonlyRef<HTMLElement | null>;
+    autoHeightActive: boolean;
+    rowHeightStore: RowHeightStore | null;
+    rowMetrics: RowMetrics;
+    rowModel: RowModel<T>;
+    virtualRows: VerticalGeometry['rows'];
+    viewportHeight: number;
+    version: number;
+    nonce: number;
+};
+export type AutoHeightMeasureSnapshot = {
+    version: number;
+    nonce: number;
+};
+export type AutoHeightMeasurer<T> = {
+    update: (args: AutoHeightMeasureArgs<T>) => void;
+    getSnapshot: () => AutoHeightMeasureSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    measuredHeights: Map<GridRowKey, number>;
+    dispose: () => void;
+};
+export declare const createAutoHeightMeasurer: <T>() => AutoHeightMeasurer<T>;
+export {};

package/dist/controllers/columnAutosizeRunner.d.ts

@@ -1,12 +1,12 @@
 import { gridActions } from '../model/gridActions';
-import type { GridColumn, RowModel } from '../model/gridTypes';
+import type { AutoSizeColumnsMode, GridColumn, RowModel } from '../model/gridTypes';
 type ReadonlyRef<V> = {
     readonly current: V;
 };
 export type ColumnAutosizeRunnerArgs<T> = {
-    rowModelRef: ReadonlyRef<RowModel<T>>;
+    rowModel: RowModel<T>;
     gridRootRef: ReadonlyRef<HTMLElement | null>;
-    columnWidthsRef: ReadonlyRef<Record<string, number>>;
+    columnWidths: Record<string, number>;
     dispatch: (action: ReturnType<typeof gridActions.syncColumnWidths>) => void;
 };
 export type ColumnAutosizeRunner<T> = {
@@ -17,4 +17,15 @@ export type ColumnAutosizeRunner<T> = {
     dispose: () => void;
 };
 export declare const createColumnAutosizeRunner: <T>() => ColumnAutosizeRunner<T>;
+export type AutoSizeOnDataArgs<T> = {
+    mode: AutoSizeColumnsMode;
+    isServerSide: boolean;
+    rows: T[];
+    visibleColumns: GridColumn<T>[];
+    runAutosize: (columns: GridColumn<T>[]) => Promise<void>;
+};
+export type AutoSizeOnDataTrigger<T> = {
+    update: (args: AutoSizeOnDataArgs<T>) => void;
+};
+export declare const createAutoSizeOnDataTrigger: <T>() => AutoSizeOnDataTrigger<T>;
 export {};

package/dist/controllers/debouncedValueStore.d.ts

@@ -0,0 +1,11 @@
+export type DebouncedValueArgs<V> = {
+    value: V;
+    enabled: boolean;
+};
+export type DebouncedValueStore<V> = {
+    update: (args: DebouncedValueArgs<V>) => void;
+    getSnapshot: () => V;
+    subscribe: (listener: () => void) => () => void;
+    dispose: () => void;
+};
+export declare const createDebouncedValueStore: <V>(initial: V, delayMs: number) => DebouncedValueStore<V>;

package/dist/controllers/scrollSyncController.d.ts

@@ -0,0 +1,17 @@
+import type { GridScrollEventParams } from '../model/gridTypes';
+import type { GridViewStatePatch } from '../model/gridStore';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type ScrollSyncArgs = {
+    scrollContainerRef: ReadonlyRef<HTMLElement | null>;
+    setViewState: (patch: GridViewStatePatch) => void;
+    onScroll: ((params: GridScrollEventParams) => void) | undefined;
+};
+export type ScrollSyncController = {
+    update: (args: ScrollSyncArgs) => void;
+    markApiScroll: () => void;
+    dispose: () => void;
+};
+export declare const createScrollSyncController: () => ScrollSyncController;
+export {};

package/dist/engine/columnCommands.d.ts

@@ -0,0 +1,56 @@
+import type { GridColumn, GridColumnPinned, GridSortState } from '../model/gridTypes';
+import { type GridUiAction } from '../model/gridActions';
+import { type InitialColumnState } from '../logic/columnReset';
+import type { ToolPanelTab } from '../controllers/toolPanelController';
+export type ColumnCommandsArgs<T> = {
+    columns: GridColumn<T>[];
+    visibleColumns: GridColumn<T>[];
+    orderedColumns: GridColumn<T>[];
+    columnWidths: Record<string, number>;
+    onColumnsChange: ((columns: GridColumn<T>[]) => void) | undefined;
+    dispatch: (action: GridUiAction) => void;
+    enableSorting: boolean;
+    sort: GridSortState;
+    globalFilterText: string;
+    closeColumnMenu: () => void;
+    openToolPanel: (tab: ToolPanelTab) => void;
+    openColumnFilterPopover: (column: GridColumn<T>) => void;
+    runAutosize: (columns: GridColumn<T>[]) => Promise<void> | void;
+};
+export type SortDirection = 'asc' | 'desc';
+export type ColumnCommands<T> = {
+    update: (args: ColumnCommandsArgs<T>) => void;
+    handleColumnMenuPinnedChange: (columnKey: string, nextPinned: GridColumnPinned | undefined) => void;
+    handleColumnMenuAutosizeColumn: (columnKey: string) => void;
+    handleColumnMenuAutosizeAllColumns: () => void;
+    handleColumnMenuOpenChooser: () => void;
+    handleColumnMenuOpenSortManager: () => void;
+    handleColumnMenuOpenFilter: (column: GridColumn<T>) => void;
+    handleColumnMenuOpenFilterManager: () => void;
+    handleColumnMenuResetColumns: () => void;
+    handleColumnMenuSortChange: (columnKey: string, direction: SortDirection) => void;
+    handleFilterManagerClearFilter: (columnKey: string) => void;
+    handleFilterManagerClearAll: () => void;
+    handleFilterManagerClearGlobal: () => void;
+    handleColumnChooserToggleVisibility: (columnKey: string, nextVisible: boolean) => void;
+    handleColumnChooserShowAll: () => void;
+    handleColumnChooserHideAll: () => void;
+    handleColumnChooserReorder: (orderedKeys: string[]) => void;
+    handleColumnChooserReset: () => void;
+    applyColumnOrderAndPin: (orderedKeys: string[], pinOverride?: Map<string, GridColumnPinned | undefined>) => void;
+    handleSortManagerAddLevel: (columnKey: string, direction: SortDirection) => void;
+    handleSortManagerChangeDirection: (index: number, direction: SortDirection) => void;
+    handleSortManagerChangeColumn: (index: number, columnKey: string) => void;
+    handleSortManagerRemoveLevel: (index: number) => void;
+    handleSortManagerClearAll: () => void;
+    handleSortManagerMove: (from: number, to: number) => void;
+    handleColumnResizePointerDown: (column: GridColumn<T>, event: ColumnResizePointerEvent) => void;
+    getInitialColumnState: () => Map<string, InitialColumnState> | null;
+};
+export type ColumnResizePointerEvent = {
+    timeStamp: number;
+    clientX: number;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+};
+export declare const createColumnCommands: <T>() => ColumnCommands<T>;

package/dist/engine/columnLayout.d.ts

@@ -0,0 +1,43 @@
+import type { GridColumn } from '../model/gridTypes';
+import { type GridPaneLayout, type PaneSourceColumns } from '../logic/geometry';
+export type ColumnResolutionInputs<T> = {
+    columns: GridColumn<T>[];
+    isServerSide: boolean;
+    enableRowDrag: boolean;
+    hasRowsChange: boolean;
+    detailToggleColumnActive: boolean;
+    renderDetailToggleCell: NonNullable<GridColumn<T>['renderCell']>;
+};
+export type ColumnResolution<T> = {
+    groupColumns: GridColumn<T>[];
+    aggColumns: GridColumn<T>[];
+    rowGroupingActive: boolean;
+    rowDragAvailable: boolean;
+    effectiveColumns: GridColumn<T>[];
+    visibleColumns: GridColumn<T>[];
+    orderedColumns: GridColumn<T>[];
+};
+export declare const createColumnResolver: <T>() => (inputs: ColumnResolutionInputs<T>) => ColumnResolution<T>;
+export type PaneLayoutInputs<T> = {
+    orderedColumns: GridColumn<T>[];
+    columnWidths: Record<string, number>;
+    viewportWidth: number;
+    rowHeaderWidth: number;
+};
+export type PaneLayoutResolution<T> = {
+    paneSourceColumns: PaneSourceColumns<T>;
+    hasFlexColumn: boolean;
+    effectiveColumnWidths: Record<string, number>;
+    paneLayout: GridPaneLayout<T>;
+    hasLeftPane: boolean;
+    hasRightPane: boolean;
+    centerOwnsRowHeader: boolean;
+    leftLeadingWidth: number;
+    centerLeadingWidth: number;
+    rightLeadingWidth: number;
+    leftPaneTotalWidth: number;
+    rightPaneTotalWidth: number;
+    centerContentWidth: number;
+    totalScrollWidth: number;
+};
+export declare const createPaneLayoutResolver: <T>() => (inputs: PaneLayoutInputs<T>) => PaneLayoutResolution<T>;

package/dist/engine/createGridEngine.d.ts

@@ -0,0 +1,46 @@
+import { type GridStore } from '../model/gridStore';
+import { type DetailIndexCacheHolder } from '../logic/detailRow';
+import { type AutoHeightMeasurer } from '../controllers/autoHeightMeasurer';
+import { type ScrollSyncController } from '../controllers/scrollSyncController';
+import { type DebouncedValueStore } from '../controllers/debouncedValueStore';
+import { type AutoSizeOnDataTrigger } from '../controllers/columnAutosizeRunner';
+import { type ColumnResolution, type ColumnResolutionInputs, type PaneLayoutInputs, type PaneLayoutResolution } from './columnLayout';
+import { type RowPipelineResolver, type ServerSideQueryResolution } from './rowPipeline';
+import { type VerticalLayoutInputs, type VerticalLayoutResolution } from './verticalLayout';
+import { type ColumnCommands } from './columnCommands';
+import { type FilterPopoverCommands, type FilterPopoverDerived, type FilterPopoverDerivedInputs } from './filterPopoverCommands';
+import { type RowSelectionCommands } from './rowSelectionCommands';
+import { type GridApi } from './gridApi';
+import { type DetailKeysNotifier, type HoverRowNotifier, type StateChangeNotifier } from './notifiers';
+export declare const SERVER_SIDE_QUERY_DEBOUNCE_MS = 300;
+export type GridEngineInit<T> = {
+    columnInputs: ColumnResolutionInputs<T>;
+    serverSide: {
+        isServerSide: boolean;
+        enableGlobalFilter: boolean;
+        enableColumnFilter: boolean;
+        enableSorting: boolean;
+    };
+};
+export type GridEngine<T> = {
+    store: GridStore;
+    resolveColumns: (inputs: ColumnResolutionInputs<T>) => ColumnResolution<T>;
+    resolvePaneLayout: (inputs: PaneLayoutInputs<T>) => PaneLayoutResolution<T>;
+    rowPipeline: RowPipelineResolver<T>;
+    resolveVerticalLayout: (inputs: VerticalLayoutInputs<T>) => VerticalLayoutResolution;
+    resolveFilterPopoverDerived: (inputs: FilterPopoverDerivedInputs<T>) => FilterPopoverDerived;
+    columnCommands: ColumnCommands<T>;
+    filterPopoverCommands: FilterPopoverCommands<T>;
+    rowSelectionCommands: RowSelectionCommands<T>;
+    gridApi: GridApi<T>;
+    hoverRowNotifier: HoverRowNotifier;
+    detailKeysNotifier: DetailKeysNotifier;
+    stateChangeNotifier: StateChangeNotifier<T>;
+    autoHeightMeasurer: AutoHeightMeasurer<T>;
+    scrollSync: ScrollSyncController;
+    serverSideQueryStore: DebouncedValueStore<ServerSideQueryResolution>;
+    autoSizeOnData: AutoSizeOnDataTrigger<T>;
+    detailIndexCache: DetailIndexCacheHolder;
+    dispose: () => void;
+};
+export declare const createGridEngine: <T>(init: GridEngineInit<T>) => GridEngine<T>;

package/dist/engine/filterPopoverCommands.d.ts

@@ -0,0 +1,56 @@
+import type { ColumnFilterUiType, ColumnFilterValue, GridColumn } from '../model/gridTypes';
+import { type GridUiAction } from '../model/gridActions';
+import { type ColumnFilterSetSelection } from '../logic/setFilterSelection';
+import { type NumberFilterConditionDraft } from '../logic/numberFilterCondition';
+import { type TextFilterConditionDraft } from '../logic/textFilterCondition';
+import { type DateFilterConditionDraft } from '../logic/dateFilterCondition';
+import type { SelectOptionEntry } from '../logic/selectOptions';
+export type FilterPopoverDerivedInputs<T> = {
+    openedFilterColumn: GridColumn<T> | null;
+    openedFilterType: ColumnFilterUiType | null;
+    openedFilterSelectOptions: SelectOptionEntry[];
+    openedFilterAllValues: ReadonlySet<string>;
+    columnFilters: Record<string, ColumnFilterValue>;
+};
+export type FilterPopoverDerived = {
+    isDateSetFilterColumn: boolean;
+    openedPopoverSelectOptions: SelectOptionEntry[];
+    openedPopoverAllValues: ReadonlySet<string>;
+    openedSetFilterValue: ColumnFilterValue | undefined;
+    openedSetSelection: ColumnFilterSetSelection | null;
+    openedColumnCanInvert: boolean;
+    isComboFilterColumn: boolean;
+};
+export declare const createFilterPopoverDerivedResolver: <T>() => (inputs: FilterPopoverDerivedInputs<T>) => FilterPopoverDerived;
+export type FilterPopoverStateLike = {
+    columnKey: string;
+    draftValue: string;
+    numberDraft: NumberFilterConditionDraft | null;
+};
+export type FilterPopoverCommandsArgs<T> = {
+    filterPopoverState: FilterPopoverStateLike | null;
+    openedFilterColumn: GridColumn<T> | null;
+    openedFilterType: ColumnFilterUiType | null;
+    columnFilters: Record<string, ColumnFilterValue>;
+    derived: FilterPopoverDerived;
+    dispatch: (action: GridUiAction) => void;
+    closeColumnFilterPopover: () => void;
+    updateNumberDraft: (draft: NumberFilterConditionDraft) => void;
+    updateTextDraft: (draft: TextFilterConditionDraft) => void;
+    updateDateDraft: (draft: DateFilterConditionDraft) => void;
+};
+export type FilterPopoverCommands<T> = {
+    update: (args: FilterPopoverCommandsArgs<T>) => void;
+    handleSetFilterValueToggle: (value: string) => void;
+    handleSetFilterSelectAllChange: (scope: 'all' | string[], nextChecked: boolean) => void;
+    handleSetFilterReplaceSelection: (values: string[]) => void;
+    clearSetFilterPopoverValue: () => void;
+    handleNumberConditionDraftChange: (draft: NumberFilterConditionDraft) => void;
+    handleTextConditionDraftChange: (draft: TextFilterConditionDraft) => void;
+    handleDateConditionDraftChange: (draft: DateFilterConditionDraft) => void;
+    handleComboConditionClear: () => void;
+    handleComboSelectionClear: () => void;
+    applyFilterPopoverValue: () => void;
+    clearFilterPopoverValue: () => void;
+};
+export declare const createFilterPopoverCommands: <T>() => FilterPopoverCommands<T>;

package/dist/engine/gridApi.d.ts

@@ -0,0 +1,61 @@
+import type { DetailRowOptions, GridColumn, GridRowKey, GridUiState, RowModel, RowSelectionState, ScrollAlign, SpreadsheetGridHandle, SpreadsheetGridProps } from '../model/gridTypes';
+import { type GridUiAction } from '../model/gridActions';
+import { type GridPaneLayout } from '../logic/geometry';
+import { type RowMetrics } from '../logic/verticalGeometry';
+import { type DetailIndexCache } from '../logic/detailRow';
+import { type GroupTree } from '../logic/grouping';
+import type { ToolPanelTab } from '../controllers/toolPanelController';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type GridApiArgs<T> = {
+    scrollContainerRef: ReadonlyRef<HTMLElement | null>;
+    dispatch: (action: GridUiAction) => void;
+    rowModel: RowModel<T>;
+    viewRowCount: number;
+    leafRowCount: number;
+    groupTree: GroupTree<T> | null;
+    rowMetrics: RowMetrics;
+    paneLayout: GridPaneLayout<T>;
+    orderedColumns: GridColumn<T>[];
+    columns: GridColumn<T>[];
+    onColumnsChange: ((nextColumns: GridColumn<T>[]) => void) | undefined;
+    uiState: GridUiState;
+    headerHeight: number;
+    verticalScaleFactor: number;
+    leftPaneTotalWidth: number;
+    rightPaneTotalWidth: number;
+    centerLeadingWidth: number;
+    windowFirstRow: number;
+    windowLastRow: number;
+    physicalBodyHeight: number;
+    rows: T[];
+    isServerSide: boolean;
+    serverSideRefresh: () => void;
+    resolvedRowKeyGetter: (row: T, sourceRowIndex: number) => GridRowKey;
+    isRowExportable: SpreadsheetGridProps<T>['isRowExportable'];
+    activeToolPanelTab: ToolPanelTab | null;
+    openToolPanel: (tab: ToolPanelTab) => void;
+    closeToolPanel: () => void;
+    undoRows: () => void;
+    redoRows: () => void;
+    canUndoRows: () => boolean;
+    canRedoRows: () => boolean;
+    clearUndoHistory: () => void;
+    detailRowEnabled: boolean;
+    detailIsExpandable: DetailRowOptions<T>['isExpandable'];
+    detailIndexCacheRef: ReadonlyRef<DetailIndexCache>;
+    moveRowByKey: (rowKey: GridRowKey, toIndex: number) => void;
+    commitRowSelection: (next: RowSelectionState) => void;
+    markApiScroll: () => void;
+};
+export type GridApi<T> = {
+    update: (args: GridApiArgs<T>) => void;
+    handle: SpreadsheetGridHandle<T>;
+    applyScroll: (logicalTop: number | null, left: number | null) => void;
+    verticalTargetFor: (viewRowIndex: number, align: ScrollAlign) => number | null;
+    horizontalTargetFor: (colIndex: number, align: ScrollAlign) => number | null;
+    scrollToCellInternal: (viewRowIndex: number, colIndex: number, align: ScrollAlign) => void;
+};
+export declare const createGridApi: <T>() => GridApi<T>;
+export {};

package/dist/engine/memo.d.ts

@@ -0,0 +1,2 @@
+export type MemoFn<Args extends readonly unknown[], R> = (...args: Args) => R;
+export declare const createMemo: <Args extends readonly unknown[], R>(compute: (...args: Args) => R) => MemoFn<Args, R>;

package/dist/engine/notifiers.d.ts

@@ -0,0 +1,35 @@
+import type { GridColumn, GridRowKey, GridSortState, GridState, GridUiState } from '../model/gridTypes';
+export type HoverRowNotifierArgs = {
+    enableRowHover: boolean;
+    isHoverControlled: boolean;
+    onHoveredRowChange: ((index: number | null, meta: {
+        source: 'pointer';
+    }) => void) | undefined;
+    setHoveredRowIndex: (index: number | null) => void;
+};
+export type HoverRowAction = number | null | ((current: number | null) => number | null);
+export type HoverRowNotifier = {
+    update: (args: HoverRowNotifierArgs) => void;
+    applyHoveredRowChange: (action: HoverRowAction) => void;
+};
+export declare const createHoverRowNotifier: () => HoverRowNotifier;
+export type DetailKeysNotifierArgs = {
+    expandedKeys: ReadonlySet<GridRowKey>;
+    onChange: ((keys: GridRowKey[]) => void) | undefined;
+};
+export type DetailKeysNotifier = {
+    update: (args: DetailKeysNotifierArgs) => void;
+};
+export declare const createDetailKeysNotifier: () => DetailKeysNotifier;
+export type StateChangeNotifierArgs<T> = {
+    columnWidths: GridUiState['columnWidths'];
+    filters: GridUiState['filters'];
+    sort: GridSortState;
+    dragState: GridUiState['dragState'];
+    columns: GridColumn<T>[];
+    onStateChange: ((state: GridState) => void) | undefined;
+};
+export type StateChangeNotifier<T> = {
+    update: (args: StateChangeNotifierArgs<T>) => void;
+};
+export declare const createStateChangeNotifier: <T>() => StateChangeNotifier<T>;

package/dist/engine/rowPipeline.d.ts

@@ -0,0 +1,50 @@
+import type { ColumnFilterValue, GridColumn, GridRowKey, GridSortState, RowModel, ServerSideQuery } from '../model/gridTypes';
+import { type RowOrder } from '../logic/filtering';
+import { type GroupTree, type GroupedDisplay } from '../logic/grouping';
+export type RowOrderInputs<T> = {
+    rows: T[];
+    visibleColumns: GridColumn<T>[];
+    columnFilters: Record<string, ColumnFilterValue>;
+    globalFilteredOrder: RowOrder;
+    sort: GridSortState;
+    rowDragAvailable: boolean;
+};
+export type RowOrderResolution = {
+    order: RowOrder;
+    orderIsIdentity: boolean;
+    rowDragOperable: boolean;
+};
+export type ClientSideRowModelInputs<T> = {
+    rows: T[];
+    order: RowOrder;
+    rowGroupingActive: boolean;
+    groupColumns: GridColumn<T>[];
+    aggColumns: GridColumn<T>[];
+    collapsedGroupKeys: ReadonlySet<string>;
+    rowKeyGetter: (row: T, index: number) => GridRowKey;
+};
+export type ClientSideRowModelResolution<T> = {
+    groupTree: GroupTree<T> | null;
+    groupedDisplay: GroupedDisplay | null;
+    rowModel: RowModel<T>;
+};
+export type ServerSideQueryInputs = {
+    isServerSide: boolean;
+    globalFilterEnabled: boolean;
+    globalText: string;
+    columnFilterEnabled: boolean;
+    columnFilters: Record<string, ColumnFilterValue>;
+    sortingEnabled: boolean;
+    sort: GridSortState;
+};
+export type ServerSideQueryResolution = {
+    query: ServerSideQuery;
+    queryKey: string;
+};
+export declare const createRowPipelineResolver: <T>() => {
+    resolveBaseOrder: (rowCount: number) => RowOrder;
+    resolveOrder: (inputs: RowOrderInputs<T>) => RowOrderResolution;
+    resolveClientSideRowModel: (inputs: ClientSideRowModelInputs<T>) => ClientSideRowModelResolution<T>;
+    resolveServerSideQuery: (inputs: ServerSideQueryInputs) => ServerSideQueryResolution;
+};
+export type RowPipelineResolver<T> = ReturnType<typeof createRowPipelineResolver<T>>;

package/dist/engine/rowSelectionCommands.d.ts

@@ -0,0 +1,21 @@
+import type { RowModel, RowSelectionModel, RowSelectionState } from '../model/gridTypes';
+import { type GridUiAction } from '../model/gridActions';
+export type RowSelectionCommandsArgs<T> = {
+    rowModel: RowModel<T>;
+    rowSelectionState: RowSelectionState;
+    rowSelectionMode: 'single' | 'multiple';
+    onRowSelectionChange: ((model: RowSelectionModel) => void) | undefined;
+    controlledRowSelectionModel: RowSelectionModel | undefined;
+    leafRowCount: number;
+    dispatch: (action: GridUiAction) => void;
+};
+export type RowSelectionCommands<T> = {
+    update: (args: RowSelectionCommandsArgs<T>) => void;
+    commitRowSelection: (next: RowSelectionState) => void;
+    handleGutterRowSelect: (viewIndex: number, opts: {
+        shiftKey: boolean;
+    }) => void;
+    handleGutterRowSelectDrag: (viewIndex: number) => void;
+    handleToggleSelectAllRows: () => void;
+};
+export declare const createRowSelectionCommands: <T>() => RowSelectionCommands<T>;

package/dist/engine/verticalLayout.d.ts

@@ -0,0 +1,52 @@
+import type { GridColumn, GridRowKey, RowModel } from '../model/gridTypes';
+import { type DetailRowExtra, type RowMetrics, type VerticalGeometry, type VerticalRow } from '../logic/verticalGeometry';
+import { type RowHeightStore } from '../logic/rowHeightStore';
+import { resolveDetailRowExtras, type DetailIndexCache } from '../logic/detailRow';
+type ReadonlyRef<V> = {
+    readonly current: V;
+};
+export type DetailLayerEntry = {
+    rowKey: GridRowKey;
+    virtualRow: VerticalRow;
+};
+type DetailIsExpandable<T> = Parameters<typeof resolveDetailRowExtras<T>>[0]['isExpandable'];
+export type VerticalLayoutInputs<T> = {
+    isServerSide: boolean;
+    autoHeight: boolean;
+    visibleColumns: GridColumn<T>[];
+    viewRowCount: number;
+    estimateRowHeight: number;
+    rowHeight: number;
+    headerHeight: number;
+    viewportHeight: number;
+    scrollTop: number;
+    rowModel: RowModel<T>;
+    measuredHeights: Map<GridRowKey, number>;
+    autoHeightVersion: number;
+    detailRowEnabled: boolean;
+    expandedDetailRowKeys: ReadonlySet<GridRowKey>;
+    detailHeight: number;
+    detailIsExpandable: DetailIsExpandable<T>;
+    detailIndexCacheRef: ReadonlyRef<DetailIndexCache>;
+};
+export type VerticalLayoutResolution = {
+    hasAutoHeightColumn: boolean;
+    autoHeightActive: boolean;
+    rowHeightStore: RowHeightStore | null;
+    baseRowMetrics: RowMetrics;
+    detailExtras: readonly DetailRowExtra[];
+    detailActive: boolean;
+    rowMetrics: RowMetrics;
+    verticalGeometry: VerticalGeometry;
+    virtualRows: VerticalGeometry['rows'];
+    virtualRowIndexes: VerticalGeometry['rowIndexSet'];
+    detailEntries: readonly DetailLayerEntry[];
+    windowFirstRow: number;
+    windowLastRow: number;
+    physicalBodyHeight: number;
+    bodyLayerTransform: string | undefined;
+    verticalScaleFactor: number;
+    overlayBaseOffset: number;
+};
+export declare const createVerticalLayoutResolver: <T>() => (inputs: VerticalLayoutInputs<T>) => VerticalLayoutResolution;
+export {};

package/dist/hooks/useController.d.ts

@@ -2,4 +2,6 @@ export type ControllerLike<Args> = {
     update: (args: Args) => void;
     dispose?: () => void;
 };
-export declare function useController<Args, C extends ControllerLike<Args>>(create: () => C, args: Args): C;
+export type ControllerUpdateTiming = 'layout' | 'passive';
+export declare function useControllerLifecycle<Args, C extends ControllerLike<Args>>(controller: C, args: Args, timing?: ControllerUpdateTiming): void;
+export declare function useController<Args, C extends ControllerLike<Args>>(create: () => C, args: Args, timing?: ControllerUpdateTiming): C;