@ishibashi0112/spreadsheet-grid 0.35.0 → 0.36.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/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/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/systemColorSchemeStore.d.ts

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

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;

package/dist/controllers/viewportSyncController.d.ts

@@ -0,0 +1,30 @@
+import type { ColumnMeasurement } from '../logic/geometry';
+import type { CellCoord } from '../model/gridTypes.core';
+export type ViewportCellRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export type ViewportSyncArgs<T> = {
+    scrollElement: HTMLElement | null;
+    columnVirtualizer: {
+        measure: () => void;
+    };
+    columnMeasurements: ColumnMeasurement<T>[];
+    totalScrollWidth: number;
+    physicalBodyHeight: number;
+    headerHeight: number;
+    leftPaneWidth: number;
+    rightPaneWidth: number;
+    centerLeadingWidth: number;
+    activeCellRect: ViewportCellRect | null;
+    activeCell: CellCoord | null;
+    verticalScaleFactor: number;
+};
+export type ViewportSyncController<T> = {
+    update: (args: ViewportSyncArgs<T>) => void;
+};
+export declare const clampScrollToContent: (scrollElement: HTMLElement, args: Pick<ViewportSyncArgs<unknown>, "totalScrollWidth" | "physicalBodyHeight" | "headerHeight">) => void;
+export declare const scrollCellIntoView: (scrollElement: HTMLElement, rect: ViewportCellRect, args: Pick<ViewportSyncArgs<unknown>, "headerHeight" | "leftPaneWidth" | "rightPaneWidth" | "centerLeadingWidth" | "verticalScaleFactor">) => void;
+export declare const createViewportSyncController: <T>() => ViewportSyncController<T>;

package/dist/hooks/useController.d.ts

@@ -0,0 +1,5 @@
+export type ControllerLike<Args> = {
+    update: (args: Args) => void;
+    dispose?: () => void;
+};
+export declare function useController<Args, C extends ControllerLike<Args>>(create: () => C, args: Args): C;

package/dist/hooks/useGridClipboardController.d.ts

@@ -1,25 +1,8 @@
-import { type Dispatch } from 'react';
-import { type GridUiAction } from '../model/gridActions';
-import type { GridColumn, SpreadsheetGridProps, GridUiState, RowModel } from '../model/gridTypes';
-import type { ServerSideCellEditInput } from '../logic/serverSideEdits';
-type UseGridClipboardControllerArgs<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: Dispatch<GridUiAction>;
-};
-export declare const useGridClipboardController: <T extends object>({ rows, rowModel, visibleColumns, uiState, readOnly, canEditCell, createRow, createOverflowColumn, onRowsChange, onColumnsChange, applyServerSideCellEdits, isRowExportable, dispatch, }: UseGridClipboardControllerArgs<T>) => {
+import { type ClipboardEvent } from 'react';
+import { type ClipboardControllerArgs } from '../controllers/clipboardController';
+export declare const useGridClipboardController: <T extends object>(args: ClipboardControllerArgs<T>) => {
     isWholeGridSelected: boolean;
     handleCopy: () => Promise<void>;
-    handlePaste: (event: React.ClipboardEvent<HTMLDivElement>) => void;
+    handlePaste: (event: ClipboardEvent<HTMLDivElement>) => void;
 };
 export default useGridClipboardController;

package/dist/hooks/useGridEditController.d.ts

@@ -1,23 +1,8 @@
-import { type Dispatch, type RefObject } from 'react';
-import { type GridUiAction } from '../model/gridActions';
-import type { CellCoord, EditorCommitDirection, EditorCommitResult, GridColumn, GridUiState, RowModel } from '../model/gridTypes';
-import type { ServerSideCellEditInput } from '../logic/serverSideEdits';
-type UseGridEditControllerArgs<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: Dispatch<GridUiAction>;
-    gridRootRef: RefObject<HTMLDivElement | null>;
-    editorActionGuardRef: RefObject<boolean>;
-};
-export declare const useGridEditController: <T extends object>({ uiState, rows, visibleColumns, rowModel, setEditorInitialValue, onRowsChange, applyServerSideCellEdits, dispatch, gridRootRef, editorActionGuardRef, }: UseGridEditControllerArgs<T>) => {
-    activateSingleCell: (cell: CellCoord) => void;
-    startEditWithValue: (cell: CellCoord, initialValue: string) => void;
-    commitEdit: (committedValue: unknown, direction?: EditorCommitDirection) => EditorCommitResult;
+import { type EditControllerArgs } from '../controllers/editController';
+export declare const useGridEditController: <T extends object>(args: EditControllerArgs<T>) => {
+    activateSingleCell: (cell: import("..").CellCoord) => void;
+    startEditWithValue: (cell: import("..").CellCoord, initialValue: string) => void;
+    commitEdit: (committedValue: unknown, direction?: import("..").EditorCommitDirection) => import("..").EditorCommitResult;
     cancelEdit: () => void;
 };
 export default useGridEditController;

package/dist/hooks/useGridHistoryController.d.ts

@@ -1,18 +1,5 @@
-import type { Dispatch } from 'react';
-import { type GridUiAction } from '../model/gridActions';
-import type { CellCoord, GridSelection, UndoRedoState } from '../model/gridTypes';
-type UseGridHistoryControllerArgs<T> = {
-    rows: T[];
-    selection: GridSelection;
-    activeCell: CellCoord | null;
-    onRowsChange?: (nextRows: T[]) => void;
-    dispatch: Dispatch<GridUiAction>;
-    enabled: boolean;
-    limit: number;
-    onUndoRedoStateChange?: (state: UndoRedoState) => void;
-    onAfterRestore?: (activeCell: CellCoord | null) => void;
-};
-export declare const useGridHistoryController: <T>({ rows, selection, activeCell, onRowsChange, dispatch, enabled, limit, onUndoRedoStateChange, onAfterRestore, }: UseGridHistoryControllerArgs<T>) => {
+import { type HistoryControllerArgs } from '../controllers/historyController';
+export declare const useGridHistoryController: <T>(args: HistoryControllerArgs<T>) => {
     handleRowsChange: ((nextRows: T[]) => void) | undefined;
     undo: () => void;
     redo: () => void;

package/dist/hooks/useGridKeyboardInteractions.d.ts

@@ -1,26 +1,6 @@
-import { type Dispatch, type KeyboardEvent } from 'react';
-import { type GridUiAction } from '../model/gridActions';
-import type { CellCoord, GridColumn, GridUiState, RowModel, SpreadsheetGridProps } from '../model/gridTypes';
-type UseGridKeyboardInteractionsArgs<T> = {
-    uiState: GridUiState;
-    rowModel: RowModel<T>;
-    visibleColumns: GridColumn<T>[];
-    readOnly: boolean;
-    canEditCell: SpreadsheetGridProps<T>['canEditCell'];
-    setEditorInitialValue: (value: string) => void;
-    dispatch: Dispatch<GridUiAction>;
-    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 declare const useGridKeyboardInteractions: <T>({ uiState, rowModel, visibleColumns, readOnly, canEditCell, setEditorInitialValue, dispatch, handleCopy, handleCellDoubleClick, isWholeGridSelected, selectEntireGrid, onUndo, onRedo, onClearSelection, enableClearOnDelete, onToggleCheckboxCell, onToggleGroup, }: UseGridKeyboardInteractionsArgs<T>) => {
+import { type KeyboardEvent } from 'react';
+import { type KeyboardControllerArgs } from '../controllers/keyboardController';
+export declare const useGridKeyboardInteractions: <T>(args: KeyboardControllerArgs<T>) => {
     handleKeyDown: (event: KeyboardEvent<HTMLDivElement>) => Promise<void>;
 };
 export default useGridKeyboardInteractions;

package/dist/hooks/useGridStore.d.ts

@@ -0,0 +1,7 @@
+import { type GridStore, type GridViewState, type Updater } from '../model/gridStore';
+import type { GridUiState } from '../model/gridTypes';
+export declare function useGridStore(store: GridStore): [GridUiState, GridStore['dispatch']];
+export type GridViewStateSetters = {
+    [K in keyof GridViewState as `set${Capitalize<K>}`]: (next: Updater<GridViewState[K]>) => void;
+};
+export declare function useGridViewState(store: GridStore): [GridViewState, GridViewStateSetters];

package/dist/hooks/useGridViewportSync.d.ts

@@ -1,23 +1,7 @@
 import { type RefObject } from 'react';
-import type { ActiveCellOverlayRect } from '../ActiveCellOverlay';
-import type { ColumnMeasurement } from '../logic/geometry';
-import type { CellCoord } from '../model/gridTypes';
-type VirtualizerLike = {
-    measure: () => void;
-};
-type UseGridViewportSyncArgs<T> = {
+import { type ViewportSyncArgs } from '../controllers/viewportSyncController';
+type UseGridViewportSyncArgs<T> = Omit<ViewportSyncArgs<T>, 'scrollElement'> & {
     scrollRef: RefObject<HTMLDivElement | null>;
-    columnVirtualizer: VirtualizerLike;
-    columnMeasurements: ColumnMeasurement<T>[];
-    totalScrollWidth: number;
-    physicalBodyHeight: number;
-    headerHeight: number;
-    leftPaneWidth: number;
-    rightPaneWidth: number;
-    centerLeadingWidth: number;
-    activeCellRect: ActiveCellOverlayRect | null;
-    activeCell: CellCoord | null;
-    verticalScaleFactor: number;
 };
-export declare const useGridViewportSync: <T>({ scrollRef, columnVirtualizer, columnMeasurements, totalScrollWidth, physicalBodyHeight, headerHeight, leftPaneWidth, rightPaneWidth, centerLeadingWidth, activeCellRect, activeCell, verticalScaleFactor, }: UseGridViewportSyncArgs<T>) => void;
+export declare const useGridViewportSync: <T>({ scrollRef, ...args }: UseGridViewportSyncArgs<T>) => void;
 export default useGridViewportSync;

package/dist/hooks/useResolvedGridTheme.d.ts

@@ -1,2 +1,3 @@
+import { type ResolvedGridTheme } from '../logic/theme';
 import type { GridTheme } from '../model/gridTypes';
-export declare function useResolvedGridTheme(theme: GridTheme): 'light' | 'dark';
+export declare function useResolvedGridTheme(theme: GridTheme): ResolvedGridTheme;