@keenmate/web-grid 1.0.0-rc09 → 1.0.0-rc11

package/dist/grid.d.ts

@@ -1,4 +1,4 @@
-import type { Column, CellValidationState, RowToolbarConfig, ContextMenuItem, RowShortcut, RowChangeDetail, ToolbarClickDetail, RowActionClickDetail, ContextMenuContext, HeaderMenuConfig, HeaderMenuContext, EditTrigger, EditStartSelection, EditingCell, FocusedCell, SortMode, SortState, DataRequestDetail, DataRequestTrigger, BeforeCommitResult, GridMode, ToggleVisibility, PaginationLabelsCallback, SummaryContentCallback, ValidationTooltipContext, ToolbarPosition, GridLabels, RowLockInfo, RowLockingOptions, RowLockChangeDetail, ColumnWidthState, ColumnResizeDetail, ColumnOrderState, ColumnReorderDetail, FillDragDetail, FillDirection, RangeShortcut } from './types.js';
+import type { Column, CellValidationState, RowToolbarConfig, ContextMenuItem, RowShortcut, RowChangeDetail, ToolbarClickDetail, RowActionClickDetail, ContextMenuContext, HeaderMenuConfig, HeaderMenuContext, EditTrigger, EditStartSelection, EditingCell, FocusedCell, SortMode, SortState, DataRequestDetail, DataRequestTrigger, BeforeCommitResult, GridMode, ToggleVisibility, PaginationLabelsCallback, SummaryContentCallback, ValidationTooltipContext, ToolbarPosition, GridLabels, RowLockInfo, RowLockingOptions, RowLockChangeDetail, ColumnWidthState, ColumnResizeDetail, ColumnOrderState, ColumnReorderDetail, FillDragDetail, FillDirection, RangeShortcut, CellSelectionMode, CellRange, CellSelectionChangeDetail } from './types.js';
 /**
  * WebGrid - Core logic class for the data grid
  *
@@ -9,25 +9,25 @@ export declare class WebGrid<T = unknown> {
     protected _items: T[];
     protected _columns: Column<T>[];
     protected _sortMode: SortMode;
-    protected _filterable: boolean;
-    protected _pageable: boolean;
+    protected _isFilterable: boolean;
+    protected _isPageable: boolean;
     protected _pageSize: number;
     protected _pageSizes: number[];
-    protected _striped: boolean;
-    protected _hoverable: boolean;
-    protected _editable: boolean;
+    protected _isStriped: boolean;
+    protected _isHoverable: boolean;
+    protected _isEditable: boolean;
     protected _editTrigger: EditTrigger;
     protected _editStartSelection: EditStartSelection;
     protected _mode: GridMode;
     protected _dropdownToggleVisibility: ToggleVisibility;
-    protected _dropdownShowOnFocus: boolean;
-    protected _openDropdownOnEnter: boolean;
-    protected _checkboxAlwaysEditable: boolean;
-    protected _showRowNumbers: boolean;
-    protected _stickyRowNumbers: boolean;
+    protected _shouldShowDropdownOnFocus: boolean;
+    protected _shouldOpenDropdownOnEnter: boolean;
+    protected _isCheckboxAlwaysEditable: boolean;
+    protected _isRowNumbersVisible: boolean;
+    protected _isStickyRowNumbers: boolean;
     protected _freezeColumns: number;
     protected _invalidCells: CellValidationState[];
-    protected _showRowToolbar: boolean;
+    protected _isRowToolbarVisible: boolean;
     protected _rowToolbar: RowToolbarConfig<T>[];
     protected _toolbarVerticalAlign: 'top' | 'center' | 'bottom';
     protected _toolbarHorizontalAlign: 'start' | 'center' | 'end' | 'cursor';
@@ -39,7 +39,7 @@ export declare class WebGrid<T = unknown> {
     protected _contextMenuYOffset: number;
     protected _headerContextMenu: HeaderMenuConfig<T>[] | undefined;
     protected _rowShortcuts: RowShortcut<T>[] | undefined;
-    protected _showShortcutsHelp: boolean;
+    protected _isShortcutsHelpVisible: boolean;
     protected _shortcutsHelpPosition: 'top-right' | 'top-left';
     protected _shortcutsHelpContentCallback: (() => string) | undefined;
     protected _idValueMember: keyof T | undefined;
@@ -48,15 +48,15 @@ export declare class WebGrid<T = unknown> {
     protected _externalLocks: Map<unknown, RowLockInfo>;
     protected _onrowlockchange: ((detail: RowLockChangeDetail<T>) => void) | undefined;
     protected _gridName: string | null;
-    protected _persistColumnWidths: boolean;
+    protected _shouldPersistColumnWidths: boolean;
     protected _columnWidths: Map<string, string>;
     protected _oncolumnresize: ((detail: ColumnResizeDetail) => void) | undefined;
-    protected _allowColumnReorder: boolean;
-    protected _persistColumnOrder: boolean;
+    protected _isColumnReorderAllowed: boolean;
+    protected _shouldPersistColumnOrder: boolean;
     protected _columnOrder: Map<string, number>;
     protected _oncolumnreorder: ((detail: ColumnReorderDetail) => void) | undefined;
     protected _fillDirection: FillDirection;
-    protected _onfilldrag: ((detail: FillDragDetail) => boolean | void) | undefined;
+    protected _fillDragCallback: ((detail: FillDragDetail) => boolean | void) | undefined;
     protected _onrowchange: ((detail: RowChangeDetail<T>) => void) | undefined;
     protected _onroweditstart: ((detail: {
         row: T;
@@ -95,15 +95,15 @@ export declare class WebGrid<T = unknown> {
     protected _summaryPosition?: string;
     protected _summaryContentCallback?: SummaryContentCallback<T>;
     protected _summaryMetadata: unknown;
-    protected _summaryInline: boolean;
+    protected _isSummaryInline: boolean;
     protected _customStylesCallback?: () => string;
     protected _rowClassCallback?: (row: T, rowIndex: number) => string | null;
     protected _labels: GridLabels;
-    protected _virtualScroll: boolean;
+    protected _isVirtualScrollEnabled: boolean;
     protected _virtualScrollThreshold: number;
     protected _virtualScrollRowHeight: number;
     protected _virtualScrollBuffer: number;
-    protected _infiniteScroll: boolean;
+    protected _isInfiniteScrollEnabled: boolean;
     protected _infiniteScrollThreshold: number;
     protected _hasMoreItems: boolean;
     protected _isLoadingMore: boolean;
@@ -122,26 +122,34 @@ export declare class WebGrid<T = unknown> {
     protected _selectedRows: Set<number>;
     protected _lastSelectedRowIndex: number | null;
     protected _rangeShortcuts: RangeShortcut<T>[];
+    protected _cellSelectionMode: CellSelectionMode;
+    protected _selectedCellRange: CellRange | null;
+    protected _lastClickedCell: {
+        rowIndex: number;
+        colIndex: number;
+    } | null;
+    protected _shouldCopyWithHeaders: boolean;
+    protected _oncellselectionchange: ((detail: CellSelectionChangeDetail) => void) | null;
     get items(): T[];
     set items(value: T[]);
     get columns(): Column<T>[];
     set columns(value: Column<T>[]);
     get sortMode(): SortMode;
     set sortMode(value: SortMode);
-    get filterable(): boolean;
-    set filterable(value: boolean);
-    get pageable(): boolean;
-    set pageable(value: boolean);
+    get isFilterable(): boolean;
+    set isFilterable(value: boolean);
+    get isPageable(): boolean;
+    set isPageable(value: boolean);
     get pageSize(): number;
     set pageSize(value: number);
     get pageSizes(): number[];
     set pageSizes(value: number[]);
-    get striped(): boolean;
-    set striped(value: boolean);
-    get hoverable(): boolean;
-    set hoverable(value: boolean);
-    get editable(): boolean;
-    set editable(value: boolean);
+    get isStriped(): boolean;
+    set isStriped(value: boolean);
+    get isHoverable(): boolean;
+    set isHoverable(value: boolean);
+    get isEditable(): boolean;
+    set isEditable(value: boolean);
     get editTrigger(): EditTrigger;
     set editTrigger(value: EditTrigger);
     get editStartSelection(): EditStartSelection;
@@ -154,20 +162,20 @@ export declare class WebGrid<T = unknown> {
      * Get effective toggle visibility for a column (column override or grid default)
      */
     getEffectiveToggleVisibility(column: Column<T>): ToggleVisibility;
-    get dropdownShowOnFocus(): boolean;
-    set dropdownShowOnFocus(value: boolean);
-    get openDropdownOnEnter(): boolean;
-    set openDropdownOnEnter(value: boolean);
-    /**
-     * Get effective openDropdownOnEnter for a column (column override or grid default)
-     */
-    getEffectiveOpenDropdownOnEnter(column: Column<T>): boolean;
-    get checkboxAlwaysEditable(): boolean;
-    set checkboxAlwaysEditable(value: boolean);
-    get showRowNumbers(): boolean;
-    set showRowNumbers(value: boolean);
-    get stickyRowNumbers(): boolean;
-    set stickyRowNumbers(value: boolean);
+    get shouldShowDropdownOnFocus(): boolean;
+    set shouldShowDropdownOnFocus(value: boolean);
+    get shouldOpenDropdownOnEnter(): boolean;
+    set shouldOpenDropdownOnEnter(value: boolean);
+    /**
+     * Get effective shouldOpenDropdownOnEnter for a column (column override or grid default)
+     */
+    getEffectiveShouldOpenDropdownOnEnter(column: Column<T>): boolean;
+    get isCheckboxAlwaysEditable(): boolean;
+    set isCheckboxAlwaysEditable(value: boolean);
+    get isRowNumbersVisible(): boolean;
+    set isRowNumbersVisible(value: boolean);
+    get isStickyRowNumbers(): boolean;
+    set isStickyRowNumbers(value: boolean);
     get freezeColumns(): number;
     set freezeColumns(value: number);
     /**
@@ -193,8 +201,8 @@ export declare class WebGrid<T = unknown> {
     get isValidating(): boolean;
     get currentCellError(): string | null;
     get hoveredRowIndex(): number | null;
-    get showRowToolbar(): boolean;
-    set showRowToolbar(value: boolean);
+    get isRowToolbarVisible(): boolean;
+    set isRowToolbarVisible(value: boolean);
     get rowToolbar(): RowToolbarConfig<T>[];
     set rowToolbar(value: RowToolbarConfig<T>[]);
     get toolbarVerticalAlign(): 'top' | 'center' | 'bottom';
@@ -221,8 +229,8 @@ export declare class WebGrid<T = unknown> {
     set headerContextMenu(value: HeaderMenuConfig<T>[] | undefined);
     get rowShortcuts(): RowShortcut<T>[] | undefined;
     set rowShortcuts(value: RowShortcut<T>[] | undefined);
-    get showShortcutsHelp(): boolean;
-    set showShortcutsHelp(value: boolean);
+    get isShortcutsHelpVisible(): boolean;
+    set isShortcutsHelpVisible(value: boolean);
     get shortcutsHelpPosition(): 'top-right' | 'top-left';
     set shortcutsHelpPosition(value: 'top-right' | 'top-left');
     get shortcutsHelpContentCallback(): (() => string) | undefined;
@@ -247,24 +255,24 @@ export declare class WebGrid<T = unknown> {
     set summaryContentCallback(value: SummaryContentCallback<T> | undefined);
     get summaryMetadata(): unknown;
     set summaryMetadata(value: unknown);
-    get summaryInline(): boolean;
-    set summaryInline(value: boolean);
+    get isSummaryInline(): boolean;
+    set isSummaryInline(value: boolean);
     get customStylesCallback(): (() => string) | undefined;
     set customStylesCallback(value: (() => string) | undefined);
     get rowClassCallback(): ((row: T, rowIndex: number) => string | null) | undefined;
     set rowClassCallback(value: ((row: T, rowIndex: number) => string | null) | undefined);
     get labels(): GridLabels;
     set labels(value: Partial<GridLabels>);
-    get virtualScroll(): boolean;
-    set virtualScroll(value: boolean);
+    get isVirtualScrollEnabled(): boolean;
+    set isVirtualScrollEnabled(value: boolean);
     get virtualScrollThreshold(): number;
     set virtualScrollThreshold(value: number);
     get virtualScrollRowHeight(): number;
     set virtualScrollRowHeight(value: number);
     get virtualScrollBuffer(): number;
     set virtualScrollBuffer(value: number);
-    get infiniteScroll(): boolean;
-    set infiniteScroll(value: boolean);
+    get isInfiniteScrollEnabled(): boolean;
+    set isInfiniteScrollEnabled(value: boolean);
     get infiniteScrollThreshold(): number;
     set infiniteScrollThreshold(value: number);
     get hasMoreItems(): boolean;
@@ -275,10 +283,6 @@ export declare class WebGrid<T = unknown> {
      * Check if virtual scroll should be used
      */
     shouldUseVirtualScroll(): boolean;
-    get showRowActions(): boolean;
-    set showRowActions(value: boolean);
-    get rowActions(): RowToolbarConfig<T>[];
-    set rowActions(value: RowToolbarConfig<T>[]);
     set onrowchange(value: ((detail: RowChangeDetail<T>) => void) | undefined);
     set onroweditstart(value: ((detail: {
         row: T;
@@ -324,20 +328,20 @@ export declare class WebGrid<T = unknown> {
     set onrowlockchange(value: ((detail: RowLockChangeDetail<T>) => void) | undefined);
     get gridName(): string | null;
     set gridName(value: string | null);
-    get persistColumnWidths(): boolean;
-    set persistColumnWidths(value: boolean);
+    get shouldPersistColumnWidths(): boolean;
+    set shouldPersistColumnWidths(value: boolean);
     get oncolumnresize(): ((detail: ColumnResizeDetail) => void) | undefined;
     set oncolumnresize(value: ((detail: ColumnResizeDetail) => void) | undefined);
-    get allowColumnReorder(): boolean;
-    set allowColumnReorder(value: boolean);
-    get persistColumnOrder(): boolean;
-    set persistColumnOrder(value: boolean);
+    get isColumnReorderAllowed(): boolean;
+    set isColumnReorderAllowed(value: boolean);
+    get shouldPersistColumnOrder(): boolean;
+    set shouldPersistColumnOrder(value: boolean);
     get oncolumnreorder(): ((detail: ColumnReorderDetail) => void) | undefined;
     set oncolumnreorder(value: ((detail: ColumnReorderDetail) => void) | undefined);
     get fillDirection(): FillDirection;
     set fillDirection(value: FillDirection);
-    get onfilldrag(): ((detail: FillDragDetail) => boolean | void) | undefined;
-    set onfilldrag(value: ((detail: FillDragDetail) => boolean | void) | undefined);
+    get fillDragCallback(): ((detail: FillDragDetail) => boolean | void) | undefined;
+    set fillDragCallback(value: ((detail: FillDragDetail) => boolean | void) | undefined);
     get selectedRows(): number[];
     get rangeShortcuts(): RangeShortcut<T>[];
     set rangeShortcuts(value: RangeShortcut<T>[]);
@@ -346,6 +350,44 @@ export declare class WebGrid<T = unknown> {
     selectRowRange(fromIndex: number, toIndex: number): void;
     clearSelection(): void;
     getSelectedRowsData(): T[];
+    /**
+     * Copy selected rows to clipboard in TSV format (Excel-compatible)
+     * @returns true if copy was successful, false if no selection or clipboard failed
+     */
+    copySelectedRowsToClipboard(): Promise<boolean>;
+    get cellSelectionMode(): CellSelectionMode;
+    set cellSelectionMode(value: CellSelectionMode);
+    get shouldCopyWithHeaders(): boolean;
+    set shouldCopyWithHeaders(value: boolean);
+    get selectedCellRange(): CellRange | null;
+    get lastClickedCell(): {
+        rowIndex: number;
+        colIndex: number;
+    } | null;
+    set lastClickedCell(value: {
+        rowIndex: number;
+        colIndex: number;
+    } | null);
+    get oncellselectionchange(): ((detail: CellSelectionChangeDetail) => void) | null;
+    set oncellselectionchange(value: ((detail: CellSelectionChangeDetail) => void) | null);
+    selectCellRange(range: CellRange): void;
+    clearCellSelection(): void;
+    getSelectedCells(): Array<{
+        row: T;
+        rowIndex: number;
+        colIndex: number;
+        field: string;
+        value: unknown;
+    }>;
+    /**
+     * Check if a cell is in the selected cell range
+     */
+    isCellInSelectedRange(rowIndex: number, colIndex: number): boolean;
+    /**
+     * Copy selected cell range to clipboard in TSV format (Excel-compatible)
+     * @returns true if copy was successful, false if no selection or clipboard failed
+     */
+    copyCellSelectionToClipboard(): Promise<boolean>;
     get isNavigateMode(): boolean;
     get filteredItems(): T[];
     get sortedItems(): T[];
@@ -369,6 +411,10 @@ export declare class WebGrid<T = unknown> {
      * Called when mode is set.
      */
     protected applyModeDefaults(): void;
+    /**
+     * Check for configuration conflicts and warn user
+     */
+    protected checkSelectionConflicts(): void;
     protected requestUpdate(): void;
     getRowDraft(rowIndex: number): T | undefined;
     hasRowDraft(rowIndex: number): boolean;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { GridElement } from './web-component.js';
 export { WebGrid } from './grid.js';
-export type { EditorType, EditTrigger, OptionsLoadTrigger, DateOutputFormat, EditorOption, EditorOptions, CustomEditorContext, CellValidationState, ValidationResult, BeforeCommitContext, BeforeCommitResult, Column, CellRenderCallback, RowChangeDetail, PredefinedToolbarItemType, ToolbarPosition, ToolbarTooltip, RowToolbarItem, RowToolbarConfig, NormalizedToolbarItem, ToolbarClickDetail, RowActionType, RowActionClickDetail, ContextMenuContext, ContextMenuItem, QuickGridProps, SortState, DataRequestDetail, DataRequestTrigger, GridLabels, RowLockInfo, RowLockingOptions, RowLockChangeDetail, LockedRowEditBehavior, ColumnWidthState, ColumnResizeDetail, ColumnOrderState, ColumnReorderDetail, FillDragDetail, FillDirection, RangeShortcut, RangeShortcutContext, EditingCell, FocusedCell, SortDirection, ToolbarRowGroup, PopupPosition, ConnectorArrowDir } from './types.js';
+export type { EditorType, EditTrigger, OptionsLoadTrigger, DateOutputFormat, EditorOption, EditorOptions, CustomEditorContext, CellValidationState, ValidationResult, BeforeCommitContext, BeforeCommitResult, Column, CellRenderCallback, RowChangeDetail, PredefinedToolbarItemType, ToolbarPosition, ToolbarTooltip, RowToolbarItem, RowToolbarConfig, NormalizedToolbarItem, ToolbarClickDetail, RowActionType, RowActionClickDetail, ContextMenuContext, ContextMenuItem, QuickGridProps, SortState, DataRequestDetail, DataRequestTrigger, GridLabels, RowLockInfo, RowLockingOptions, RowLockChangeDetail, LockedRowEditBehavior, ColumnWidthState, ColumnResizeDetail, ColumnOrderState, ColumnReorderDetail, FillDragDetail, FillDirection, RangeShortcut, RangeShortcutContext, CellSelectionMode, CellRange, CellSelectionChangeDetail, EditingCell, FocusedCell, SortDirection, ToolbarRowGroup, PopupPosition, ConnectorArrowDir } from './types.js';
 export { GridElement as default } from './web-component.js';

package/dist/modules/cell-selection/index.d.ts

@@ -0,0 +1,29 @@
+import type { GridContext } from '../types.js';
+/**
+ * Check if cell selection drag is in progress
+ */
+export declare function isCellSelecting(): boolean;
+/**
+ * Check if cell selection drag is pending (mouse down but not dragging yet)
+ */
+export declare function isCellSelectionPending(): boolean;
+/**
+ * Handle mousedown on a cell to start selection
+ */
+export declare function handleCellMouseDown<T>(ctx: GridContext<T>, rowIndex: number, colIndex: number, event: MouseEvent): void;
+/**
+ * Handle Shift+Click to extend/create range to clicked cell
+ */
+export declare function handleCellShiftClick<T>(ctx: GridContext<T>, rowIndex: number, colIndex: number): void;
+/**
+ * Create persistent range border (after selection complete)
+ */
+export declare function createRangeBorder<T>(ctx: GridContext<T>): void;
+/**
+ * Update range border position (e.g., on scroll)
+ */
+export declare function updateRangeBorder<T>(ctx: GridContext<T>): void;
+/**
+ * Remove the persistent range border
+ */
+export declare function removeRangeBorder(): void;

package/dist/modules/focus-events/index.d.ts

@@ -0,0 +1,42 @@
+export type FocusEventType = 'blur' | 'focusout';
+export type FocusHandler = (target: HTMLElement, relatedTarget: HTMLElement | null) => void;
+export interface FocusSubscription {
+    unsubscribe: () => void;
+}
+export interface FocusEventManager {
+    /**
+     * Subscribe to focus events
+     * @param type - 'blur' for editor blur (capture phase), 'focusout' for table focusout
+     * @param handler - Callback with target and relatedTarget
+     * @returns Subscription object with unsubscribe method
+     */
+    subscribe(type: FocusEventType, handler: FocusHandler): FocusSubscription;
+    /**
+     * Unified guard check - returns true if blur should be skipped
+     * Checks: isCommittingFromKeyboard, isTransitioningCells, isClosingViaToggle, isOpeningDropdown
+     */
+    shouldSkipBlur(): boolean;
+    /**
+     * Initialize focus listeners on the table element
+     */
+    init(table: HTMLElement): void;
+    /**
+     * Remove all listeners and subscriptions
+     */
+    destroy(): void;
+}
+/**
+ * Guard state for blur handling
+ */
+export interface BlurGuardState {
+    isCommittingFromKeyboard: boolean;
+    isTransitioningCells: boolean;
+    isClosingViaToggle: boolean;
+    isOpeningDropdown: boolean;
+}
+/**
+ * Create a focus event manager for a single grid instance
+ * @param getGuardState - Callback to get current guard flag state
+ * @param resetClosingViaToggle - Callback to reset the isClosingViaToggle flag
+ */
+export declare function createFocusEventManager(getGuardState: () => BlurGuardState, resetClosingViaToggle: () => void): FocusEventManager;

package/dist/modules/navigation/index.d.ts

@@ -1 +1 @@
-export { focusCellElement, updateFocusVisual, clearEditingVisual, handleCellFocus, moveFocus, tryStartEdit, getCursorPositionFromClick, handleTableFocusOut, scrollToRowPosition } from './focus.js';
+export { focusCellElement, updateFocusVisual, clearEditingVisual, restoreEditingCellToDisplayMode, handleCellFocus, moveFocus, tryStartEdit, getCursorPositionFromClick, handleTableFocusOut, scrollToRowPosition } from './focus.js';

package/dist/modules/scroll-events/index.d.ts

@@ -0,0 +1,27 @@
+export type ScrollSource = 'container' | 'window';
+export type ScrollHandler = () => void;
+export interface ScrollSubscription {
+    unsubscribe: () => void;
+}
+export interface ScrollEventManager {
+    /**
+     * Subscribe to scroll events from a specific source
+     * @param source - 'container' for grid container scroll, 'window' for window scroll
+     * @param handler - Callback function to invoke on scroll
+     * @returns Subscription object with unsubscribe method
+     */
+    subscribe(source: ScrollSource, handler: ScrollHandler): ScrollSubscription;
+    /**
+     * Initialize scroll listeners (called once in connectedCallback)
+     * @param container - The grid container element (.wg)
+     */
+    init(container: HTMLElement): void;
+    /**
+     * Remove all listeners and subscriptions (called in disconnectedCallback)
+     */
+    destroy(): void;
+}
+/**
+ * Create a scroll event manager for a single grid instance
+ */
+export declare function createScrollEventManager(): ScrollEventManager;

package/dist/modules/types.d.ts

@@ -1,5 +1,7 @@
 import type { WebGrid } from '../grid.js';
 import type { Column, EditorOption, EditorOptions } from '../types.js';
+import type { ScrollEventManager } from './scroll-events/index.js';
+import type { FocusEventManager } from './focus-events/index.js';
 /**
  * GridElement context interface for module functions
  * This is the subset of GridElement that modules need access to
@@ -29,4 +31,6 @@ export interface GridContext<T = unknown> {
     getCurrentEditingColumn(): Column<T> | null;
     getCurrentEditorOptions(): EditorOptions;
     moveFocusAfterCommit(rowIndex: number, field: string, direction: 'down' | 'up' | 'next' | 'prev'): void;
+    readonly scrollEvents: ScrollEventManager;
+    readonly focusEvents: FocusEventManager;
 }

package/dist/types.d.ts

@@ -6,6 +6,7 @@ export type OptionsLoadTrigger = "immediate" | "oneditstart" | "ondropdownopen";
 export type DateOutputFormat = "date" | "iso" | "timestamp";
 export type EditStartSelection = "mousePosition" | "selectAll" | "cursorAtStart" | "cursorAtEnd";
 export type FillDirection = "vertical" | "all";
+export type CellSelectionMode = "disabled" | "click" | "shift";
 export type EditorOption = {
     value: string | number | boolean;
     label: string;
@@ -41,6 +42,7 @@ export type EditorOptions<T = unknown> = {
     emptyLabel?: string;
     noOptionsText?: string;
     searchingText?: string;
+    dropdownMinWidth?: string;
     maxLength?: number;
     placeholder?: string;
     pattern?: string;
@@ -58,7 +60,7 @@ export type EditorOptions<T = unknown> = {
     dateFormat?: string;
     outputFormat?: DateOutputFormat;
     initialOptions?: EditorOption[];
-    onSearchCallback?: (query: string, row: T, signal?: AbortSignal) => Promise<EditorOption[]>;
+    searchCallback?: (query: string, row: T, signal?: AbortSignal) => Promise<EditorOption[]>;
     minSearchLength?: number;
     debounceMs?: number;
     multiple?: boolean;
@@ -95,37 +97,41 @@ export type Column<T> = {
     field: keyof T | string;
     title: string;
     headerInfo?: string;
-    sortable?: boolean;
-    filterable?: boolean;
+    isSortable?: boolean;
+    isFilterable?: boolean;
     width?: string;
     minWidth?: string;
     maxWidth?: string;
     textOverflow?: 'wrap' | 'ellipsis';
-    align?: "left" | "center" | "right";
+    maxLines?: number;
+    horizontalAlign?: "left" | "center" | "right" | "justify";
+    verticalAlign?: "top" | "middle" | "bottom";
+    headerHorizontalAlign?: "left" | "center" | "right" | "justify";
+    headerVerticalAlign?: "top" | "middle" | "bottom";
     cellClass?: string;
     cellClassCallback?: (value: unknown, row: T) => string | null;
     formatCallback?: (value: unknown, row: T) => string;
     templateCallback?: (row: T) => string;
     renderCallback?: CellRenderCallback<T>;
-    editable?: boolean;
+    isEditable?: boolean;
     editor?: EditorType;
     editTrigger?: EditTrigger;
     dropdownToggleVisibility?: ToggleVisibility;
-    openDropdownOnEnter?: boolean;
+    shouldOpenDropdownOnEnter?: boolean;
     editorOptions?: EditorOptions<T>;
     validateCallback?: (value: unknown, row: T) => string | null | Promise<string | null>;
     beforeCommitCallback?: (context: BeforeCommitContext<T>) => BeforeCommitResult | Promise<BeforeCommitResult>;
     cellEditCallback?: (context: CustomEditorContext<T>) => void;
-    showEditButton?: boolean;
+    isEditButtonVisible?: boolean;
     tooltipMember?: string;
     tooltipCallback?: (value: unknown, row: T) => string | null;
     beforeCopyCallback?: (value: unknown, row: T) => string;
     beforePasteCallback?: (value: string, row: T) => unknown;
     validationTooltipCallback?: (context: ValidationTooltipContext<T>) => string | null;
-    frozen?: boolean;
-    resizable?: boolean;
+    isFrozen?: boolean;
+    isResizable?: boolean;
     fillDirection?: FillDirection;
-    hidden?: boolean;
+    isHidden?: boolean;
 };
 export type ValidationTooltipContext<T> = {
     field: string;
@@ -144,6 +150,10 @@ export type RowChangeDetail<T> = {
     isValid: boolean;
     validationError?: string | null;
 };
+export type CellSelectionChangeDetail = {
+    range: CellRange | null;
+    cellCount: number;
+};
 export type PredefinedToolbarItemType = 'add' | 'delete' | 'duplicate' | 'moveUp' | 'moveDown';
 export type ToolbarPosition = 'auto' | 'left' | 'right' | 'top' | 'inline';
 export type ToolbarTooltip = {
@@ -240,9 +250,25 @@ export type RowShortcut<T> = {
     action: (ctx: ShortcutContext<T>) => void | Promise<void>;
     disabled?: boolean | ((ctx: ShortcutContext<T>) => boolean);
 };
+export type CellRange = {
+    startRowIndex: number;
+    startColIndex: number;
+    endRowIndex: number;
+    endColIndex: number;
+    startField: string;
+    endField: string;
+};
 export type RangeShortcutContext<T> = {
     rows: T[];
     rowIndices: number[];
+    cellRange?: CellRange;
+    cells?: Array<{
+        row: T;
+        rowIndex: number;
+        colIndex: number;
+        field: string;
+        value: unknown;
+    }>;
 };
 export type RangeShortcut<T> = {
     key: string;
@@ -261,13 +287,13 @@ export type ParsedKeyCombo = {
 export type QuickGridProps<T> = {
     items: T[];
     columns: Column<T>[];
-    filterable?: boolean;
-    pageable?: boolean;
+    isFilterable?: boolean;
+    isPageable?: boolean;
     pageSize?: number;
-    striped?: boolean;
-    hoverable?: boolean;
-    showRowNumbers?: boolean;
-    stickyRowNumbers?: boolean;
+    isStriped?: boolean;
+    isHoverable?: boolean;
+    isRowNumbersVisible?: boolean;
+    isStickyRowNumbers?: boolean;
     freezeColumns?: number;
     class?: string;
     style?: string;
@@ -284,27 +310,23 @@ export type QuickGridProps<T> = {
     paginationLayout?: string;
     summaryPosition?: string;
     summaryContentCallback?: SummaryContentCallback<T>;
-    summaryInline?: boolean;
-    editable?: boolean;
+    isSummaryInline?: boolean;
+    isEditable?: boolean;
     editTrigger?: EditTrigger;
     editStartSelection?: EditStartSelection;
     mode?: GridMode;
     dropdownToggleVisibility?: ToggleVisibility;
-    dropdownShowOnFocus?: boolean;
-    openDropdownOnEnter?: boolean;
-    checkboxAlwaysEditable?: boolean;
+    shouldShowDropdownOnFocus?: boolean;
+    shouldOpenDropdownOnEnter?: boolean;
+    isCheckboxAlwaysEditable?: boolean;
     invalidCells?: CellValidationState[];
-    showRowToolbar?: boolean;
+    isRowToolbarVisible?: boolean;
     rowToolbar?: RowToolbarConfig<T>[];
     toolbarVerticalAlign?: 'top' | 'center' | 'bottom';
     toolbarHorizontalAlign?: 'start' | 'center' | 'end' | 'cursor';
     toolbarTrigger?: 'hover' | 'click' | 'button';
     toolbarPosition?: ToolbarPosition;
     inlineActionsTitle?: string;
-    showRowActions?: boolean;
-    rowActions?: RowToolbarConfig<T>[];
-    toolbarAlign?: 'top' | 'center' | 'bottom';
-    toolbarTopPosition?: 'start' | 'center' | 'end' | 'cursor';
     contextMenu?: ContextMenuItem<T>[];
     contextMenuXOffset?: number;
     contextMenuYOffset?: number;
@@ -312,14 +334,14 @@ export type QuickGridProps<T> = {
     headerContextMenu?: HeaderMenuConfig<T>[];
     onheadercontextmenuopen?: (context: HeaderMenuContext<T>) => void;
     rowShortcuts?: RowShortcut<T>[];
-    showShortcutsHelp?: boolean;
+    isShortcutsHelpVisible?: boolean;
     shortcutsHelpPosition?: 'top-right' | 'top-left';
     shortcutsHelpContentCallback?: () => string;
-    virtualScroll?: boolean;
+    isVirtualScrollEnabled?: boolean;
     virtualScrollThreshold?: number;
     virtualScrollRowHeight?: number;
     virtualScrollBuffer?: number;
-    infiniteScroll?: boolean;
+    isInfiniteScrollEnabled?: boolean;
     infiniteScrollThreshold?: number;
     hasMoreItems?: boolean;
     onrowchange?: (detail: RowChangeDetail<T>) => void;
@@ -341,19 +363,21 @@ export type QuickGridProps<T> = {
     }) => void;
     validationTooltipCallback?: (context: ValidationTooltipContext<T>) => string | null;
     ontoolbarclick?: (detail: ToolbarClickDetail<T>) => void;
-    onrowaction?: (detail: RowActionClickDetail<T>) => void;
     ondatarequest?: (detail: DataRequestDetail) => void;
     onrowdelete?: (detail: {
         rowIndex: number;
         row: T;
     }) => void;
     gridName?: string;
-    persistColumnWidths?: boolean;
+    shouldPersistColumnWidths?: boolean;
     oncolumnresize?: (detail: ColumnResizeDetail) => void;
-    allowColumnReorder?: boolean;
-    persistColumnOrder?: boolean;
+    isColumnReorderAllowed?: boolean;
+    shouldPersistColumnOrder?: boolean;
     oncolumnreorder?: (detail: ColumnReorderDetail) => void;
-    onfilldrag?: (detail: FillDragDetail) => boolean | void;
+    fillDragCallback?: (detail: FillDragDetail) => boolean | void;
+    cellSelectionMode?: CellSelectionMode;
+    shouldCopyWithHeaders?: boolean;
+    oncellselectionchange?: (detail: CellSelectionChangeDetail) => void;
 };
 export type EditingCell = {
     rowIndex: number;