@infinite-table/infinite-react 6.1.1-canary.0 → 6.1.1

package/index.dev.mjs

@@ -19517,6 +19517,377 @@ function getRowDetailApi(param) {
   return rowDetailApi;
 }
 
+// src/components/utils/clamp.ts
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// src/components/InfiniteTable/eventHandlers/keyboardNavigation.ts
+function getNextEnabledRowIndex(getDataSourceState, activeRowIndex, direction) {
+  const dataArray = getDataSourceState().dataArray;
+  const min = 0;
+  const max = dataArray.length - 1;
+  let i = activeRowIndex;
+  do {
+    i += direction;
+    const rowInfo = dataArray[i];
+    if (!rowInfo) {
+      return i < min ? min : max;
+    }
+    if (!rowInfo.rowDisabled) {
+      return i;
+    }
+  } while (i >= min && i <= max);
+  return clamp(i, min, max);
+}
+function handleRowNavigation(options, event) {
+  const { getState, getDataSourceState, actions, api, dataSourceApi } = options;
+  const { key } = event;
+  const dataArray = getDataSourceState().dataArray;
+  const arrLength = dataArray.length;
+  const state = getState();
+  const { brain } = state;
+  let { activeRowIndex } = state;
+  if (activeRowIndex == null) {
+    return false;
+  }
+  const {
+    start: [startRow],
+    end: [endRow]
+  } = brain.getRenderRange();
+  const initialActiveRowIndex = activeRowIndex;
+  const renderRowCount = endRow - startRow - 1;
+  const min = 0;
+  const max = arrLength - 1;
+  const KeyToFunction = {
+    ArrowDown: () => {
+      activeRowIndex = getNextEnabledRowIndex(
+        getDataSourceState,
+        activeRowIndex,
+        1
+      );
+    },
+    ArrowUp: () => {
+      activeRowIndex = getNextEnabledRowIndex(
+        getDataSourceState,
+        activeRowIndex,
+        -1
+      );
+    },
+    ArrowLeft: () => {
+      const rowInfo = dataArray[activeRowIndex];
+      if (brain.isHorizontalLayoutBrain) {
+        const rowsPerPage = brain.rowsPerPage;
+        if (activeRowIndex - rowsPerPage >= min) {
+          activeRowIndex = activeRowIndex - rowsPerPage;
+        } else {
+          KeyToFunction.ArrowUp();
+        }
+        return;
+      }
+      if (rowInfo && rowInfo.isGroupRow) {
+        return api.collapseGroupRow(rowInfo.groupKeys);
+      }
+      if (rowInfo && api.rowDetailApi.isRowDetailEnabledForRow(rowInfo.id)) {
+        return api.rowDetailApi.collapseRowDetail(rowInfo.id);
+      }
+      return false;
+    },
+    ArrowRight: () => {
+      const rowInfo = dataArray[activeRowIndex];
+      if (brain.isHorizontalLayoutBrain) {
+        const rowsPerPage = brain.rowsPerPage;
+        if (activeRowIndex + rowsPerPage <= max) {
+          activeRowIndex = activeRowIndex + rowsPerPage;
+        } else {
+          KeyToFunction.ArrowDown();
+        }
+        return;
+      }
+      if (rowInfo && rowInfo.isGroupRow) {
+        return api.expandGroupRow(rowInfo.groupKeys);
+      }
+      if (rowInfo && api.rowDetailApi.isRowDetailEnabledForRow(rowInfo.id)) {
+        return api.rowDetailApi.expandRowDetail(rowInfo.id);
+      }
+      return false;
+    },
+    Enter: () => {
+      const rowInfo = dataArray[activeRowIndex];
+      if (rowInfo && rowInfo.isGroupRow) {
+        return api.toggleGroupRow(rowInfo.groupKeys);
+      }
+      if (rowInfo && rowInfo.isTreeNode && rowInfo.isParentNode) {
+        return dataSourceApi.treeApi.toggleNode(rowInfo.nodePath);
+      }
+      const hasRowDetail = api.rowDetailApi.isRowDetailEnabledForRow(
+        rowInfo.id
+      );
+      if (hasRowDetail) {
+        return api.rowDetailApi.toggleRowDetail(rowInfo.id);
+      }
+      return false;
+    },
+    PageDown: () => {
+      activeRowIndex = Math.min(
+        activeRowIndex + renderRowCount,
+        arrLength - 1
+      );
+    },
+    PageUp: () => {
+      activeRowIndex = Math.max(activeRowIndex - renderRowCount, min);
+    },
+    End: () => {
+      activeRowIndex = max;
+    },
+    Home: () => {
+      activeRowIndex = min;
+    }
+  };
+  const Fn = KeyToFunction[key];
+  if (!Fn) {
+    return false;
+  }
+  Fn();
+  if (initialActiveRowIndex !== activeRowIndex) {
+    actions.activeRowIndex = activeRowIndex;
+    return true;
+  }
+  return false;
+}
+function computeNextActiveCellIndex(options, event) {
+  const {
+    api,
+    getState,
+    getComputed,
+    getDataSourceState,
+    dataSourceApi
+  } = options;
+  const { key, shiftKey } = event;
+  const dataArray = getDataSourceState().dataArray;
+  const state = getState();
+  const { activeCellIndex, brain } = state;
+  if (!activeCellIndex) {
+    return false;
+  }
+  let [rowIndex, colIndex] = activeCellIndex;
+  const {
+    start: [startRow, startCol],
+    end: [endRow, endCol]
+  } = brain.getRenderRange();
+  const renderRowCount = endRow - startRow - 1;
+  const renderColCount = endCol - startCol - 1;
+  const maxRow = getDataSourceState().dataArray.length - 1;
+  const maxCol = getComputed().computedVisibleColumns.length - 1;
+  const minRow = 0;
+  const minCol = 0;
+  rowIndex = clamp(rowIndex, 0, maxRow);
+  colIndex = clamp(colIndex, 0, maxCol);
+  const KeyToFunction = {
+    ArrowDown: () => {
+      rowIndex = clamp(rowIndex + 1, minRow, maxRow);
+    },
+    ArrowUp: () => {
+      rowIndex = clamp(rowIndex - 1, minRow, maxRow);
+    },
+    ArrowLeft: () => {
+      if (colIndex === minCol) {
+        if (rowIndex !== minRow) {
+          colIndex = maxCol;
+        }
+        if (brain.isHorizontalLayoutBrain) {
+          const rowsPerPage = brain.rowsPerPage;
+          if (rowIndex - rowsPerPage >= minRow) {
+            rowIndex = rowIndex - rowsPerPage;
+          } else {
+            KeyToFunction.ArrowUp();
+          }
+        } else {
+          KeyToFunction.ArrowUp();
+        }
+      } else {
+        colIndex = clamp(colIndex - 1, minCol, maxCol);
+      }
+    },
+    ArrowRight: () => {
+      if (colIndex === maxCol) {
+        if (rowIndex !== maxRow) {
+          colIndex = minCol;
+        }
+        if (brain.isHorizontalLayoutBrain) {
+          const rowsPerPage = brain.rowsPerPage;
+          if (rowIndex + rowsPerPage <= maxRow) {
+            rowIndex = rowIndex + rowsPerPage;
+          } else {
+            KeyToFunction.ArrowDown();
+          }
+        } else {
+          KeyToFunction.ArrowDown();
+        }
+      } else {
+        colIndex = clamp(colIndex + 1, minCol, maxCol);
+      }
+    },
+    Enter: () => {
+      const rowInfo = dataArray[rowIndex];
+      if (rowInfo && rowInfo.isGroupRow) {
+        return api.toggleGroupRow(rowInfo.groupKeys);
+      }
+      if (rowInfo && rowInfo.isTreeNode && rowInfo.isParentNode) {
+        return dataSourceApi.treeApi.toggleNode(rowInfo.nodePath);
+      }
+      if (rowInfo && api.rowDetailApi.isRowDetailEnabledForRow(rowInfo.id)) {
+        return api.rowDetailApi.toggleRowDetail(rowInfo.id);
+      }
+      return false;
+    },
+    PageDown: () => {
+      if (!shiftKey) {
+        rowIndex = Math.min(rowIndex + renderRowCount, maxRow);
+      } else {
+        colIndex = Math.min(colIndex + renderColCount, maxCol);
+      }
+    },
+    PageUp: () => {
+      if (!shiftKey) {
+        rowIndex = Math.max(rowIndex - renderRowCount, minRow);
+      } else {
+        colIndex = Math.max(colIndex - renderColCount, minCol);
+      }
+    },
+    End: () => {
+      if (!shiftKey) {
+        rowIndex = maxRow;
+      } else {
+        colIndex = maxCol;
+      }
+    },
+    Home: () => {
+      if (!shiftKey) {
+        rowIndex = minRow;
+      } else {
+        colIndex = minCol;
+      }
+    }
+  };
+  const Fn = KeyToFunction[key];
+  if (!Fn) {
+    return false;
+  }
+  Fn();
+  return [rowIndex, colIndex];
+}
+function handleCellNavigation(options, event) {
+  const result = computeNextActiveCellIndex(
+    options,
+    event
+  );
+  if (result) {
+    options.actions.activeCellIndex = result;
+    return true;
+  }
+  return false;
+}
+var validKeys = {
+  ArrowUp: true,
+  ArrowDown: true,
+  ArrowLeft: true,
+  ArrowRight: true,
+  PageUp: true,
+  PageDown: true,
+  Home: true,
+  End: true,
+  Enter: true,
+  " ": true
+};
+function handleKeyboardNavigation(options, event) {
+  const { key } = event;
+  const { getState } = options;
+  const state = getState();
+  const {
+    activeRowIndex,
+    activeCellIndex,
+    keyboardNavigation,
+    cellContextMenuVisibleFor,
+    contextMenuVisibleFor
+  } = state;
+  if (cellContextMenuVisibleFor || contextMenuVisibleFor) {
+    return false;
+  }
+  if (!validKeys[key]) {
+    return false;
+  }
+  if (activeRowIndex != null && keyboardNavigation === "row") {
+    return handleRowNavigation(options, event);
+  }
+  if (activeCellIndex != null && keyboardNavigation === "cell") {
+    return handleCellNavigation(options, event);
+  }
+  return false;
+}
+
+// src/components/InfiniteTable/api/getKeyboardNavigationApi.ts
+var KeyboardNavigationApi = class {
+  constructor(param) {
+    this.param = param;
+  }
+  setKeyboardNavigation(keyboardNavigation) {
+    this.param.actions.keyboardNavigation = keyboardNavigation;
+  }
+  setActiveCellIndex(activeCellIndex) {
+    this.param.actions.activeCellIndex = activeCellIndex;
+  }
+  setActiveRowIndex(activeRowIndex) {
+    this.param.actions.activeRowIndex = activeRowIndex;
+  }
+  gotoRowWithDirection(direction) {
+    const { getDataSourceState, getState } = this.param;
+    const { activeRowIndex, keyboardNavigation } = getState();
+    if (keyboardNavigation !== "row") {
+      console.error("Keyboard navigation is not enabled for rows");
+      return false;
+    }
+    if (activeRowIndex == null) {
+      return false;
+    }
+    const newActiveRowIndex = getNextEnabledRowIndex(
+      getDataSourceState,
+      activeRowIndex,
+      direction
+    );
+    if (newActiveRowIndex !== activeRowIndex) {
+      this.param.actions.activeRowIndex = newActiveRowIndex;
+      return newActiveRowIndex;
+    }
+    return false;
+  }
+  gotoRow(direction) {
+    return this.gotoRowWithDirection(direction);
+  }
+  gotoNextRow() {
+    return this.gotoRow(1);
+  }
+  gotoPreviousRow() {
+    return this.gotoRow(-1);
+  }
+  gotoCell(config) {
+    const { direction } = config;
+    const key = direction == "top" ? "ArrowUp" : direction == "bottom" ? "ArrowDown" : direction == "left" ? "ArrowLeft" : "ArrowRight";
+    const activeCellIndex = computeNextActiveCellIndex(this.param, {
+      key,
+      shiftKey: false
+    });
+    if (activeCellIndex === false) {
+      return false;
+    }
+    this.param.actions.activeCellIndex = activeCellIndex;
+    return activeCellIndex;
+  }
+};
+function getKeyboardNavigationApi(param) {
+  return new KeyboardNavigationApi(param);
+}
+
 // src/components/InfiniteTable/api/getImperativeApi.ts
 function isSortInfoForColumn(sortInfo, col) {
   if (sortInfo.id) {
@@ -19951,6 +20322,14 @@ var InfiniteTableApiImpl = class {
       dataSourceActions: context.dataSourceActions,
       getDataSourceState: context.getDataSourceState
     });
+    this.keyboardNavigationApi = getKeyboardNavigationApi({
+      getState: context.getState,
+      getDataSourceState: context.getDataSourceState,
+      actions: context.actions,
+      getComputed: context.getComputed,
+      api: this,
+      dataSourceApi: context.dataSourceApi
+    });
     this.rowDetailApi = getRowDetailApi({
       getState: context.getState,
       actions: context.actions,
@@ -23172,7 +23551,7 @@ var useLicense = (licenseKey = "") => {
     }
     let valid2 = isValidLicense(licenseKey, {
       publishedAt: 1624970570587,
-      version: "6.1.1-canary.0"
+      version: "6.1.1"
     });
     if (!licenseKey && !valid2 && isInsidePlayground) {
       return true;
@@ -23280,431 +23659,130 @@ function onCellDoubleClick(context, event) {
   };
   if (onCellDoubleClick2) {
     const result = onCellDoubleClick2(context, event);
-    if (result && typeof result === "object") {
-      dblClickResult = { ...dblClickResult, ...result };
-    }
-  }
-  if (dblClickResult.preventEdit) {
-    return;
-  }
-  const computed = context.getComputed();
-  const column = computed.computedVisibleColumns[context.colIndex];
-  context.api.startEdit({
-    rowIndex: context.rowIndex,
-    columnId: column.id
-  });
-}
-function updateCellSelectionOnCellClick(context, event) {
-  const {
-    getDataSourceState,
-    getState,
-    getComputed,
-    rowIndex,
-    colIndex,
-    dataSourceActions
-  } = context;
-  const dataSourceState = getDataSourceState();
-  const { selectionMode, cellSelection: existingCellSelection } = dataSourceState;
-  if (!existingCellSelection) {
-    return;
-  }
-  if (selectionMode !== "multi-cell") {
-    return;
-  }
-  const { multiCellSelector, computedVisibleColumns } = getComputed();
-  const { brain } = getState();
-  const { rowsPerPage } = brain;
-  const columnsPerSet = computedVisibleColumns.length;
-  const cellSelection = new CellSelectionState(existingCellSelection);
-  multiCellSelector.cellSelectionState = cellSelection;
-  const position2 = {
-    rowIndex,
-    colIndex
-  };
-  if (event.metaKey || event.ctrlKey) {
-    multiCellSelector.singleAddClick(position2);
-  } else if (event.shiftKey) {
-    const horizontalLayout = !!getState().wrapRowsHorizontally;
-    multiCellSelector.multiSelectClick(
-      position2,
-      horizontalLayout ? {
-        horizontalLayout,
-        rowsPerPage,
-        columnsPerSet
-      } : {
-        horizontalLayout
-      }
-    );
-  } else {
-    multiCellSelector.resetClick(position2);
-  }
-  dataSourceActions.cellSelection = cellSelection;
-}
-function updateRowSelectionOnCellClick(context, event) {
-  const {
-    rowIndex,
-    getDataSourceState,
-    getComputed,
-    dataSourceActions,
-    api,
-    cloneRowSelection: cloneRowSelection2
-  } = context;
-  const { multiRowSelector, renderSelectionCheckBox } = getComputed();
-  const dataSourceState = getDataSourceState();
-  const { selectionMode, groupBy, dataArray, isTree } = dataSourceState;
-  if (groupBy.length) {
-    return false;
-  }
-  if (isTree) {
-    return false;
-  }
-  const rowInfo = dataArray[rowIndex];
-  if (rowInfo?.rowDisabled) {
-    return false;
-  }
-  if (selectionMode === "multi-row") {
-    if (renderSelectionCheckBox && !event.key) {
-      return false;
-    }
-    let { rowSelection: rowSelectionState } = dataSourceState;
-    rowSelectionState = cloneRowSelection2(
-      rowSelectionState
-    );
-    multiRowSelector.rowSelectionState = rowSelectionState;
-    if (rowSelectionState && typeof rowSelectionState === "object") {
-      if (event.shiftKey) {
-        multiRowSelector.multiSelectClick(rowIndex);
-      } else if (event.metaKey || event.ctrlKey) {
-        multiRowSelector.singleAddClick(rowIndex);
-      } else {
-        multiRowSelector.resetClick(rowIndex);
-      }
-      dataSourceActions.rowSelection = rowSelectionState;
-      return true;
-    }
-  } else if (selectionMode === "single-row") {
-    const rowInfo2 = dataArray[rowIndex];
-    const id = rowInfo2.id;
-    if (event.metaKey || event.ctrlKey) {
-      api.rowSelectionApi.toggleRowSelection(id);
-    } else {
-      api.rowSelectionApi.selectRow(id);
-    }
-  }
-  return false;
-}
-
-// src/components/InfiniteTable/eventHandlers/onCellMouseDown.ts
-function onCellMouseDown(context, event) {
-  if (event.detail === 2) {
-    return;
-  }
-  updateCellSelectionOnCellMouseDown(context);
-}
-function updateCellSelectionOnCellMouseDown(_context) {
-}
-
-// src/components/utils/clamp.ts
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-
-// src/components/InfiniteTable/eventHandlers/keyboardNavigation.ts
-function getNextEnabledRowIndex(getDataSourceState, activeRowIndex, direction) {
-  const dataArray = getDataSourceState().dataArray;
-  const min = 0;
-  const max = dataArray.length - 1;
-  let i = activeRowIndex;
-  do {
-    i += direction;
-    const rowInfo = dataArray[i];
-    if (!rowInfo) {
-      return i < min ? min : max;
-    }
-    if (!rowInfo.rowDisabled) {
-      return i;
-    }
-  } while (i >= min && i <= max);
-  return clamp(i, min, max);
-}
-function handleRowNavigation(options, event) {
-  const { getState, getDataSourceState, actions, api, dataSourceApi } = options;
-  const { key } = event;
-  const dataArray = getDataSourceState().dataArray;
-  const arrLength = dataArray.length;
-  const state = getState();
-  const { brain } = state;
-  let { activeRowIndex } = state;
-  if (activeRowIndex == null) {
-    return false;
-  }
-  const {
-    start: [startRow],
-    end: [endRow]
-  } = brain.getRenderRange();
-  const initialActiveRowIndex = activeRowIndex;
-  const renderRowCount = endRow - startRow - 1;
-  const min = 0;
-  const max = arrLength - 1;
-  const KeyToFunction = {
-    ArrowDown: () => {
-      activeRowIndex = getNextEnabledRowIndex(
-        getDataSourceState,
-        activeRowIndex,
-        1
-      );
-    },
-    ArrowUp: () => {
-      activeRowIndex = getNextEnabledRowIndex(
-        getDataSourceState,
-        activeRowIndex,
-        -1
-      );
-    },
-    ArrowLeft: () => {
-      const rowInfo = dataArray[activeRowIndex];
-      if (brain.isHorizontalLayoutBrain) {
-        const rowsPerPage = brain.rowsPerPage;
-        if (activeRowIndex - rowsPerPage >= min) {
-          activeRowIndex = activeRowIndex - rowsPerPage;
-        } else {
-          KeyToFunction.ArrowUp();
-        }
-        return;
-      }
-      if (rowInfo && rowInfo.isGroupRow) {
-        return api.collapseGroupRow(rowInfo.groupKeys);
-      }
-      if (rowInfo && api.rowDetailApi.isRowDetailEnabledForRow(rowInfo.id)) {
-        return api.rowDetailApi.collapseRowDetail(rowInfo.id);
-      }
-      return false;
-    },
-    ArrowRight: () => {
-      const rowInfo = dataArray[activeRowIndex];
-      if (brain.isHorizontalLayoutBrain) {
-        const rowsPerPage = brain.rowsPerPage;
-        if (activeRowIndex + rowsPerPage <= max) {
-          activeRowIndex = activeRowIndex + rowsPerPage;
-        } else {
-          KeyToFunction.ArrowDown();
-        }
-        return;
-      }
-      if (rowInfo && rowInfo.isGroupRow) {
-        return api.expandGroupRow(rowInfo.groupKeys);
-      }
-      if (rowInfo && api.rowDetailApi.isRowDetailEnabledForRow(rowInfo.id)) {
-        return api.rowDetailApi.expandRowDetail(rowInfo.id);
-      }
-      return false;
-    },
-    Enter: () => {
-      const rowInfo = dataArray[activeRowIndex];
-      if (rowInfo && rowInfo.isGroupRow) {
-        return api.toggleGroupRow(rowInfo.groupKeys);
-      }
-      if (rowInfo && rowInfo.isTreeNode && rowInfo.isParentNode) {
-        return dataSourceApi.treeApi.toggleNode(rowInfo.nodePath);
-      }
-      const hasRowDetail = api.rowDetailApi.isRowDetailEnabledForRow(
-        rowInfo.id
-      );
-      if (hasRowDetail) {
-        return api.rowDetailApi.toggleRowDetail(rowInfo.id);
-      }
-      return false;
-    },
-    PageDown: () => {
-      activeRowIndex = Math.min(
-        activeRowIndex + renderRowCount,
-        arrLength - 1
-      );
-    },
-    PageUp: () => {
-      activeRowIndex = Math.max(activeRowIndex - renderRowCount, min);
-    },
-    End: () => {
-      activeRowIndex = max;
-    },
-    Home: () => {
-      activeRowIndex = min;
+    if (result && typeof result === "object") {
+      dblClickResult = { ...dblClickResult, ...result };
     }
-  };
-  const Fn = KeyToFunction[key];
-  if (!Fn) {
-    return false;
   }
-  Fn();
-  if (initialActiveRowIndex !== activeRowIndex) {
-    actions.activeRowIndex = activeRowIndex;
-    return true;
+  if (dblClickResult.preventEdit) {
+    return;
   }
-  return false;
+  const computed = context.getComputed();
+  const column = computed.computedVisibleColumns[context.colIndex];
+  context.api.startEdit({
+    rowIndex: context.rowIndex,
+    columnId: column.id
+  });
 }
-function handleCellNavigation(options, event) {
+function updateCellSelectionOnCellClick(context, event) {
   const {
-    api,
+    getDataSourceState,
     getState,
     getComputed,
-    getDataSourceState,
-    dataSourceApi,
-    actions
-  } = options;
-  const { key, shiftKey } = event;
-  const dataArray = getDataSourceState().dataArray;
-  const state = getState();
-  const { activeCellIndex, brain } = state;
-  if (!activeCellIndex) {
-    return false;
+    rowIndex,
+    colIndex,
+    dataSourceActions
+  } = context;
+  const dataSourceState = getDataSourceState();
+  const { selectionMode, cellSelection: existingCellSelection } = dataSourceState;
+  if (!existingCellSelection) {
+    return;
   }
-  let [rowIndex, colIndex] = activeCellIndex;
-  const {
-    start: [startRow, startCol],
-    end: [endRow, endCol]
-  } = brain.getRenderRange();
-  const renderRowCount = endRow - startRow - 1;
-  const renderColCount = endCol - startCol - 1;
-  const maxRow = getDataSourceState().dataArray.length - 1;
-  const maxCol = getComputed().computedVisibleColumns.length - 1;
-  const minRow = 0;
-  const minCol = 0;
-  rowIndex = clamp(rowIndex, 0, maxRow);
-  colIndex = clamp(colIndex, 0, maxCol);
-  actions.activeCellIndex = [rowIndex, colIndex];
-  const KeyToFunction = {
-    ArrowDown: () => {
-      rowIndex = clamp(rowIndex + 1, minRow, maxRow);
-    },
-    ArrowUp: () => {
-      rowIndex = clamp(rowIndex - 1, minRow, maxRow);
-    },
-    ArrowLeft: () => {
-      if (colIndex === minCol) {
-        if (rowIndex !== minRow) {
-          colIndex = maxCol;
-        }
-        if (brain.isHorizontalLayoutBrain) {
-          const rowsPerPage = brain.rowsPerPage;
-          if (rowIndex - rowsPerPage >= minRow) {
-            rowIndex = rowIndex - rowsPerPage;
-          } else {
-            KeyToFunction.ArrowUp();
-          }
-        } else {
-          KeyToFunction.ArrowUp();
-        }
-      } else {
-        colIndex = clamp(colIndex - 1, minCol, maxCol);
-      }
-    },
-    ArrowRight: () => {
-      if (colIndex === maxCol) {
-        if (rowIndex !== maxRow) {
-          colIndex = minCol;
-        }
-        if (brain.isHorizontalLayoutBrain) {
-          const rowsPerPage = brain.rowsPerPage;
-          if (rowIndex + rowsPerPage <= maxRow) {
-            rowIndex = rowIndex + rowsPerPage;
-          } else {
-            KeyToFunction.ArrowDown();
-          }
-        } else {
-          KeyToFunction.ArrowDown();
-        }
-      } else {
-        colIndex = clamp(colIndex + 1, minCol, maxCol);
-      }
-    },
-    Enter: () => {
-      const rowInfo = dataArray[rowIndex];
-      if (rowInfo && rowInfo.isGroupRow) {
-        return api.toggleGroupRow(rowInfo.groupKeys);
-      }
-      if (rowInfo && rowInfo.isTreeNode && rowInfo.isParentNode) {
-        return dataSourceApi.treeApi.toggleNode(rowInfo.nodePath);
-      }
-      if (rowInfo && api.rowDetailApi.isRowDetailEnabledForRow(rowInfo.id)) {
-        return api.rowDetailApi.toggleRowDetail(rowInfo.id);
-      }
-      return false;
-    },
-    PageDown: () => {
-      if (!shiftKey) {
-        rowIndex = Math.min(rowIndex + renderRowCount, maxRow);
-      } else {
-        colIndex = Math.min(colIndex + renderColCount, maxCol);
-      }
-    },
-    PageUp: () => {
-      if (!shiftKey) {
-        rowIndex = Math.max(rowIndex - renderRowCount, minRow);
-      } else {
-        colIndex = Math.max(colIndex - renderColCount, minCol);
-      }
-    },
-    End: () => {
-      if (!shiftKey) {
-        rowIndex = maxRow;
-      } else {
-        colIndex = maxCol;
-      }
-    },
-    Home: () => {
-      if (!shiftKey) {
-        rowIndex = minRow;
-      } else {
-        colIndex = minCol;
-      }
-    }
+  if (selectionMode !== "multi-cell") {
+    return;
+  }
+  const { multiCellSelector, computedVisibleColumns } = getComputed();
+  const { brain } = getState();
+  const { rowsPerPage } = brain;
+  const columnsPerSet = computedVisibleColumns.length;
+  const cellSelection = new CellSelectionState(existingCellSelection);
+  multiCellSelector.cellSelectionState = cellSelection;
+  const position2 = {
+    rowIndex,
+    colIndex
   };
-  const Fn = KeyToFunction[key];
-  if (!Fn) {
-    return false;
+  if (event.metaKey || event.ctrlKey) {
+    multiCellSelector.singleAddClick(position2);
+  } else if (event.shiftKey) {
+    const horizontalLayout = !!getState().wrapRowsHorizontally;
+    multiCellSelector.multiSelectClick(
+      position2,
+      horizontalLayout ? {
+        horizontalLayout,
+        rowsPerPage,
+        columnsPerSet
+      } : {
+        horizontalLayout
+      }
+    );
+  } else {
+    multiCellSelector.resetClick(position2);
   }
-  Fn();
-  actions.activeCellIndex = [rowIndex, colIndex];
-  return true;
+  dataSourceActions.cellSelection = cellSelection;
 }
-var validKeys = {
-  ArrowUp: true,
-  ArrowDown: true,
-  ArrowLeft: true,
-  ArrowRight: true,
-  PageUp: true,
-  PageDown: true,
-  Home: true,
-  End: true,
-  Enter: true,
-  " ": true
-};
-function handleKeyboardNavigation(options, event) {
-  const { key } = event;
-  const { getState } = options;
-  const state = getState();
+function updateRowSelectionOnCellClick(context, event) {
   const {
-    activeRowIndex,
-    activeCellIndex,
-    keyboardNavigation,
-    cellContextMenuVisibleFor,
-    contextMenuVisibleFor
-  } = state;
-  if (cellContextMenuVisibleFor || contextMenuVisibleFor) {
+    rowIndex,
+    getDataSourceState,
+    getComputed,
+    dataSourceActions,
+    api,
+    cloneRowSelection: cloneRowSelection2
+  } = context;
+  const { multiRowSelector, renderSelectionCheckBox } = getComputed();
+  const dataSourceState = getDataSourceState();
+  const { selectionMode, groupBy, dataArray, isTree } = dataSourceState;
+  if (groupBy.length) {
     return false;
   }
-  if (!validKeys[key]) {
+  if (isTree) {
     return false;
   }
-  if (activeRowIndex != null && keyboardNavigation === "row") {
-    return handleRowNavigation(options, event);
+  const rowInfo = dataArray[rowIndex];
+  if (rowInfo?.rowDisabled) {
+    return false;
   }
-  if (activeCellIndex != null && keyboardNavigation === "cell") {
-    return handleCellNavigation(options, event);
+  if (selectionMode === "multi-row") {
+    if (renderSelectionCheckBox && !event.key) {
+      return false;
+    }
+    let { rowSelection: rowSelectionState } = dataSourceState;
+    rowSelectionState = cloneRowSelection2(
+      rowSelectionState
+    );
+    multiRowSelector.rowSelectionState = rowSelectionState;
+    if (rowSelectionState && typeof rowSelectionState === "object") {
+      if (event.shiftKey) {
+        multiRowSelector.multiSelectClick(rowIndex);
+      } else if (event.metaKey || event.ctrlKey) {
+        multiRowSelector.singleAddClick(rowIndex);
+      } else {
+        multiRowSelector.resetClick(rowIndex);
+      }
+      dataSourceActions.rowSelection = rowSelectionState;
+      return true;
+    }
+  } else if (selectionMode === "single-row") {
+    const rowInfo2 = dataArray[rowIndex];
+    const id = rowInfo2.id;
+    if (event.metaKey || event.ctrlKey) {
+      api.rowSelectionApi.toggleRowSelection(id);
+    } else {
+      api.rowSelectionApi.selectRow(id);
+    }
   }
   return false;
 }
 
+// src/components/InfiniteTable/eventHandlers/onCellMouseDown.ts
+function onCellMouseDown(context, event) {
+  if (event.detail === 2) {
+    return;
+  }
+  updateCellSelectionOnCellMouseDown(context);
+}
+function updateCellSelectionOnCellMouseDown(_context) {
+}
+
 // src/components/InfiniteTable/eventHandlers/keyboardSelection.ts
 var validKeys2 = {
   Enter: true,