handsontable 13.1.0 → 14.0.0-next-d97b156-20231027

package/core/focusCatcher/index.mjs

@@ -0,0 +1,144 @@
+import { GRID_GROUP } from "../../shortcutContexts/index.mjs";
+import { installFocusDetector } from "./focusDetector.mjs";
+/**
+ * Installs a focus catcher module. The module observes when the table is focused and depending on
+ * from the which side it was focused on it selects a specified cell or releases the TAB navigation
+ * to the browser.
+ *
+ * @param {Core} hot The Handsontable instance.
+ */
+export function installFocusCatcher(hot) {
+  let recentlyAddedFocusCoords;
+  const {
+    activate,
+    deactivate
+  } = installFocusDetector(hot, {
+    onFocusFromTop() {
+      var _recentlyAddedFocusCo;
+      const mostTopStartCoords = (_recentlyAddedFocusCo = recentlyAddedFocusCoords) !== null && _recentlyAddedFocusCo !== void 0 ? _recentlyAddedFocusCo : getMostTopStartPosition(hot);
+      if (mostTopStartCoords) {
+        hot.runHooks('modifyFocusOnTabNavigation', 'from_above', mostTopStartCoords);
+        hot.selectCell(mostTopStartCoords.row, mostTopStartCoords.col);
+      }
+      hot.listen();
+    },
+    onFocusFromBottom() {
+      var _recentlyAddedFocusCo2;
+      const mostBottomEndCoords = (_recentlyAddedFocusCo2 = recentlyAddedFocusCoords) !== null && _recentlyAddedFocusCo2 !== void 0 ? _recentlyAddedFocusCo2 : getMostBottomEndPosition(hot);
+      if (mostBottomEndCoords) {
+        hot.runHooks('modifyFocusOnTabNavigation', 'from_below', mostBottomEndCoords);
+        hot.selectCell(mostBottomEndCoords.row, mostBottomEndCoords.col);
+      }
+      hot.listen();
+    }
+  });
+  const rowWrapState = {
+    wrapped: false,
+    flipped: false
+  };
+  hot.addHook('afterListen', () => deactivate());
+  hot.addHook('afterUnlisten', () => activate());
+  hot.addHook('afterSelection', () => {
+    var _hot$getSelectedRange;
+    recentlyAddedFocusCoords = (_hot$getSelectedRange = hot.getSelectedRangeLast()) === null || _hot$getSelectedRange === void 0 ? void 0 : _hot$getSelectedRange.highlight;
+  });
+  hot.addHook('beforeRowWrap', (isWrapEnabled, newCoords, isFlipped) => {
+    rowWrapState.wrapped = true;
+    rowWrapState.flipped = isFlipped;
+  });
+
+  /**
+   * Unselects the cell and deactivates the table.
+   */
+  function deactivateTable() {
+    rowWrapState.wrapped = false;
+    rowWrapState.flipped = false;
+    hot.deselectCell();
+    hot.unlisten();
+  }
+  hot.getShortcutManager().getContext('grid').addShortcut({
+    keys: [['Tab'], ['Shift', 'Tab']],
+    callback: event => {
+      const {
+        disableTabNavigation,
+        autoWrapRow
+      } = hot.getSettings();
+      if (disableTabNavigation || !hot.selection.isSelected() || autoWrapRow && rowWrapState.wrapped && rowWrapState.flipped || !autoWrapRow && rowWrapState.wrapped) {
+        if (autoWrapRow && rowWrapState.wrapped && rowWrapState.flipped) {
+          recentlyAddedFocusCoords = event.shiftKey ? getMostTopStartPosition(hot) : getMostBottomEndPosition(hot);
+        }
+        deactivateTable();
+        return false;
+      }
+
+      // if the selection is still within the table's range then prevent default action
+      event.preventDefault();
+    },
+    runOnlyIf: () => !hot.getSettings().minSpareCols,
+    preventDefault: false,
+    stopPropagation: false,
+    position: 'after',
+    relativeToGroup: GRID_GROUP,
+    group: 'focusCatcher'
+  });
+}
+
+/**
+ * Gets the coordinates of the most top-start cell or header (depends on the table settings and its size).
+ *
+ * @param {Core} hot The Handsontable instance.
+ * @returns {CellCoords|null}
+ */
+function getMostTopStartPosition(hot) {
+  const {
+    rowIndexMapper,
+    columnIndexMapper
+  } = hot;
+  const {
+    navigableHeaders
+  } = hot.getSettings();
+  let topRow = navigableHeaders && hot.countColHeaders() > 0 ? -hot.countColHeaders() : 0;
+  let startColumn = navigableHeaders && hot.countRowHeaders() > 0 ? -hot.countRowHeaders() : 0;
+  if (topRow === 0) {
+    topRow = rowIndexMapper.getVisualFromRenderableIndex(topRow);
+  }
+  if (startColumn === 0) {
+    startColumn = columnIndexMapper.getVisualFromRenderableIndex(startColumn);
+  }
+  if (topRow === null || startColumn === null) {
+    return null;
+  }
+  return hot._createCellCoords(topRow, startColumn);
+}
+
+/**
+ * Gets the coordinates of the most bottom-end cell or header (depends on the table settings and its size).
+ *
+ * @param {Core} hot The Handsontable instance.
+ * @returns {CellCoords|null}
+ */
+function getMostBottomEndPosition(hot) {
+  var _rowIndexMapper$getVi, _columnIndexMapper$ge;
+  const {
+    rowIndexMapper,
+    columnIndexMapper
+  } = hot;
+  const {
+    navigableHeaders
+  } = hot.getSettings();
+  let bottomRow = rowIndexMapper.getRenderableIndexesLength() - 1;
+  let endColumn = columnIndexMapper.getRenderableIndexesLength() - 1;
+  if (bottomRow < 0) {
+    if (!navigableHeaders || hot.countColHeaders() === 0) {
+      return null;
+    }
+    bottomRow = -1;
+  }
+  if (endColumn < 0) {
+    if (!navigableHeaders || hot.countColHeaders() === 0) {
+      return null;
+    }
+    endColumn = -1;
+  }
+  return hot._createCellCoords((_rowIndexMapper$getVi = rowIndexMapper.getVisualFromRenderableIndex(bottomRow)) !== null && _rowIndexMapper$getVi !== void 0 ? _rowIndexMapper$getVi : bottomRow, (_columnIndexMapper$ge = columnIndexMapper.getVisualFromRenderableIndex(endColumn)) !== null && _columnIndexMapper$ge !== void 0 ? _columnIndexMapper$ge : endColumn);
+}

package/core/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+exports.__esModule = true;
+var _focusCatcher = require("./focusCatcher");
+Object.keys(_focusCatcher).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _focusCatcher[key]) return;
+  exports[key] = _focusCatcher[key];
+});

package/core/index.mjs

@@ -0,0 +1 @@
+export * from "./focusCatcher/index.mjs";

package/core.d.ts

@@ -17,6 +17,7 @@ import { BaseValidator } from './validators/base';
 import { Plugins } from './plugins';
 import { CellType } from './cellTypes';
 import { ShortcutManager } from './shortcuts';
+import { FocusManager } from './focusManager';
 
 type AlterActions = 'insert_row_above' | 'insert_row_below' |
                     'insert_col_start' | 'insert_col_end' |
@@ -45,6 +46,8 @@ export default class Core {
   countSourceRows(): number;
   countVisibleCols(): number;
   countVisibleRows(): number;
+  countRowHeaders(): number;
+  countColHeaders(): number;
   deselectCell(): void;
   destroy(): void;
   destroyEditor(revertOriginal?: boolean, prepareEditorIfNeeded?: boolean): void;
@@ -75,6 +78,7 @@ export default class Core {
   getDataAtRowProp(row: number, prop: string): CellValue;
   getDataType(rowFrom: number, columnFrom: number, rowTo: number, columnTo: number): CellType | 'mixed';
   getDirectionFactor(): 1 | -1;
+  getFocusManager(): FocusManager;
   getInstance(): Core;
   getPlugin<T extends keyof Plugins>(pluginName: T): Plugins[T];
   getPlugin(pluginName: string): Plugins['basePlugin'];
@@ -114,7 +118,7 @@ export default class Core {
   loadData(data: CellValue[][] | RowObject[], source?: string): void;
   populateFromArray(row: number, col: number, input: CellValue[][], endRow?: number,
     endCol?: number, source?: string, method?: 'shift_down' | 'shift_right' | 'overwrite'): void;
-  propToCol(prop: string | number): number;
+  propToCol(prop: string | number): string | number;
   redo(): void;
   refreshDimensions(): void;
   removeCellMeta(row: number, col: number, key: (keyof CellMeta) | string): void;
@@ -128,13 +132,14 @@ export default class Core {
   rootWindow: Window;
   rowIndexMapper: IndexMapper;
   runHooks(key: keyof Events, p1?: any, p2?: any, p3?: any, p4?: any, p5?: any, p6?: any): any;
-  scrollViewportTo(row?: number, column?: number, snapToBottom?: boolean, snapToRight?: boolean, considerHiddenIndexes?: boolean): boolean;
-  selectAll(): void;
+  scrollViewportTo(options: { row?: number, col?: number, verticalSnap?: 'top' | 'bottom', horizontalSnap?: 'start' | 'end', considerHiddenIndexes?: boolean }): boolean;
+  scrollToFocusedCell(callback?: () => void): void;
+  selectAll(includeRowHeaders?: boolean, includeColumnHeaders?: boolean, options?: { focusPosition?: { row: number, col: number }, disableHeadersHighlight?: boolean }): void;
   selectCell(row: number, col: number, endRow?: number, endCol?: number, scrollToCell?: boolean, changeListener?: boolean): boolean;
   selectCellByProp(row: number, prop: string, endRow?: number, endProp?: string, scrollToCell?: boolean): boolean;
   selectCells(coords: Array<[number, number | string, number, number | string]> | CellRange[], scrollToCell?: boolean, changeListener?: boolean): boolean;
-  selectColumns(startColumn: number | string, endColumn?: number | string): boolean;
-  selectRows(startRow: number, endRow?: number): boolean;
+  selectColumns(startColumn: number | string, endColumn?: number | string, focusPosition?: number): boolean;
+  selectRows(startRow: number, endRow?: number, focusPosition?: number): boolean;
   setCellMeta(row: number, col: number, key: string, val: any): void;
   setCellMeta<K extends keyof CellMeta>(row: number, col: number, key: K, val: CellMeta[K]): void;
   setCellMetaObject(row: number, col: number, prop: CellMeta): void;