create-react-admin-template 0.0.0-stage → 0.1.0

package/template/src/components/AppTable/table/grid/useTableGrid.ts

@@ -0,0 +1,857 @@
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  type RefObject,
+} from 'react'
+import type { CellChange, GridSettings } from 'handsontable'
+import { textRenderer } from 'handsontable/renderers'
+import type { CellMeta } from 'handsontable/settings'
+import { createSelectionRenderer } from '@/components/AppTable/engine/cell/customCell/renderers/selection'
+import type { TableCellLayerAdapter } from '@/components/AppTable/engine/cell/customCell/types'
+import type { TableIntlFormatter } from '@/components/AppTable/engine/cell/formatting'
+import {
+  countTableStartActionColumns,
+  type TableColumn as EngineTableColumn,
+} from '@/components/AppTable/engine/columns/column'
+import { buildTableGridColumns } from '@/components/AppTable/engine/columns/gridColumns'
+import { TABLE_DEFAULT_ROW_KEY } from '@/components/AppTable/engine/config/constants'
+import { compileTableGridSettings } from '@/components/AppTable/engine/config/grid/compiler'
+import { createTableGridDefaultSettings } from '@/components/AppTable/engine/config/grid/defaults'
+import { TABLE_GRID_HOOK_OWNERSHIP } from '@/components/AppTable/engine/config/grid/ownership'
+import type { ResolvedTablePaginationConfig } from '@/components/AppTable/engine/pagination/types'
+import type { TablePreferenceUpdater } from '@/components/AppTable/engine/preference/preference'
+import type { TablePreference } from '@/components/AppTable/engine/preference/types'
+import type { SelectionState } from '@/components/AppTable/engine/selection/types'
+import { createTableClickCoordinator } from '@/components/AppTable/engine/shared/interaction'
+import { getTableRowValue } from '@/components/AppTable/engine/shared/row'
+import type { TableThemeController } from '@/components/AppTable/engine/shared/theme'
+import type {
+  TableRow,
+  TableRowInteractionContext,
+  TableSelectionRangeContext,
+} from '@/components/AppTable/engine/shared/types'
+import { createTableSelectionSumTask } from '@/components/AppTable/engine/summary/selectionSum'
+import {
+  type TableSummaryColumn,
+  type TableSummaryResult,
+} from '@/components/AppTable/engine/summary/summary'
+import type { TableController } from '@/components/AppTable/engine/table/controller/TableController'
+import type { TableSnapshot } from '@/components/AppTable/engine/table/controller/types'
+import { resolveTableCellMeta } from '@/components/AppTable/engine/table/grid/cellMeta'
+import { createTableFixedEndHooks } from '@/components/AppTable/engine/table/hooks/fixedEndHooks'
+import type { TableGridHooks } from '@/components/AppTable/engine/table/hooks/gridHooks'
+import { createTableHeaderHooks } from '@/components/AppTable/engine/table/hooks/headerHooks'
+import { fitTableDropdownMenuToViewport } from '@/components/AppTable/engine/table/layout/dropdownMenu'
+import { resolveTableFixedColumnsEnd } from '@/components/AppTable/engine/table/layout/fixedColumns'
+import { createTableFixedEndRuntime } from '@/components/AppTable/engine/table/layout/fixedEndRuntime'
+import {
+  buildTableAutoMergeCells,
+  resolveTableMergeCells,
+} from '@/components/AppTable/engine/table/layout/mergeCells'
+import { buildTableNestedHeaders } from '@/components/AppTable/engine/table/layout/nestedHeaders'
+import type { ITableCellComponentSession } from '../../cell'
+import type { ResolvedTableComponentProps, TableColumn } from '../../config'
+import { useAppTableMessages } from '../../messages'
+
+interface IUseTableGridOptions<T extends TableRow> {
+  objContainerRef: RefObject<HTMLDivElement | null>
+  objFixedEndShadowRef: RefObject<HTMLDivElement | null>
+  objProps: ResolvedTableComponentProps<T>
+  arrColumns: readonly TableColumn<T>[]
+  objPreference: TablePreference
+  fnUpdatePreference: (updater: TablePreferenceUpdater) => Promise<unknown>
+  objHeight: number | string
+  objController: TableController<T>
+  objSnapshot: TableSnapshot<T>
+  objSelectionHeaderState: {
+    selectableRows: readonly T[]
+    selectedCount: number
+  }
+  objPagination: ResolvedTablePaginationConfig
+  objLayer: TableCellLayerAdapter
+  objCellComponentSession: ITableCellComponentSession
+  objFormatter: TableIntlFormatter
+  objThemeController: TableThemeController
+  nPage: number
+  nPageSize: number
+  fnReportError: (objError: unknown) => void
+  fnOnDataChange?: (arrRows: T[]) => void
+  fnOnCellChange?: (arrChanges: CellChange[], strSource: string) => void
+  fnOnSelectionChange?: (arrRows: T[], objSelection: SelectionState<T>) => void
+  fnOnSelectionEnd?: (objContext: TableSelectionRangeContext) => void
+  fnOnRowClick?: (objContext: TableRowInteractionContext<T>) => void
+  fnOnRowDoubleClick?: (objContext: TableRowInteractionContext<T>) => void
+  fnOnSelectedCellSumChange: (strSum: string | null) => void
+  arrSummaryColumns?: readonly TableSummaryColumn<T>[]
+  strSummaryLabel?: string
+  objSummaryResult?: TableSummaryResult
+  nSummaryRevision?: number
+  fnRefreshSummary?: () => void
+}
+
+const TABLE_SUMMARY_ROW_MARKER = '__TABLE_COMPONENT_SUMMARY_ROW__'
+
+function fnIsInternalTableChange(strSource: string) {
+  return (
+    strSource === 'loadData' ||
+    strSource === 'updateData' ||
+    strSource === 'MergeCells' ||
+    strSource === 'ColumnSummary.reset' ||
+    strSource === 'ColumnSummary.set'
+  )
+}
+
+function fnRemoveTableHeaderMenu(objHeader: HTMLTableCellElement) {
+  objHeader.querySelector('button.changeType')?.remove()
+  objHeader.removeAttribute('aria-haspopup')
+}
+
+function fnResolveTruncatedTableHeader(objHeader: HTMLTableCellElement) {
+  const objHeaderLabel = objHeader.querySelector<HTMLElement>('.colHeader')
+  const strHeaderLabel = objHeaderLabel?.textContent?.trim()
+
+  return objHeaderLabel &&
+    strHeaderLabel &&
+    objHeaderLabel.scrollWidth > objHeaderLabel.clientWidth
+    ? { objHeaderLabel, strHeaderLabel }
+    : undefined
+}
+
+export function useTableGrid<T extends TableRow>({
+  objContainerRef,
+  objFixedEndShadowRef,
+  objProps,
+  arrColumns,
+  objPreference,
+  fnUpdatePreference,
+  objHeight,
+  objController,
+  objSnapshot,
+  objSelectionHeaderState,
+  objPagination,
+  objLayer,
+  objCellComponentSession,
+  objFormatter,
+  objThemeController,
+  nPage,
+  nPageSize,
+  fnReportError,
+  fnOnDataChange,
+  fnOnCellChange,
+  fnOnSelectionChange,
+  fnOnSelectionEnd,
+  fnOnRowClick,
+  fnOnRowDoubleClick,
+  fnOnSelectedCellSumChange,
+  arrSummaryColumns = [],
+  strSummaryLabel,
+  objSummaryResult,
+  nSummaryRevision = -1,
+  fnRefreshSummary,
+}: IUseTableGridOptions<T>) {
+  const objMessages = useAppTableMessages()
+  const strResolvedSummaryLabel = strSummaryLabel ?? objMessages.strSummary
+  const objSelectionSumTaskRef = useRef<
+    ReturnType<typeof createTableSelectionSumTask> | undefined
+  >(undefined)
+  objSelectionSumTaskRef.current ??= createTableSelectionSumTask()
+  useEffect(
+    () => () => objSelectionSumTaskRef.current?.cancel('table-disposed'),
+    []
+  )
+  const objRowClickCoordinator = useMemo(
+    () =>
+      createTableClickCoordinator<TableRowInteractionContext<T>>({
+        onClick: (objContext) => fnOnRowClick?.(objContext),
+        onDoubleClick: (objContext) => fnOnRowDoubleClick?.(objContext),
+      }),
+    [fnOnRowClick, fnOnRowDoubleClick]
+  )
+  useEffect(
+    () => () => objRowClickCoordinator.cancel(),
+    [objRowClickCoordinator]
+  )
+  const arrVisibleColumns = useMemo(
+    () =>
+      arrColumns.filter(
+        (objColumn) => objColumn.enabled !== false && !objColumn.hidden
+      ),
+    [arrColumns]
+  )
+  const bSummaryEnabled = arrSummaryColumns.length > 0
+  const bHasCurrentSummary = nSummaryRevision === objSnapshot.dataRevision
+  const objSummaryRow = useMemo(() => {
+    if (!bSummaryEnabled) return undefined
+    const objRow = { [TABLE_SUMMARY_ROW_MARKER]: true } as T
+    const objSummaryKeys = new Set(
+      arrSummaryColumns.map((objColumn) => String(objColumn.key))
+    )
+    const objLabelColumn = arrVisibleColumns.find(
+      (objColumn) =>
+        !objSummaryKeys.has(String(objColumn.key)) &&
+        objColumn.renderer !== 'button' &&
+        !objColumn.actions?.length
+    )
+    if (objLabelColumn) {
+      Reflect.set(objRow, objLabelColumn.key, strResolvedSummaryLabel)
+    }
+    arrSummaryColumns.forEach((objColumn) => {
+      Reflect.set(
+        objRow,
+        objColumn.key,
+        bHasCurrentSummary
+          ? (objSummaryResult?.formattedValues[String(objColumn.key)] ?? '-')
+          : '-'
+      )
+    })
+    return objRow
+  }, [
+    arrSummaryColumns,
+    arrVisibleColumns,
+    bHasCurrentSummary,
+    bSummaryEnabled,
+    objSummaryResult,
+    strResolvedSummaryLabel,
+  ])
+  const arrProjectedRows = useMemo(
+    () =>
+      objSummaryRow ? [...objSnapshot.rows, objSummaryRow] : objSnapshot.rows,
+    [objSnapshot.rows, objSummaryRow]
+  )
+  const fnIsSummaryRow = useCallback(
+    (objRow: T | undefined) =>
+      Boolean(objRow && Reflect.get(objRow, TABLE_SUMMARY_ROW_MARKER)),
+    []
+  )
+  const objSummaryProjectionRef = useRef(objSummaryRow)
+  useLayoutEffect(() => {
+    objSummaryProjectionRef.current = objSummaryRow
+    objController.refreshDataProjection()
+  }, [objController, objSummaryRow])
+  useLayoutEffect(
+    () =>
+      objController.setDataProjection((arrRows) => {
+        const objCurrentSummary = objSummaryProjectionRef.current
+        return {
+          data: objCurrentSummary ? [...arrRows, objCurrentSummary] : arrRows,
+          settings: {
+            fixedRowsBottom:
+              Number(objProps.settings.fixedRowsBottom ?? 0) +
+              (objCurrentSummary ? 1 : 0),
+          },
+        }
+      }),
+    [objController, objProps.settings.fixedRowsBottom]
+  )
+  const nPreferredFrozenColumns = useMemo(() => {
+    const objFrozen = new Set(objPreference.frozenColumns ?? [])
+    let nCount = 0
+    for (const objColumn of arrVisibleColumns) {
+      if (!objFrozen.has(String(objColumn.key))) break
+      nCount += 1
+    }
+    return nCount
+  }, [arrVisibleColumns, objPreference.frozenColumns])
+
+  const fnSelectionRenderer = useMemo(
+    () =>
+      objProps.selectable
+        ? createSelectionRenderer<T>({
+            isSelected: (objRow) => objController.isRowSelected(objRow),
+            isDisabled: (objRow) => !objController.canSelectRow(objRow),
+            isInteractive: (objRow) => !fnIsSummaryRow(objRow),
+            toggle: (objRow, bChecked) => {
+              objController.toggleRowSelection(objRow, bChecked)
+              fnOnSelectionChange?.(
+                objController.getLoadedSelectedRows(),
+                objController.getSelection()
+              )
+            },
+            messages: objMessages,
+          })
+        : undefined,
+    [
+      fnIsSummaryRow,
+      fnOnSelectionChange,
+      objController,
+      objMessages,
+      objProps.selectable,
+    ]
+  )
+
+  const arrGridColumns = useMemo<EngineTableColumn<T>[]>(
+    () =>
+      arrVisibleColumns.map((objColumn) => {
+        if (!('cellComponent' in objColumn) || !objColumn.cellComponent) {
+          return objColumn
+        }
+        const {
+          cellComponent: CellComponent,
+          renderer: _objRenderer,
+          ...objEngineColumn
+        } = objColumn
+        return {
+          ...objEngineColumn,
+          readOnly: true,
+          renderer: objCellComponentSession.createRenderer(
+            objColumn,
+            CellComponent,
+            (objValue, objFormat) => objFormatter.format(objValue, objFormat),
+            () => objController.dataRevision
+          ),
+        } as EngineTableColumn<T>
+      }),
+    [arrVisibleColumns, objCellComponentSession, objController, objFormatter]
+  )
+
+  const arrHotColumns = useMemo(
+    () =>
+      buildTableGridColumns({
+        columns: arrGridColumns,
+        defaultColumnWidth: objProps.defaultColumnWidth,
+        selectable: objProps.selectable,
+        selectionRenderer: fnSelectionRenderer,
+        getInstance: () => objController.instance,
+        getRows: () => objController.snapshot.rows,
+        updateCell: (nVisualRow, strKey, objValue) =>
+          objController.commitControlledCell(nVisualRow, strKey, objValue),
+        layer: objLayer,
+        formatValue: (objValue, objFormat) =>
+          objFormatter.format(objValue, objFormat),
+        messages: objMessages,
+      }),
+    [
+      arrGridColumns,
+      objController,
+      objFormatter,
+      objLayer,
+      objMessages,
+      objProps.defaultColumnWidth,
+      objProps.selectable,
+      fnSelectionRenderer,
+    ]
+  )
+
+  const objNestedHeaders = useMemo(
+    () =>
+      objProps.headerGroups?.length
+        ? buildTableNestedHeaders({
+            columns: arrVisibleColumns.map((objColumn) => ({
+              key: String(objColumn.key),
+              label: objColumn.label,
+            })),
+            groups: objProps.headerGroups,
+            selectionLabel: objProps.selectable
+              ? objMessages.strSelectionColumn
+              : undefined,
+          })
+        : undefined,
+    [
+      arrVisibleColumns,
+      objMessages.strSelectionColumn,
+      objProps.headerGroups,
+      objProps.selectable,
+    ]
+  )
+
+  const objMergeCells = useMemo(() => {
+    const arrRows = objSnapshot.rows
+    const objColumnIndex = new Map(
+      arrVisibleColumns.map((objColumn, nIndex) => [
+        String(objColumn.key),
+        nIndex,
+      ])
+    )
+    if (typeof objProps.mergeCells === 'function') {
+      return resolveTableMergeCells(objProps.mergeCells, {
+        rows: arrRows,
+        columns: arrVisibleColumns.map((objColumn) => String(objColumn.key)),
+        columnOffset: objProps.selectable ? 1 : 0,
+        resolveColumn: (strKey) => objColumnIndex.get(strKey),
+      })
+    }
+    if (!objProps.autoMerge) return objProps.mergeCells
+    return buildTableAutoMergeCells({
+      rows: arrRows,
+      columns: objProps.autoMerge.columns.map(String),
+      hierarchical: objProps.autoMerge.hierarchical,
+      mergeEmpty: objProps.autoMerge.mergeEmpty,
+      columnOffset: objProps.selectable ? 1 : 0,
+      resolveColumn: (strKey) => objColumnIndex.get(strKey),
+    })
+  }, [
+    arrVisibleColumns,
+    objProps.autoMerge,
+    objProps.mergeCells,
+    objProps.selectable,
+    objSnapshot.rows,
+  ])
+
+  const nFixedColumnsEnd = useMemo(
+    () =>
+      resolveTableFixedColumnsEnd({
+        columns: arrVisibleColumns,
+        fixedColumnsEnd: objProps.fixedColumnsEnd,
+        autoFreezeEndActions: objProps.autoFreezeEndActions,
+      }),
+    [arrVisibleColumns, objProps.autoFreezeEndActions, objProps.fixedColumnsEnd]
+  )
+  const nFixedActionColumnsStart = objProps.autoFreezeStartActions
+    ? Math.min(
+        countTableStartActionColumns(arrVisibleColumns),
+        Math.max(0, arrVisibleColumns.length - nFixedColumnsEnd)
+      )
+    : 0
+
+  const objFixedEndRuntime = useMemo(
+    () =>
+      createTableFixedEndRuntime({
+        getContainer: () => objContainerRef.current,
+        getShadowElement: () => objFixedEndShadowRef.current,
+        getFixedColumnsEnd: () => nFixedColumnsEnd,
+        getTotalColumns: () => arrHotColumns.length,
+        getInstance: () => objController.instance,
+        getDataRevision: () => objController.dataRevision,
+        messages: objMessages,
+      }),
+    [
+      arrHotColumns.length,
+      nFixedColumnsEnd,
+      objContainerRef,
+      objController,
+      objFixedEndShadowRef,
+      objMessages,
+    ]
+  )
+  useEffect(() => () => objFixedEndRuntime.cancel(), [objFixedEndRuntime])
+  const objFixedEndHooks = useMemo(
+    () =>
+      createTableFixedEndHooks({
+        applyFixedEndElement: objFixedEndRuntime.applyElement,
+        scheduleFixedEndShadow: objFixedEndRuntime.scheduleShadow,
+      }),
+    [objFixedEndRuntime]
+  )
+  const objHeaderHooks = useMemo(
+    () =>
+      createTableHeaderHooks<T>({
+        messages: objMessages,
+        getNestedHeaders: () => objNestedHeaders,
+        getSelectable: () => objProps.selectable,
+        getColumns: () => arrVisibleColumns,
+        getRows: () => objController.snapshot.rows,
+        getColumnProperty: (nColumn) => {
+          const objProperty = objController.instance?.colToProp(nColumn)
+          return typeof objProperty === 'string' ||
+            typeof objProperty === 'number'
+            ? objProperty
+            : undefined
+        },
+        applyFixedEndElement: objFixedEndRuntime.applyElement,
+        getSelectionOptions: () => objProps.selectionOptions,
+        canSelect: (objRow) => objController.canSelectRow(objRow),
+        isSelected: (objRow) => objController.isRowSelected(objRow),
+        selectPage: (arrRows, bSelected) =>
+          objController.selectPage(arrRows, bSelected),
+        onSelectionChange: () =>
+          fnOnSelectionChange?.(
+            objController.getLoadedSelectedRows(),
+            objController.getSelection()
+          ),
+        getSelectionState: () => objSelectionHeaderState,
+      }),
+    [
+      arrVisibleColumns,
+      fnOnSelectionChange,
+      objController,
+      objFixedEndRuntime,
+      objNestedHeaders,
+      objMessages,
+      objProps.selectable,
+      objProps.selectionOptions,
+      objSelectionHeaderState,
+    ]
+  )
+
+  const fnSaveFrozenColumns = useCallback(() => {
+    const nCount = Math.max(
+      0,
+      Number(objController.instance?.getSettings().fixedColumnsStart ?? 0) -
+        (objProps.selectable ? 1 : 0)
+    )
+    const arrFrozenColumns = arrVisibleColumns
+      .slice(0, nCount)
+      .map((objColumn) => String(objColumn.key))
+    void fnUpdatePreference((objCurrent) => ({
+      ...objCurrent,
+      frozenColumns: arrFrozenColumns,
+    }))
+  }, [
+    arrVisibleColumns,
+    fnUpdatePreference,
+    objController,
+    objProps.selectable,
+  ])
+
+  return useMemo<GridSettings>(() => {
+    const objInternalHooks: TableGridHooks = {
+      ...objFixedEndHooks,
+      ...objHeaderHooks,
+      afterRenderer: (
+        objCell,
+        nRow,
+        nColumn,
+        objProperty,
+        objValue,
+        objCellProperties
+      ) => {
+        objFixedEndHooks.afterRenderer?.(
+          objCell,
+          nRow,
+          nColumn,
+          objProperty,
+          objValue,
+          objCellProperties
+        )
+      },
+      afterViewRender: (bIsForced) => {
+        objFixedEndHooks.afterViewRender?.(bIsForced)
+        // 一个视图渲染周期只清理一次失联 TD，避免每个单元格都调度快照发布。
+        objCellComponentSession.prune()
+      },
+      afterColumnResize: (nNewSize, nColumn) => {
+        const objKey = objController.instance?.colToProp(nColumn)
+        if (typeof objKey === 'string' && objKey !== '__tableSelection') {
+          void fnUpdatePreference((objCurrent) => ({
+            ...objCurrent,
+            columnWidths: {
+              ...objCurrent.columnWidths,
+              [objKey]: nNewSize,
+            },
+          }))
+        }
+        window.requestAnimationFrame(() => objController.render())
+      },
+      beforeColumnMove: (arrMovedColumns, nFinalIndex) => {
+        if (
+          objProps.selectable &&
+          (arrMovedColumns.includes(0) || nFinalIndex === 0)
+        )
+          return false
+      },
+      afterColumnMove: (...arrArguments) => {
+        if (!arrArguments[4]) return
+        const objHot = objController.instance
+        if (!objHot) return
+        const arrVisibleOrder = Array.from(
+          { length: objHot.countCols() },
+          (_, nIndex) => String(objHot.colToProp(nIndex))
+        ).filter((strKey) => strKey !== '__tableSelection')
+        const objVisibleKeys = new Set(arrVisibleOrder)
+        const arrRemainingKeys = arrColumns
+          .map((objColumn) => String(objColumn.key))
+          .filter((strKey) => !objVisibleKeys.has(strKey))
+        void fnUpdatePreference((objCurrent) => ({
+          ...objCurrent,
+          columnOrder: [...arrVisibleOrder, ...arrRemainingKeys],
+        }))
+      },
+      afterColumnFreeze: (_nColumn, bPerformed) => {
+        if (bPerformed) fnSaveFrozenColumns()
+      },
+      afterColumnUnfreeze: (_nColumn, bPerformed) => {
+        if (bPerformed) fnSaveFrozenColumns()
+      },
+      cells: (nRow, nColumn, objProp) => {
+        const objInherited = objProps.settings.cells?.call(
+          objController.instance,
+          nRow,
+          nColumn,
+          objProp
+        ) as CellMeta | undefined
+        const nColumnOffset = objProps.selectable ? 1 : 0
+        const objColumn = arrVisibleColumns[nColumn - nColumnOffset]
+        // Handsontable 的 cells() 回调使用物理坐标；展示态（如斑马纹）再显式映射到视觉行。
+        const nPhysicalRow = nRow
+        const nVisualRow =
+          objController.instance?.toVisualRow(nPhysicalRow) ?? nRow
+        const objRow =
+          (objController.instance?.getSourceDataAtRow?.(nPhysicalRow) as
+            | T
+            | undefined) ?? arrProjectedRows[nPhysicalRow]
+        if (fnIsSummaryRow(objRow)) {
+          return {
+            ...(objInherited ?? {}),
+            readOnly: true,
+            renderer: textRenderer,
+            className: [
+              objInherited?.className,
+              'columnSummaryResult',
+              'htMiddle',
+            ]
+              .filter(Boolean)
+              .join(' '),
+          }
+        }
+        if (!objColumn || !objRow) return objInherited ?? {}
+        const objResolved = objProps.resolveCell?.({
+          row: objRow,
+          rowIndex: nPhysicalRow,
+          column: objColumn,
+          columnIndex: nColumn - nColumnOffset,
+        })
+        return resolveTableCellMeta({
+          inherited: objInherited,
+          resolved: objResolved,
+          row: objRow,
+          column: objColumn,
+          visualRow: nVisualRow,
+          physicalRow: nPhysicalRow,
+          striped: objProps.striped,
+          cellState: objController.getCellState(
+            getTableRowValue(
+              objRow,
+              String(objProps.rowKey ?? TABLE_DEFAULT_ROW_KEY)
+            ),
+            String(objColumn.key)
+          ),
+        })
+      },
+      beforeChange: (arrChanges, strSource) => {
+        if (!arrChanges || fnIsInternalTableChange(strSource)) return
+        if (!objProps.allowBulkEdit && arrChanges.filter(Boolean).length > 1) {
+          fnReportError(new Error(objMessages.strSingleCellEditOnly))
+          return false
+        }
+        const objResult = objController.processChanges(arrChanges, strSource)
+        if (objResult.rejected.length) {
+          fnReportError(new Error(objResult.rejected[0]!.message))
+        }
+        return objResult.accepted.length ? undefined : false
+      },
+      afterChange: (arrChanges, strSource) => {
+        if (!arrChanges || fnIsInternalTableChange(strSource)) return
+        const arrAcceptedChanges = arrChanges.filter(
+          (arrChange): arrChange is CellChange => Boolean(arrChange)
+        )
+        if (!arrAcceptedChanges.length) return
+        objController.recordChanges(arrAcceptedChanges)
+        fnOnDataChange?.(objController.getData())
+        fnOnCellChange?.(arrAcceptedChanges, strSource)
+        fnRefreshSummary?.()
+      },
+      afterSelectionEnd: (nRow, nColumn, nRow2, nColumn2) => {
+        const objInstance = objController.instance
+        fnOnSelectionEnd?.({
+          start: {
+            visualRow: nRow,
+            physicalRow: objInstance?.toPhysicalRow(nRow) ?? nRow,
+            visualColumn: nColumn,
+            physicalColumn: objInstance?.toPhysicalColumn(nColumn) ?? nColumn,
+          },
+          end: {
+            visualRow: nRow2,
+            physicalRow: objInstance?.toPhysicalRow(nRow2) ?? nRow2,
+            visualColumn: nColumn2,
+            physicalColumn: objInstance?.toPhysicalColumn(nColumn2) ?? nColumn2,
+          },
+        })
+        if (!objProps.summarySelected) {
+          objSelectionSumTaskRef.current?.cancel('summary-disabled')
+          fnOnSelectedCellSumChange(null)
+          return
+        }
+        const arrSelected = objInstance?.getSelected() ?? []
+        objSelectionSumTaskRef.current?.calculate({
+          ranges: arrSelected,
+          getValue: (nSelectedRow, nSelectedColumn) =>
+            objInstance?.getDataAtCell(nSelectedRow, nSelectedColumn),
+          onResult: fnOnSelectedCellSumChange,
+          onError: fnReportError,
+        })
+      },
+      afterDeselect: () => {
+        objSelectionSumTaskRef.current?.cancel('selection-cleared')
+        fnOnSelectedCellSumChange(null)
+      },
+      afterOnCellMouseUp: (objEvent, objCoords) => {
+        if (
+          objCoords.row === null ||
+          objCoords.col === null ||
+          objCoords.row < 0
+        ) {
+          return
+        }
+        const objInstance = objController.instance
+        const nPhysicalRow =
+          objInstance?.toPhysicalRow(objCoords.row) ?? objCoords.row
+        const nPhysicalColumn =
+          objInstance?.toPhysicalColumn(objCoords.col) ?? objCoords.col
+        const objRow =
+          (objInstance?.getSourceDataAtRow?.(nPhysicalRow) as T | undefined) ??
+          arrProjectedRows[nPhysicalRow]
+        if (!objRow || fnIsSummaryRow(objRow)) return
+        const nDataColumn = objCoords.col - (objProps.selectable ? 1 : 0)
+        const strColumnKey =
+          nDataColumn >= 0
+            ? String(arrVisibleColumns[nDataColumn]?.key ?? '') || undefined
+            : undefined
+        const objContext: TableRowInteractionContext<T> = {
+          row: objRow,
+          rowIndex: nPhysicalRow,
+          visualRow: objCoords.row,
+          physicalRow: nPhysicalRow,
+          visualColumn: objCoords.col,
+          physicalColumn: nPhysicalColumn,
+          columnKey: strColumnKey,
+          readOnly: Boolean(
+            objInstance?.getCellMeta(objCoords.row, objCoords.col).readOnly
+          ),
+          event: objEvent,
+        }
+        const strDisposition = objRowClickCoordinator.schedule(
+          `${nPhysicalRow}:${objCoords.col}`,
+          objContext
+        )
+        const strRowSelection = objProps.selectionOptions.rowClick ?? 'none'
+        const bClickedSelection =
+          objEvent.target instanceof Element &&
+          Boolean(objEvent.target.closest('.table-component__selection'))
+        if (
+          objProps.selectable &&
+          strDisposition === 'pending' &&
+          strRowSelection !== 'none' &&
+          !bClickedSelection &&
+          objController.canSelectRow(objRow)
+        ) {
+          objController.toggleRowSelection(
+            objRow,
+            strRowSelection === 'select'
+              ? true
+              : !objController.isRowSelected(objRow)
+          )
+          fnOnSelectionChange?.(
+            objController.getLoadedSelectedRows(),
+            objController.getSelection()
+          )
+        }
+      },
+      beforeCreateRow: (_nIndex, _nAmount, strSource) =>
+        strSource === 'CopyPaste.paste' || strSource === 'Autofill.fill'
+          ? false
+          : undefined,
+      afterDropdownMenuShow: (objDropdownMenu) => {
+        fitTableDropdownMenuToViewport(objDropdownMenu)
+      },
+      afterGetColHeader: (nVisualColumn, objHeader, nHeaderLevel) => {
+        objHeaderHooks.afterGetColHeader?.(
+          nVisualColumn,
+          objHeader,
+          nHeaderLevel
+        )
+        if (objProps.headerMenuTrigger === 'hidden') {
+          fnRemoveTableHeaderMenu(objHeader)
+        }
+      },
+      afterOnCellMouseOver: (_objEvent, objCoords, objCell) => {
+        if (objCoords.row === null || objCoords.row >= 0) return
+        const objHeader = fnResolveTruncatedTableHeader(objCell)
+        if (!objHeader) {
+          objLayer.hideTooltip()
+          return
+        }
+        objLayer.showTooltip(objHeader.strHeaderLabel, objHeader.objHeaderLabel)
+      },
+      afterOnCellMouseOut: (_objEvent, objCoords) => {
+        if (objCoords.row !== null && objCoords.row < 0) objLayer.hideTooltip()
+      },
+    }
+    const objControlledSettings: GridSettings = {
+      data: arrProjectedRows as T[],
+      columns: arrHotColumns,
+      colHeaders: [
+        ...(objProps.selectable ? [objMessages.strSelectionColumn] : []),
+        ...arrVisibleColumns.map((objColumn) => objColumn.label),
+      ],
+      rowHeaders: objProps.showIndex
+        ? (nRow) =>
+            fnIsSummaryRow(arrProjectedRows[nRow])
+              ? ''
+              : String(
+                  objPagination.enabled
+                    ? (nPage - 1) * nPageSize + nRow + 1
+                    : nRow + 1
+                )
+        : false,
+      nestedHeaders: objNestedHeaders?.nestedHeaders,
+      collapsibleColumns: objNestedHeaders?.collapsibleColumns ?? false,
+      mergeCells: objMergeCells,
+      licenseKey: objProps.licenseKey,
+      theme: objThemeController.theme,
+      height: objHeight,
+      viewportColumnRenderingOffset:
+        objProps.settings.viewportColumnRenderingOffset,
+      fixedColumnsStart:
+        (objProps.selectable ? 1 : 0) +
+        Math.max(nFixedActionColumnsStart, nPreferredFrozenColumns),
+      fixedRowsTop: Math.min(
+        objPreference.frozenRows ?? 0,
+        objSnapshot.rows.length
+      ),
+      fixedRowsBottom:
+        Number(objProps.settings.fixedRowsBottom ?? 0) +
+        (objSummaryRow ? 1 : 0),
+      fillHandle: objProps.allowBulkEdit,
+      minSpareRows: 0,
+      currentRowClassName: objProps.highlightCurrentRow
+        ? 'table-component__current-row'
+        : undefined,
+    }
+    return compileTableGridSettings({
+      defaults: createTableGridDefaultSettings(),
+      consumer: objProps.settings,
+      controlled: objControlledSettings,
+      internalHooks: objInternalHooks,
+      hookPolicies: TABLE_GRID_HOOK_OWNERSHIP,
+    })
+  }, [
+    arrHotColumns,
+    arrColumns,
+    arrProjectedRows,
+    arrVisibleColumns,
+    fnOnCellChange,
+    fnOnDataChange,
+    fnOnSelectedCellSumChange,
+    fnOnSelectionEnd,
+    fnOnSelectionChange,
+    fnRefreshSummary,
+    fnIsSummaryRow,
+    fnSaveFrozenColumns,
+    fnUpdatePreference,
+    fnReportError,
+    nPage,
+    nPageSize,
+    objController,
+    objCellComponentSession,
+    objFixedEndHooks,
+    objHeaderHooks,
+    objRowClickCoordinator,
+    objMergeCells,
+    objMessages.strSelectionColumn,
+    objMessages.strSingleCellEditOnly,
+    objNestedHeaders,
+    objLayer,
+    objPagination.enabled,
+    objProps,
+    objHeight,
+    objSnapshot.rows,
+    objSummaryRow,
+    objThemeController.theme,
+    nFixedActionColumnsStart,
+    nPreferredFrozenColumns,
+    objPreference.frozenRows,
+  ])
+}