slickgrid-react 9.9.0 → 9.11.0

package/src/components/slickgridReactProps.ts

@@ -1,10 +1,22 @@
 import type {
   Column,
+  ColumnSort,
   ContainerService,
+  CurrentFilter,
+  CurrentSorter,
   DragRowMove,
+  ExportTextDownloadOption,
   ExtensionList,
+  GridMenuCommandItemCallbackArgs,
+  GridMenuEventWithElementCallbackArgs,
   GridOption,
+  GridSize,
+  GridStateChange,
   HeaderButtonOnCommandArgs,
+  HeaderMenuCommandItemCallbackArgs,
+  MenuCommandItemCallbackArgs,
+  MenuFromCellCallbackArgs,
+  MenuOptionItemCallbackArgs,
   OnActiveCellChangedEventArgs,
   OnAddNewRowEventArgs,
   OnAutosizeColumnsEventArgs,
@@ -19,15 +31,19 @@ import type {
   OnCellChangeEventArgs,
   OnCellCssStylesChangedEventArgs,
   OnClickEventArgs,
+  OnColumnsChangedArgs,
   OnColumnsDragEventArgs,
   OnColumnsReorderedEventArgs,
   OnColumnsResizeDblClickEventArgs,
   OnColumnsResizedEventArgs,
   OnCompositeEditorChangeEventArgs,
   OnDblClickEventArgs,
+  OnDragReplaceCellsEventArgs,
   OnFooterClickEventArgs,
   OnFooterContextMenuEventArgs,
   OnFooterRowCellRenderedEventArgs,
+  OnGroupCollapsedEventArgs,
+  OnGroupExpandedEventArgs,
   OnHeaderCellRenderedEventArgs,
   OnHeaderClickEventArgs,
   OnHeaderContextMenuEventArgs,
@@ -35,33 +51,28 @@ import type {
   OnHeaderRowCellRenderedEventArgs,
   OnKeyDownEventArgs,
   OnRenderedEventArgs,
-  OnScrollEventArgs,
-  OnSelectedRowsChangedEventArgs,
-  OnSetOptionsEventArgs,
-  OnValidationErrorEventArgs,
-  SingleColumnSort,
-  OnGroupCollapsedEventArgs,
-  OnGroupExpandedEventArgs,
   OnRowCountChangedEventArgs,
   OnRowsChangedEventArgs,
   OnRowsOrCountChangedEventArgs,
+  OnScrollEventArgs,
+  OnSelectedRowIdsChangedEventArgs,
+  OnSelectedRowsChangedEventArgs,
   OnSetItemsCalledEventArgs,
+  OnSetOptionsEventArgs,
+  OnValidationErrorEventArgs,
   Pagination,
+  PaginationMetadata,
   PagingInfo,
+  ReactRegularEventHandler,
+  ReactSlickEventHandler,
+  SingleColumnSort,
   SlickControlList,
   SlickDataView,
   SlickGrid,
   SlickPluginList,
   SlickRange,
-  GridMenuCommandItemCallbackArgs,
-  GridMenuEventWithElementCallbackArgs,
-  MenuCommandItemCallbackArgs,
-  HeaderMenuCommandItemCallbackArgs,
-  PaginationChangedArgs,
-  MenuFromCellCallbackArgs,
-  MenuOptionItemCallbackArgs,
+  TreeToggleStateChange,
 } from '@slickgrid-universal/common';
-
 import type { SlickgridReactInstance } from '../models/index.js';
 import type { TranslaterI18NextService } from '../services/translaterI18Next.service.js';
 
@@ -84,165 +95,135 @@ export interface SlickgridReactProps {
   // ---------------------
 
   // Slick Grid events
-  onActiveCellChanged?: (e: CustomEvent<{ eventData: any; args: OnActiveCellChangedEventArgs }>) => void;
-  onActiveCellPositionChanged?: (e: CustomEvent<{ eventData: any; args: { grid: SlickGrid } }>) => void;
-  onAddNewRow?: (e: CustomEvent<{ eventData: any; args: OnAddNewRowEventArgs }>) => void;
-  onAutosizeColumns?: (e: CustomEvent<{ eventData: any; args: OnAutosizeColumnsEventArgs }>) => void;
-  onBeforeAppendCell?: (e: CustomEvent<{ eventData: any; args: OnBeforeAppendCellEventArgs }>) => void;
-  onBeforeSearchChange?: (e: CustomEvent<{ eventData: any; args: OnCellChangeEventArgs }>) => void;
-  onBeforeCellEditorDestroy?: (e: CustomEvent<{ eventData: any; args: OnBeforeCellEditorDestroyEventArgs }>) => void;
-  onBeforeColumnsResize?: (e: CustomEvent<{ eventData: any; args: OnBeforeColumnsResizeEventArgs }>) => void;
-  onBeforeDestroy?: (e: CustomEvent<{ eventData: any; args: { grid: SlickGrid } }>) => void;
-  onBeforeEditCell?: (e: CustomEvent<{ eventData: any; args: OnBeforeEditCellEventArgs }>) => void;
-  onBeforeHeaderCellDestroy?: (e: CustomEvent<{ eventData: any; args: OnBeforeHeaderCellDestroyEventArgs }>) => void;
-  onBeforeHeaderRowCellDestroy?: (e: CustomEvent<{ eventData: any; args: OnBeforeHeaderRowCellDestroyEventArgs }>) => void;
-  onBeforeFooterRowCellDestroy?: (e: CustomEvent<{ eventData: any; args: OnBeforeFooterRowCellDestroyEventArgs }>) => void;
-  onBeforeSetColumns?: (e: CustomEvent<{ eventData: any; args: OnBeforeSetColumnsEventArgs }>) => void;
-  onBeforeSort?: (e: CustomEvent<{ eventData: any; args: SingleColumnSort }>) => void;
-  onCellChange?: (e: CustomEvent<{ eventData: any; args: OnCellChangeEventArgs }>) => void;
-  onCellCssStylesChanged?: (e: CustomEvent<{ eventData: any; args: OnCellCssStylesChangedEventArgs }>) => void;
-  onClick?: (e: CustomEvent<{ eventData: any; args: OnClickEventArgs }>) => void;
-  onColumnsDrag?: (e: CustomEvent<{ eventData: any; args: OnColumnsDragEventArgs }>) => void;
-  onColumnsReordered?: (e: CustomEvent<{ eventData: any; args: OnColumnsReorderedEventArgs }>) => void;
-  onColumnsResized?: (e: CustomEvent<{ eventData: any; args: OnColumnsResizedEventArgs }>) => void;
-  onColumnsResizeDblClick?: (e: CustomEvent<{ eventData: any; args: OnColumnsResizeDblClickEventArgs }>) => void;
-  onCompositeEditorChange?: (e: CustomEvent<{ eventData: any; args: OnCompositeEditorChangeEventArgs }>) => void;
-  onContextMenu?: (e: CustomEvent<{ eventData: any; args: { grid: SlickGrid } }>) => void;
-  onDrag?: (e: CustomEvent<{ eventData: any; args: DragRowMove }>) => void;
-  onDragEnd?: (e: CustomEvent<{ eventData: any; args: DragRowMove }>) => void;
-  onDragInit?: (e: CustomEvent<{ eventData: any; args: DragRowMove }>) => void;
-  onDragStart?: (e: CustomEvent<{ eventData: any; args: DragRowMove }>) => void;
-  onDblClick?: (e: CustomEvent<{ eventData: any; args: OnDblClickEventArgs }>) => void;
-  onFooterContextMenu?: (e: CustomEvent<{ eventData: any; args: OnFooterContextMenuEventArgs }>) => void;
-  onFooterRowCellRendered?: (e: CustomEvent<{ eventData: any; args: OnFooterRowCellRenderedEventArgs }>) => void;
-  onHeaderCellRendered?: (e: CustomEvent<{ eventData: any; args: OnHeaderCellRenderedEventArgs }>) => void;
-  onFooterClick?: (e: CustomEvent<{ eventData: any; args: OnFooterClickEventArgs }>) => void;
-  onHeaderClick?: (e: CustomEvent<{ eventData: any; args: OnHeaderClickEventArgs }>) => void;
-  onHeaderContextMenu?: (e: CustomEvent<{ eventData: any; args: OnHeaderContextMenuEventArgs }>) => void;
-  onHeaderMouseEnter?: (e: CustomEvent<{ eventData: any; args: OnHeaderMouseEventArgs }>) => void;
-  onHeaderMouseLeave?: (e: CustomEvent<{ eventData: any; args: OnHeaderMouseEventArgs }>) => void;
-  onHeaderRowCellRendered?: (e: CustomEvent<{ eventData: any; args: OnHeaderRowCellRenderedEventArgs }>) => void;
-  onHeaderRowMouseEnter?: (e: CustomEvent<{ eventData: any; args: OnHeaderMouseEventArgs }>) => void;
-  onHeaderRowMouseLeave?: (e: CustomEvent<{ eventData: any; args: OnHeaderMouseEventArgs }>) => void;
-  onKeyDown?: (e: CustomEvent<{ eventData: any; args: OnKeyDownEventArgs }>) => void;
-  onMouseEnter?: (e: CustomEvent<{ eventData: any; args: { grid: SlickGrid } }>) => void;
-  onMouseLeave?: (e: CustomEvent<{ eventData: any; args: { grid: SlickGrid } }>) => void;
-  onValidationError?: (e: CustomEvent<{ eventData: any; args: OnValidationErrorEventArgs }>) => void;
-  onViewportChanged?: (e: CustomEvent<{ eventData: any; args: { grid: SlickGrid } }>) => void;
-  onRendered?: (e: CustomEvent<{ eventData: any; args: OnRenderedEventArgs }>) => void;
-  onSelectedRowsChanged?: (e: CustomEvent<{ eventData: any; args: OnSelectedRowsChangedEventArgs }>) => void;
-  onSetOptions?: (e: CustomEvent<{ eventData: any; args: OnSetOptionsEventArgs }>) => void;
-  onScroll?: (e: CustomEvent<{ eventData: any; args: OnScrollEventArgs }>) => void;
-  onSort?: (e: CustomEvent<{ eventData: any; args: SingleColumnSort }>) => void;
+  onActiveCellChanged?: ReactSlickEventHandler<OnActiveCellChangedEventArgs>;
+  onActiveCellPositionChanged?: ReactSlickEventHandler<{ grid: SlickGrid }>;
+  onAddNewRow?: ReactSlickEventHandler<OnAddNewRowEventArgs>;
+  onAutosizeColumns?: ReactSlickEventHandler<OnAutosizeColumnsEventArgs>;
+  onBeforeAppendCell?: ReactSlickEventHandler<OnBeforeAppendCellEventArgs>;
+  onBeforeSearchChange?: ReactSlickEventHandler<OnCellChangeEventArgs, boolean | void>;
+  onBeforeCellEditorDestroy?: ReactSlickEventHandler<OnBeforeCellEditorDestroyEventArgs>;
+  onBeforeColumnsResize?: ReactSlickEventHandler<OnBeforeColumnsResizeEventArgs>;
+  onBeforeDestroy?: ReactSlickEventHandler<{ grid: SlickGrid }>;
+  onBeforeEditCell?: ReactSlickEventHandler<OnBeforeEditCellEventArgs>;
+  onBeforeHeaderCellDestroy?: ReactSlickEventHandler<OnBeforeHeaderCellDestroyEventArgs>;
+  onBeforeHeaderRowCellDestroy?: ReactSlickEventHandler<OnBeforeHeaderRowCellDestroyEventArgs>;
+  onBeforeFooterRowCellDestroy?: ReactSlickEventHandler<OnBeforeFooterRowCellDestroyEventArgs>;
+  onBeforeSetColumns?: ReactSlickEventHandler<OnBeforeSetColumnsEventArgs>;
+  onBeforeSort?: ReactSlickEventHandler<SingleColumnSort, boolean | void>;
+  onCellChange?: ReactSlickEventHandler<OnCellChangeEventArgs>;
+  onCellCssStylesChanged?: ReactSlickEventHandler<OnCellCssStylesChangedEventArgs>;
+  onClick?: ReactSlickEventHandler<OnClickEventArgs>;
+  onColumnsDrag?: ReactSlickEventHandler<OnColumnsDragEventArgs>;
+  onColumnsReordered?: ReactSlickEventHandler<OnColumnsReorderedEventArgs>;
+  onColumnsResized?: ReactSlickEventHandler<OnColumnsResizedEventArgs>;
+  onColumnsResizeDblClick?: ReactSlickEventHandler<OnColumnsResizeDblClickEventArgs>;
+  onCompositeEditorChange?: ReactSlickEventHandler<OnCompositeEditorChangeEventArgs>;
+  onContextMenu?: ReactSlickEventHandler<{ grid: SlickGrid }>;
+  onDrag?: ReactSlickEventHandler<DragRowMove>;
+  onDragEnd?: ReactSlickEventHandler<DragRowMove>;
+  onDragInit?: ReactSlickEventHandler<DragRowMove>;
+  onDragStart?: ReactSlickEventHandler<DragRowMove>;
+  onDragReplaceCells?: ReactSlickEventHandler<OnDragReplaceCellsEventArgs>;
+  onDblClick?: ReactSlickEventHandler<OnDblClickEventArgs>;
+  onFooterContextMenu?: ReactSlickEventHandler<OnFooterContextMenuEventArgs>;
+  onFooterRowCellRendered?: ReactSlickEventHandler<OnFooterRowCellRenderedEventArgs>;
+  onHeaderCellRendered?: ReactSlickEventHandler<OnHeaderCellRenderedEventArgs>;
+  onFooterClick?: ReactSlickEventHandler<OnFooterClickEventArgs>;
+  onHeaderClick?: ReactSlickEventHandler<OnHeaderClickEventArgs>;
+  onHeaderContextMenu?: ReactSlickEventHandler<OnHeaderContextMenuEventArgs>;
+  onHeaderMouseEnter?: ReactSlickEventHandler<OnHeaderMouseEventArgs>;
+  onHeaderMouseLeave?: ReactSlickEventHandler<OnHeaderMouseEventArgs>;
+  onHeaderRowCellRendered?: ReactSlickEventHandler<OnHeaderRowCellRenderedEventArgs>;
+  onHeaderRowMouseEnter?: ReactSlickEventHandler<OnHeaderMouseEventArgs>;
+  onHeaderRowMouseLeave?: ReactSlickEventHandler<OnHeaderMouseEventArgs>;
+  onKeyDown?: ReactSlickEventHandler<OnKeyDownEventArgs>;
+  onMouseEnter?: ReactSlickEventHandler<{ grid: SlickGrid }>;
+  onMouseLeave?: ReactSlickEventHandler<{ grid: SlickGrid }>;
+  onValidationError?: ReactSlickEventHandler<OnValidationErrorEventArgs>;
+  onViewportChanged?: ReactSlickEventHandler<{ grid: SlickGrid }>;
+  onRendered?: ReactSlickEventHandler<OnRenderedEventArgs>;
+  onSelectedRowsChanged?: ReactSlickEventHandler<OnSelectedRowsChangedEventArgs>;
+  onSetOptions?: ReactSlickEventHandler<OnSetOptionsEventArgs>;
+  onScroll?: ReactSlickEventHandler<OnScrollEventArgs>;
+  onSort?: ReactSlickEventHandler<SingleColumnSort>;
 
   // Slick DataView events
-  onBeforePagingInfoChanged?: (e: CustomEvent<{ eventData: any; args: PagingInfo }>) => void;
-  onGroupExpanded?: (e: CustomEvent<{ eventData: any; args: OnGroupExpandedEventArgs }>) => void;
-  onGroupCollapsed?: (e: CustomEvent<{ eventData: any; args: OnGroupCollapsedEventArgs }>) => void;
-  onPagingInfoChanged?: (e: CustomEvent<{ eventData: any; args: PagingInfo }>) => void;
-  onRowCountChanged?: (e: CustomEvent<{ eventData: any; args: OnRowCountChangedEventArgs }>) => void;
-  onRowsChanged?: (e: CustomEvent<{ eventData: any; args: OnRowsChangedEventArgs }>) => void;
-  onRowsOrCountChanged?: (e: CustomEvent<{ eventData: any; args: OnRowsOrCountChangedEventArgs }>) => void;
-  onSetItemsCalled?: (e: CustomEvent<{ eventData: any; args: OnSetItemsCalledEventArgs }>) => void;
+  onBeforePagingInfoChanged?: ReactSlickEventHandler<PagingInfo>;
+  onGroupExpanded?: ReactSlickEventHandler<OnGroupExpandedEventArgs>;
+  onGroupCollapsed?: ReactSlickEventHandler<OnGroupCollapsedEventArgs>;
+  onPagingInfoChanged?: ReactSlickEventHandler<PagingInfo>;
+  onRowCountChanged?: ReactSlickEventHandler<OnRowCountChangedEventArgs>;
+  onRowsChanged?: ReactSlickEventHandler<OnRowsChangedEventArgs>;
+  onRowsOrCountChanged?: ReactSlickEventHandler<OnRowsOrCountChangedEventArgs>;
+  onSelectedRowIdsChanged?: ReactSlickEventHandler<OnSelectedRowIdsChangedEventArgs>;
+  onSetItemsCalled?: ReactSlickEventHandler<OnSetItemsCalledEventArgs>;
+
+  // other Slick Events
+  onAfterMenuShow?: ReactSlickEventHandler<MenuFromCellCallbackArgs>;
+  onBeforeMenuClose?: ReactSlickEventHandler<MenuFromCellCallbackArgs>;
+  onBeforeMenuShow?: ReactSlickEventHandler<MenuFromCellCallbackArgs>;
+  onColumnsChanged?: ReactSlickEventHandler<OnColumnsChangedArgs>;
+  onCommand?: ReactSlickEventHandler<MenuCommandItemCallbackArgs | MenuOptionItemCallbackArgs>;
+  onGridMenuColumnsChanged?: ReactSlickEventHandler<OnColumnsChangedArgs>;
+  onMenuClose?: ReactSlickEventHandler<GridMenuEventWithElementCallbackArgs>;
+  onCopyCells?: ReactSlickEventHandler<{ ranges: SlickRange[] }>;
+  onCopyCancelled?: ReactSlickEventHandler<{ ranges: SlickRange[] }>;
+  onPasteCells?: ReactSlickEventHandler<{ ranges: SlickRange[] }>;
+  onBeforePasteCell?: ReactSlickEventHandler<{ cell: number; row: number; item: any; columnDef: Column; value: any }>;
 
-  // Slickgrid-React events
-  onAfterExportToExcel?: (e: CustomEvent<any>) => void;
-  onBeforeExportToExcel?: (e: CustomEvent<any>) => void;
-  onBeforeFilterChange?: (e: CustomEvent<any>) => void;
-  onBeforeFilterClear?: (e: CustomEvent<any>) => void;
-  onBeforeSortChange?: (e: CustomEvent<any>) => void;
-  onBeforeToggleTreeCollapse?: (e: CustomEvent<any>) => void;
-  onContextMenuClearGrouping?: (e: CustomEvent<any>) => void;
-  onContextMenuCollapseAllGroups?: (e: CustomEvent<any>) => void;
-  onContextMenuExpandAllGroups?: (e: CustomEvent<any>) => void;
-  onAfterMenuShow?: (e: CustomEvent<{ eventData: any; args: MenuFromCellCallbackArgs }>) => void;
-  onAfterGridDestroyed?: (e: CustomEvent<{ eventData: any; args: MenuFromCellCallbackArgs }>) => void;
-  onBeforeMenuShow?: (e: CustomEvent<{ eventData: any; args: MenuFromCellCallbackArgs }>) => void;
-  onBeforeMenuClose?: (e: CustomEvent<{ eventData: any; args: MenuFromCellCallbackArgs }>) => void;
-  onBeforeGridDestroy?: (e: CustomEvent<{ eventData: any; args: MenuFromCellCallbackArgs }>) => void;
-  onCommand?: (e: CustomEvent<{ eventData: any; args: MenuCommandItemCallbackArgs | MenuOptionItemCallbackArgs }>) => void;
-  onOptionSelected?: (e: CustomEvent<{ eventData: any; args: MenuCommandItemCallbackArgs | MenuOptionItemCallbackArgs }>) => void;
-  onColumnPickerColumnsChanged?: (
-    e: CustomEvent<{
-      eventData: any;
-      args: {
-        columnId: string;
-        showing: boolean;
-        allColumns: Column[];
-        visibleColumns: Column[];
-        columns: Column[];
-        grid: SlickGrid;
-      };
-    }>
-  ) => void;
-  onColumnsChanged?: (
-    e: CustomEvent<{
-      eventData: any;
-      args: {
-        columnId: string;
-        showing: boolean;
-        allColumns: Column[];
-        visibleColumns: Column[];
-        columns: Column[];
-        grid: SlickGrid;
-      };
-    }>
-  ) => void;
-  onGridMenuMenuClose?: (e: CustomEvent<{ eventData: any; args: GridMenuEventWithElementCallbackArgs }>) => void;
-  onGridMenuBeforeMenuShow?: (e: CustomEvent<{ eventData: any; args: GridMenuEventWithElementCallbackArgs }>) => void;
-  onGridMenuAfterMenuShow?: (e: CustomEvent<{ eventData: any; args: GridMenuEventWithElementCallbackArgs }>) => void;
-  onGridMenuClearAllPinning?: (e: CustomEvent<any>) => void;
-  onGridMenuClearAllFilters?: (e: CustomEvent<any>) => void;
-  onGridMenuClearAllSorting?: (e: CustomEvent<any>) => void;
-  onGridMenuColumnsChanged?: (
-    e: CustomEvent<{
-      eventData: any;
-      args: {
-        columnId: string;
-        showing: boolean;
-        allColumns: Column[];
-        visibleColumns: Column[];
-        columns: Column[];
-        grid: SlickGrid;
-      };
-    }>
-  ) => void;
-  onGridMenuCommand?: (e: CustomEvent<{ eventData: any; args: GridMenuCommandItemCallbackArgs }>) => void;
-  onHeaderButtonCommand?: (e: CustomEvent<{ eventData: any; args: HeaderButtonOnCommandArgs }>) => void;
-  onCopyCells?: (e: CustomEvent<{ eventData: any; args: { ranges: SlickRange[] } }>) => void;
-  onCopyCancelled?: (e: CustomEvent<{ eventData: any; args: { ranges: SlickRange[] } }>) => void;
-  onPasteCells?: (e: CustomEvent<{ eventData: any; args: { ranges: SlickRange[] } }>) => void;
-  onBeforePasteCell?: (
-    e: CustomEvent<{ eventData: any; args: { cell: number; row: number; item: any; columnDef: Column; value: any } }>
-  ) => void;
-  onHeaderMenuCommand?: (e: CustomEvent<{ eventData: any; args: MenuCommandItemCallbackArgs }>) => void;
-  onHeaderMenuColumnResizeByContent?: (e: CustomEvent<{ eventData: any; args: { columnId: string } }>) => void;
-  onHeaderMenuBeforeMenuShow?: (e: CustomEvent<{ eventData: any; args: HeaderMenuCommandItemCallbackArgs }>) => void;
-  onHeaderMenuAfterMenuShow?: (e: CustomEvent<{ eventData: any; args: HeaderMenuCommandItemCallbackArgs }>) => void;
-  onHideColumns?: (e: CustomEvent<{ eventData: any; args: { columns: Column[]; hiddenColumn: Column[] } }>) => void;
-  onItemsAdded?: (e: CustomEvent<any>) => void;
-  onItemsDeleted?: (e: CustomEvent<any>) => void;
-  onItemsUpdated?: (e: CustomEvent<any>) => void;
-  onItemsUpserted?: (e: CustomEvent<any>) => void;
-  onFullResizeByContentRequested?: (e: CustomEvent<any>) => void;
-  onGridStateChanged?: (e: CustomEvent<any>) => void;
-  onBeforePaginationChange?: (e: CustomEvent<any>) => void;
-  onPaginationChanged?: (e: CustomEvent<PaginationChangedArgs>) => void;
-  onPaginationRefreshed?: (e: CustomEvent<any>) => void;
-  onPaginationVisibilityChanged?: (e: CustomEvent<any>) => void;
-  onPaginationSetCursorBased?: (e: CustomEvent<any>) => void;
-  onGridBeforeResize?: (e: CustomEvent<any>) => void;
-  onGridAfterResize?: (e: CustomEvent<any>) => void;
-  onBeforeResizeByContent?: (e: CustomEvent<any>) => void;
-  onAfterResizeByContent?: (e: CustomEvent<any>) => void;
-  onSelectedRowIdsChanged?: (e: CustomEvent<any>) => void;
-  onSortCleared?: (e: CustomEvent<any>) => void;
-  onFilterChanged?: (e: CustomEvent<any>) => void;
-  onFilterCleared?: (e: CustomEvent<any>) => void;
-  onReactGridCreated?: (e: CustomEvent<any>) => void;
-  onSortChanged?: (e: CustomEvent<any>) => void;
-  onToggleTreeCollapsed?: (e: CustomEvent<any>) => void;
-  onTreeItemToggled?: (e: CustomEvent<any>) => void;
-  onTreeFullToggleEnd?: (e: CustomEvent<any>) => void;
-  onTreeFullToggleStart?: (e: CustomEvent<any>) => void;
+  // Slickgrid-React or Slickgrid-Universal events
+  onAfterExportToExcel?: ReactRegularEventHandler<{ filename: string; mimeType: string }>;
+  onBeforeExportToExcel?: ReactRegularEventHandler<boolean>;
+  onBeforeExportToTextFile?: ReactRegularEventHandler<boolean>;
+  onAfterExportToTextFile?: ReactRegularEventHandler<ExportTextDownloadOption>;
+  onBeforeFilterChange?: ReactRegularEventHandler<CurrentFilter[]>;
+  onBeforeFilterClear?: ReactRegularEventHandler<{ columnId: string } | boolean>;
+  onBeforeSortChange?: ReactRegularEventHandler<Array<ColumnSort & { clearSortTriggered?: boolean }>>;
+  onContextMenuClearGrouping?: ReactRegularEventHandler<void>;
+  onContextMenuCollapseAllGroups?: ReactRegularEventHandler<void>;
+  onContextMenuExpandAllGroups?: ReactRegularEventHandler<void>;
+  onAfterGridDestroyed?: ReactRegularEventHandler<MenuFromCellCallbackArgs>;
+  onBeforeGridDestroy?: ReactRegularEventHandler<MenuFromCellCallbackArgs>;
+  onOptionSelected?: ReactRegularEventHandler<MenuCommandItemCallbackArgs | MenuOptionItemCallbackArgs>;
+  onColumnPickerColumnsChanged?: ReactRegularEventHandler<OnColumnsChangedArgs>;
+  onGridMenuMenuClose?: ReactRegularEventHandler<GridMenuEventWithElementCallbackArgs>;
+  onGridMenuBeforeMenuShow?: ReactRegularEventHandler<GridMenuEventWithElementCallbackArgs>;
+  onGridMenuAfterMenuShow?: ReactRegularEventHandler<GridMenuEventWithElementCallbackArgs>;
+  onGridMenuClearAllPinning?: ReactRegularEventHandler<void>;
+  onGridMenuClearAllFilters?: ReactRegularEventHandler<void>;
+  onGridMenuClearAllSorting?: ReactRegularEventHandler<void>;
+  onGridMenuCommand?: ReactRegularEventHandler<GridMenuCommandItemCallbackArgs>;
+  onHeaderButtonCommand?: ReactRegularEventHandler<HeaderButtonOnCommandArgs>;
+  onHeaderMenuCommand?: ReactRegularEventHandler<MenuCommandItemCallbackArgs>;
+  onHeaderMenuColumnResizeByContent?: ReactRegularEventHandler<{ columnId: string }>;
+  onHeaderMenuBeforeMenuShow?: ReactRegularEventHandler<HeaderMenuCommandItemCallbackArgs>;
+  onHeaderMenuAfterMenuShow?: ReactRegularEventHandler<HeaderMenuCommandItemCallbackArgs>;
+  onHideColumns?: ReactRegularEventHandler<{ columns: Column[]; hiddenColumn: Column[] }>;
+  onItemsAdded?: ReactRegularEventHandler<any[]>;
+  onItemsDeleted?: ReactRegularEventHandler<any[]>;
+  onItemsUpdated?: ReactRegularEventHandler<any[]>;
+  onItemsUpserted?: ReactRegularEventHandler<any[]>;
+  onFullResizeByContentRequested?: ReactRegularEventHandler<{ caller: string }>;
+  onGridStateChanged?: ReactRegularEventHandler<GridStateChange>;
+  onBeforePaginationChange?: ReactRegularEventHandler<PaginationMetadata, boolean | void>;
+  onPaginationChanged?: ReactRegularEventHandler<PaginationMetadata>;
+  onPaginationRefreshed?: ReactRegularEventHandler<PaginationMetadata>;
+  onPaginationVisibilityChanged?: ReactRegularEventHandler<{ visible: boolean }>;
+  onPaginationSetCursorBased?: ReactRegularEventHandler<{ isCursorBased: boolean }>;
+  onGridBeforeResize?: ReactRegularEventHandler<void>;
+  onGridAfterResize?: ReactRegularEventHandler<GridSize | undefined>;
+  onBeforeResizeByContent?: ReactRegularEventHandler<void>;
+  onAfterResizeByContent?: ReactRegularEventHandler<{
+    readItemCount: number;
+    calculateColumnWidths: { [x: string]: number | undefined; [x: number]: number | undefined };
+  }>;
+  onSortCleared?: ReactRegularEventHandler<boolean>;
+  onFilterChanged?: ReactRegularEventHandler<CurrentFilter[]>;
+  onFilterCleared?: ReactRegularEventHandler<boolean>;
+  onReactGridCreated?: ReactRegularEventHandler<any>;
+  onSortChanged?: ReactRegularEventHandler<CurrentSorter[]>;
+  onTreeItemToggled?: ReactRegularEventHandler<TreeToggleStateChange>;
+  onTreeFullToggleEnd?: ReactRegularEventHandler<TreeToggleStateChange>;
+  onTreeFullToggleStart?: ReactRegularEventHandler<TreeToggleStateChange>;
+  onLanguageChange?: ReactRegularEventHandler<string>;
 }

package/src/contexts/i18nextContext.ts

@@ -1,5 +1,4 @@
 import React from 'react';
-
 import type { I18Next } from '../models/i18next.interface.js';
 
 export const I18nextContext = React.createContext<I18Next | null>(null);

package/src/extensions/slickRowDetailView.ts

@@ -1,18 +1,19 @@
 import {
   addToArrayWhenNotExists,
   createDomElement,
+  SlickEventData,
+  SlickHybridSelectionModel,
+  SlickRowSelectionModel,
+  unsubscribeAll,
   type EventSubscription,
   type OnBeforeRowDetailToggleArgs,
   type OnRowBackOrOutOfViewportRangeArgs,
-  SlickEventData,
+  type SelectionModel,
   type SlickGrid,
-  SlickRowSelectionModel,
-  unsubscribeAll,
 } from '@slickgrid-universal/common';
 import { type EventPubSubService } from '@slickgrid-universal/event-pub-sub';
 import { SlickRowDetailView as UniversalSlickRowDetailView } from '@slickgrid-universal/row-detail-view-plugin';
 import type { Root } from 'react-dom/client';
-
 import type { GridOption, RowDetailView, ViewModelBindableInputData } from '../models/index.js';
 import { createReactComponentDynamically } from '../services/reactUtils.js';
 
@@ -81,16 +82,16 @@ export class SlickRowDetailView extends UniversalSlickRowDetailView {
 
   init(grid: SlickGrid) {
     this._grid = grid;
-    super.init(this._grid);
+    super.init(grid);
     this.gridContainerElement = grid.getContainerNode();
-    this.register(grid?.getSelectionModel() as SlickRowSelectionModel);
+    this.register(grid.getSelectionModel());
   }
 
   /**
    * Create the plugin before the Grid creation, else it will behave oddly.
    * Mostly because the column definitions might change after the grid creation
    */
-  register(rowSelectionPlugin?: SlickRowSelectionModel) {
+  register(rowSelectionPlugin?: SelectionModel) {
     if (typeof this.gridOptions.rowDetailView?.process === 'function') {
       // we need to keep the user "process" method and replace it with our own execution method
       // we do this because when we get the item detail, we need to call "onAsyncResponse.notify" for the plugin to work
@@ -104,11 +105,11 @@ export class SlickRowDetailView extends UniversalSlickRowDetailView {
       // load the Preload & RowDetail Templates (could be straight HTML or React Components)
       // when those are React Components, we need to create View Component & provide the html containers to the Plugin (preTemplate/postTemplate methods)
       if (!this.gridOptions.rowDetailView.preTemplate) {
-        this._preloadComponent = this.gridOptions?.rowDetailView?.preloadComponent;
+        this._preloadComponent = this.gridOptions.rowDetailView.preloadComponent;
         this.addonOptions.preTemplate = () => createDomElement('div', { className: `${PRELOAD_CONTAINER_PREFIX}` });
       }
       if (!this.gridOptions.rowDetailView.postTemplate) {
-        this._component = this.gridOptions?.rowDetailView?.viewComponent;
+        this._component = this.gridOptions.rowDetailView.viewComponent;
         this.addonOptions.postTemplate = (itemDetail: any) =>
           createDomElement('div', { className: `${ROW_DETAIL_CONTAINER_PREFIX}${itemDetail[this.datasetIdPropName]}` });
       }
@@ -116,7 +117,8 @@ export class SlickRowDetailView extends UniversalSlickRowDetailView {
       if (this._grid && this.gridOptions) {
         // this also requires the Row Selection Model to be registered as well
         if (!rowSelectionPlugin || !this._grid.getSelectionModel()) {
-          rowSelectionPlugin = new SlickRowSelectionModel(this.gridOptions.rowSelectionOptions || { selectActiveRow: true });
+          const SelectionModelClass = this.gridOptions.enableHybridSelection ? SlickHybridSelectionModel : SlickRowSelectionModel;
+          rowSelectionPlugin = new SelectionModelClass(this.gridOptions.rowSelectionOptions || { selectActiveRow: true });
           this._grid.setSelectionModel(rowSelectionPlugin);
         }
 
@@ -196,7 +198,7 @@ export class SlickRowDetailView extends UniversalSlickRowDetailView {
           this.eventHandler.subscribe(this._grid.onColumnsReordered, () => this.redrawAllViewComponents(false));
 
           // on row selection changed, we also need to redraw
-          if (this.gridOptions.enableRowSelection || this.gridOptions.enableCheckboxSelector) {
+          if (this.gridOptions.enableRowSelection || this.gridOptions.enableHybridSelection || this.gridOptions.enableCheckboxSelector) {
             this._eventHandler.subscribe(this._grid.onSelectedRowsChanged, () => this.redrawAllViewComponents(false));
           }
 

package/src/global-grid-options.ts

@@ -1,5 +1,4 @@
-import { type Column, DelimiterType, EventNamingStyle, Filters, type TreeDataOption } from '@slickgrid-universal/common';
-
+import { DelimiterType, EventNamingStyle, Filters, type Column, type TreeDataOption } from '@slickgrid-universal/common';
 import type { GridOption, RowDetailView } from './models/index.js';
 
 /**

package/src/index.ts

@@ -1,10 +1,9 @@
-import 'regenerator-runtime/runtime.js';
-export * from '@slickgrid-universal/common';
-
 import { SlickgridReact } from './components/slickgrid-react.js';
 import { SlickRowDetailView } from './extensions/slickRowDetailView.js';
+import type { GridOption, RowDetailView, SlickgridReactComponentOutput, SlickgridReactInstance } from './models/index.js';
 import type { SlickgridConfig } from './slickgrid-config.js';
-import type { SlickgridReactInstance, SlickgridReactComponentOutput, RowDetailView, GridOption } from './models/index.js';
+
+export * from '@slickgrid-universal/common';
 
 // expose all public classes & contexts
 export { TranslaterI18NextService, disposeAllSubscriptions } from './services/index.js';

package/src/models/gridOption.interface.ts

@@ -1,6 +1,5 @@
 import type { BasePaginationComponent, BasePaginationModel, GridOption as UniversalGridOption } from '@slickgrid-universal/common';
 import type { ForwardRefExoticComponent, RefAttributes } from 'react';
-
 import type { I18Next } from './i18next.interface.js';
 import type { RowDetailView } from './rowDetailView.interface.js';
 

package/src/models/reactComponentOutput.interface.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/consistent-type-imports */
+/* oxlint-disable @typescript-eslint/consistent-type-imports */
 import React, { type ReactInstance } from 'react';
 
 export interface SlickgridReactComponentOutput {

package/src/services/singletons.ts

@@ -1,6 +1,5 @@
 import { SharedService } from '@slickgrid-universal/common';
 import { EventPubSubService } from '@slickgrid-universal/event-pub-sub';
-
 import { ContainerService } from './container.service.js';
 
 export const GlobalEventPubSubService = new EventPubSubService();

package/src/services/translaterI18Next.service.ts

@@ -1,5 +1,4 @@
 import type { TranslaterService as UniversalTranslateService } from '@slickgrid-universal/common';
-
 import type { I18Next } from '../models/i18next.interface.js';
 
 /**

package/src/slickgrid-config.ts

@@ -1,5 +1,5 @@
-import type { GridOption } from './models/gridOption.interface.js';
 import { GlobalGridOptions } from './global-grid-options.js';
+import type { GridOption } from './models/gridOption.interface.js';
 
 export class SlickgridConfig {
   options: Partial<GridOption>;