@atlaskit/editor-plugin-table 5.5.3 → 5.5.5

package/dist/esm/plugins/table/commands/misc.js

@@ -1,3 +1,4 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
@@ -5,7 +6,7 @@ import { closestElement, isParagraph, isTextSelection, mapSlice } from '@atlaski
 import { TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
 import { TableMap } from '@atlaskit/editor-tables/table-map';
-import { findCellClosestToPos, findTable, getCellsInColumn, getCellsInRow, getSelectionRect, isSelectionType, isTableSelected, removeTable, selectColumn as selectColumnTransform, selectionCell, selectRow as selectRowTransform, setCellAttrs } from '@atlaskit/editor-tables/utils';
+import { findCellClosestToPos, findTable, getCellsInColumn, getCellsInRow, getSelectionRect, isSelectionType, isTableSelected, removeTable, selectColumns as selectColumnsTransform, selectColumn as selectColumnTransform, selectionCell, selectRows as selectRowsTransform, selectRow as selectRowTransform, setCellAttrs } from '@atlaskit/editor-tables/utils';
 import { getDecorations } from '../pm-plugins/decorations/plugin';
 import { buildColumnResizingDecorations, clearColumnResizingDecorations } from '../pm-plugins/decorations/utils';
 import { createCommand, getPluginState } from '../pm-plugins/plugin-factory';
@@ -339,6 +340,37 @@ export var selectColumn = function selectColumn(column, expand) {
     return selectColumnTransform(column, expand)(tr).setMeta('addToHistory', false);
   });
 };
+export var selectColumns = function selectColumns(columnIndexes) {
+  return createCommand(function (state) {
+    if (!columnIndexes) {
+      return false;
+    }
+    var cells = columnIndexes.map(function (column) {
+      return getCellsInColumn(column)(state.tr.selection);
+    }).flat();
+    if (!cells || !cells.length || cells.some(function (cell) {
+      return cell && typeof cell.pos !== 'number';
+    })) {
+      return false;
+    }
+    var decorations = createColumnSelectedDecoration(selectColumnsTransform(columnIndexes)(state.tr));
+    var decorationSet = updatePluginStateDecorations(state, decorations, TableDecorations.COLUMN_SELECTED);
+    var cellsInFirstColumn = getCellsInColumn(Math.min.apply(Math, _toConsumableArray(columnIndexes)))(state.tr.selection);
+    if (!cellsInFirstColumn || cellsInFirstColumn.length === 0) {
+      return false;
+    }
+    var targetCellPosition = cellsInFirstColumn[0].pos;
+    return {
+      type: 'SELECT_COLUMN',
+      data: {
+        targetCellPosition: targetCellPosition,
+        decorationSet: decorationSet
+      }
+    };
+  }, function (tr) {
+    return selectColumnsTransform(columnIndexes)(tr).setMeta('addToHistory', false);
+  });
+};
 export var selectRow = function selectRow(row, expand) {
   return createCommand(function (state) {
     var targetCellPosition;
@@ -356,6 +388,34 @@ export var selectRow = function selectRow(row, expand) {
     return selectRowTransform(row, expand)(tr).setMeta('addToHistory', false);
   });
 };
+export var selectRows = function selectRows(rowIndexes) {
+  return createCommand(function (state) {
+    if (rowIndexes.length === 0) {
+      return false;
+    }
+    var cells = rowIndexes.map(function (row) {
+      return getCellsInRow(row)(state.tr.selection);
+    }).flat();
+    if (!cells || !cells.length || cells.some(function (cell) {
+      return cell && typeof cell.pos !== 'number';
+    })) {
+      return false;
+    }
+    var cellsInFirstRow = getCellsInRow(Math.min.apply(Math, _toConsumableArray(rowIndexes)))(state.tr.selection);
+    if (!cellsInFirstRow || cellsInFirstRow.length === 0) {
+      return false;
+    }
+    var targetCellPosition = cellsInFirstRow[0].pos;
+    return {
+      type: 'SET_TARGET_CELL_POSITION',
+      data: {
+        targetCellPosition: targetCellPosition
+      }
+    };
+  }, function (tr) {
+    return selectRowsTransform(rowIndexes)(tr).setMeta('addToHistory', false);
+  });
+};
 export var showInsertColumnButton = function showInsertColumnButton(columnIndex) {
   return createCommand(function (_) {
     return columnIndex > -1 ? {

package/dist/esm/plugins/table/pm-plugins/drag-and-drop/plugin.js

@@ -7,8 +7,7 @@ import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
 import { getCellsInRow } from '@atlaskit/editor-tables/utils';
 import { monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/adapter/element';
-import { findNearestCellIndexToPoint } from '../../utils';
-import { hasMergedCellsInColumn, hasMergedCellsInRow } from '../../utils/merged-cells';
+import { findNearestCellIndexToPoint, hasMergedCellsInBetween } from '../../utils';
 import { getPluginState as getTablePluginState } from '../plugin-factory';
 import { pluginKey as tablePluginKey } from '../plugin-key';
 import { DragAndDropActionType } from './actions';
@@ -175,8 +174,7 @@ export var createPlugin = function createPlugin(dispatch, eventDispatcher) {
             }
 
             // If the drop target index contains merged cells then we should not allow the drop to occur.
-            var hasMergedCells = sourceType === 'table-row' ? hasMergedCellsInRow : hasMergedCellsInColumn;
-            if (hasMergedCells(targetAdjustedIndex)(editorView.state.selection)) {
+            if (hasMergedCellsInBetween([targetAdjustedIndex - 1, targetAdjustedIndex], sourceType === 'table-row' ? DropTargetType.ROW : DropTargetType.COLUMN)(editorView.state.selection)) {
               clearDropTarget(tr)(editorView.state, editorView.dispatch);
               return;
             }
@@ -184,6 +182,7 @@ export var createPlugin = function createPlugin(dispatch, eventDispatcher) {
               sourceIndex = _sourceIndexes[0];
             requestAnimationFrame(function () {
               moveSource(sourceType, sourceIndex, targetAdjustedIndex + (direction === -1 ? 0 : -1), tr)(editorView.state, editorView.dispatch);
+              editorView.focus();
             });
           }
         })

package/dist/esm/plugins/table/ui/FloatingInsertButton/index.js

@@ -95,9 +95,6 @@ export var FloatingInsertButton = /*#__PURE__*/function (_React$Component) {
               position: pos,
               docSize: editorView.state.doc.nodeSize,
               error: error === null || error === void 0 ? void 0 : error.toString()
-            },
-            nonPrivacySafeAttributes: {
-              errorStack: error.stack || undefined
             }
           };
           dispatchAnalyticsEvent(payload);

package/dist/esm/plugins/table/ui/TableFloatingColumnControls/ColumnControls/index.js

@@ -4,7 +4,7 @@ import React, { useCallback, useMemo } from 'react';
 import { tableCellMinWidth } from '@atlaskit/editor-common/styles';
 import { CellSelection } from '@atlaskit/editor-tables';
 import { getSelectionRect } from '@atlaskit/editor-tables/utils';
-import { clearHoverSelection, hoverCell, hoverColumns, selectColumn } from '../../../commands';
+import { clearHoverSelection, hoverCell, hoverColumns, selectColumn, selectColumns } from '../../../commands';
 import { toggleDragMenu } from '../../../pm-plugins/drag-and-drop/commands';
 import { TableCssClassName as ClassName } from '../../../types';
 import { getRowsParams, getSelectedColumnIndexes } from '../../../utils';
@@ -47,8 +47,14 @@ export var ColumnControls = function ColumnControls(_ref) {
   var handleClick = useCallback(function (event) {
     var state = editorView.state,
       dispatch = editorView.dispatch;
-    selectColumn(colIndex, event.shiftKey)(state, dispatch);
-  }, [colIndex, editorView]);
+    var isClickOutsideSelectedCols = selectedColIndexes.length >= 1 && !selectedColIndexes.includes(colIndex);
+    if (!selectedColIndexes || selectedColIndexes.length === 0 || isClickOutsideSelectedCols) {
+      selectColumn(colIndex, event.shiftKey)(state, dispatch);
+    }
+    if (selectedColIndexes.length > 1 && selectedColIndexes.includes(colIndex) && !event.shiftKey) {
+      selectColumns(selectedColIndexes)(state, dispatch);
+    }
+  }, [colIndex, selectedColIndexes, editorView]);
   var handleMouseOver = useCallback(function () {
     var state = editorView.state,
       dispatch = editorView.dispatch;

package/dist/esm/plugins/table/ui/TableFloatingControls/RowControls/DragControls.js

@@ -38,6 +38,7 @@ var DragControlsComponent = function DragControlsComponent(_ref) {
     canDrag = _ref.canDrag,
     hoverRows = _ref.hoverRows,
     selectRow = _ref.selectRow,
+    selectRows = _ref.selectRows,
     updateCellHoverLocation = _ref.updateCellHoverLocation;
   var _useState = useState(false),
     _useState2 = _slicedToArray(_useState, 2),
@@ -103,8 +104,14 @@ var DragControlsComponent = function DragControlsComponent(_ref) {
     hoverRows([rowIndex]);
   }, [hoverRows, rowIndex]);
   var handleClick = useCallback(function (e) {
-    selectRow(rowIndex, e === null || e === void 0 ? void 0 : e.shiftKey);
-  }, [rowIndex, selectRow]);
+    var isClickOutsideSelectedRows = selectedRowIndexes.length >= 1 && !selectedRowIndexes.includes(rowIndex);
+    if (!selectedRowIndexes || selectedRowIndexes.length === 0 || isClickOutsideSelectedRows) {
+      selectRow(rowIndex, e.shiftKey);
+    }
+    if (selectedRowIndexes.length > 1 && selectedRowIndexes.includes(rowIndex) && !e.shiftKey) {
+      selectRows(selectedRowIndexes);
+    }
+  }, [rowIndex, selectRow, selectRows, selectedRowIndexes]);
   var generateHandleByType = function generateHandleByType(type) {
     if (!hoveredCell) {
       return null;

package/dist/esm/plugins/table/ui/TableFloatingControls/index.js

@@ -12,7 +12,7 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 import React, { Component } from 'react';
 import { browser } from '@atlaskit/editor-common/utils';
-import { hoverCell, hoverRows, selectRow } from '../../commands';
+import { hoverCell, hoverRows, selectRow, selectRows } from '../../commands';
 import { TableCssClassName as ClassName } from '../../types';
 import { isSelectionUpdated } from '../../utils';
 import { CornerControls, DragCornerControls } from './CornerControls';
@@ -35,6 +35,16 @@ var TableFloatingControls = /*#__PURE__*/function (_Component) {
       }
       selectRow(row, expand)(state, dispatch);
     });
+    _defineProperty(_assertThisInitialized(_this), "selectRows", function (rowIndexes) {
+      var editorView = _this.props.editorView;
+      var state = editorView.state,
+        dispatch = editorView.dispatch;
+      // fix for issue ED-4665
+      if (browser.ie_version === 11) {
+        editorView.dom.blur();
+      }
+      selectRows(rowIndexes)(state, dispatch);
+    });
     _defineProperty(_assertThisInitialized(_this), "hoverRows", function (rows, danger) {
       var _this$props$editorVie = _this.props.editorView,
         state = _this$props$editorVie.state,
@@ -198,6 +208,7 @@ var TableFloatingControls = /*#__PURE__*/function (_Component) {
         tableWidth: this.state.tableWrapperWidth,
         hoverRows: this.hoverRows,
         selectRow: this.selectRow,
+        selectRows: this.selectRows,
         updateCellHoverLocation: this.updateCellHoverLocation,
         canDrag: canDrag
       })) : /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(CornerControls, {

package/dist/esm/plugins/table/utils/index.js

@@ -8,4 +8,4 @@ export { getRowHeights, isRowDeleteButtonVisible, getRowDeleteButtonParams, getR
 export { getSelectedTableInfo, getSelectedCellInfo } from './analytics';
 export { getMergedCellsPositions } from './table';
 export { updatePluginStateDecorations } from './update-plugin-state-decorations';
-export { hasMergedCellsInColumn, hasMergedCellsInRow } from './merged-cells';
+export { hasMergedCellsInColumn, hasMergedCellsInRow, hasMergedCellsInBetween } from './merged-cells';

package/dist/esm/plugins/table/utils/merged-cells.js

@@ -1,3 +1,4 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { findTable, TableMap } from '@atlaskit/editor-tables';
 var hasMergedCells = function hasMergedCells(indexes, normalizeRect) {
   return function (selection) {
@@ -57,4 +58,76 @@ export var hasMergedCellsInRow = function hasMergedCellsInRow(rowIndexes) {
       bottom: y === index ? y + 1 : y
     };
   });
+};
+var getRect = function getRect(index, type, map) {
+  if (type === 'column') {
+    var x = Math.max(Math.min(index, map.width - 1), 0); // clamped index
+    return {
+      left: x,
+      right: x === index ? x + 1 : x,
+      top: 0,
+      bottom: map.height
+    };
+  } else {
+    var y = Math.max(Math.min(index, map.height - 1), 0); // clamped index
+    return {
+      left: 0,
+      right: map.width,
+      top: y,
+      bottom: y === index ? y + 1 : y
+    };
+  }
+};
+export var hasMergedCellsInBetween = function hasMergedCellsInBetween(indexes, type) {
+  return function (selection) {
+    var table = findTable(selection);
+    if (!table) {
+      return false;
+    }
+    var map = TableMap.get(table.node);
+    var cellPositions = new Set();
+    var mergedCells = new Set();
+    map.map.forEach(function (value) {
+      if (cellPositions.has(value)) {
+        mergedCells.add(value);
+      } else {
+        cellPositions.add(value);
+      }
+    });
+    if (!mergedCells.size) {
+      return false;
+    }
+    var getMergedCellsInRect = function getMergedCellsInRect(index, type) {
+      var rect = getRect(index, type, map);
+      var isValidRectangle = rect.left < rect.right && rect.top < rect.bottom;
+      if (!isValidRectangle) {
+        return [];
+      }
+      var cells = map.cellsInRect(rect);
+      var allCellsInRect = [];
+      if (type === 'column') {
+        allCellsInRect = map.map.filter(function (_, key) {
+          return key % map.width === index;
+        });
+      } else {
+        allCellsInRect = map.map.filter(function (_, key) {
+          return Math.floor(key / map.width) === index;
+        });
+      }
+      var mergedCell = allCellsInRect.filter(function (nodePos) {
+        return !cells.includes(nodePos) // cell exists in Rect but not show in the map.cellsInRect list => merged cell
+        ? true : mergedCells.has(nodePos); // cell includes in mergedCells => merged cell
+      });
+
+      return _toConsumableArray(new Set(mergedCell));
+    };
+    var mergedCellsInRectArr = indexes.map(function (index) {
+      return getMergedCellsInRect(index, type);
+    });
+
+    // Currently only support 2 indexes, but we can extend this to support more indexes in the future.
+    return mergedCellsInRectArr[0].some(function (cell) {
+      return mergedCellsInRectArr[1].includes(cell);
+    });
+  };
 };

package/dist/types/plugins/table/commands/index.d.ts

@@ -2,7 +2,7 @@ export { hoverColumns, hoverRows, hoverTable, hoverCell, hoverMergedCells, clear
 export { insertColumn, insertRow, createTable } from './insert';
 export { getNextLayout, toggleContextualMenu, toggleHeaderColumn, toggleHeaderRow, toggleNumberColumn, toggleTableLayout, } from './toggle';
 export { clearMultipleCells } from './clear';
-export { autoSizeTable, convertFirstRowToHeader, deleteTable, hideInsertColumnOrRowButton, moveCursorBackward, selectColumn, selectRow, setCellAttr, setEditorFocus, setMultipleCellAttrs, setTableRef, showInsertColumnButton, showInsertRowButton, transformSliceToAddTableHeaders, triggerUnlessTableHeader, addBoldInEmptyHeaderCells, addResizeHandleDecorations, } from './misc';
+export { autoSizeTable, convertFirstRowToHeader, deleteTable, hideInsertColumnOrRowButton, moveCursorBackward, selectColumn, selectColumns, selectRow, selectRows, setCellAttr, setEditorFocus, setMultipleCellAttrs, setTableRef, showInsertColumnButton, showInsertRowButton, transformSliceToAddTableHeaders, triggerUnlessTableHeader, addBoldInEmptyHeaderCells, addResizeHandleDecorations, } from './misc';
 export { sortByColumn } from './sort';
 export { goToNextCell } from './go-to-next-cell';
 export { removeDescendantNodes } from './referentiality';

package/dist/types/plugins/table/commands/misc.d.ts

@@ -20,7 +20,9 @@ export declare const convertFirstRowToHeader: (schema: Schema) => (tr: Transacti
 export declare const moveCursorBackward: Command;
 export declare const setMultipleCellAttrs: (attrs: Object, targetCellPosition?: number) => Command;
 export declare const selectColumn: (column: number, expand?: boolean) => Command;
+export declare const selectColumns: (columnIndexes: number[]) => Command;
 export declare const selectRow: (row: number, expand?: boolean) => Command;
+export declare const selectRows: (rowIndexes: number[]) => Command;
 export declare const showInsertColumnButton: (columnIndex: number) => Command;
 export declare const showInsertRowButton: (rowIndex: number) => Command;
 export declare const hideInsertColumnOrRowButton: () => Command;

package/dist/types/plugins/table/ui/TableFloatingControls/RowControls/DragControls.d.ts

@@ -16,6 +16,7 @@ type DragControlsProps = {
     canDrag?: boolean;
     hoverRows: (rows: number[], danger?: boolean) => void;
     selectRow: (row: number, expand: boolean) => void;
+    selectRows: (rowIndexes: number[]) => void;
     updateCellHoverLocation: (rowIndex: number) => void;
 };
 export declare const DragControls: React.FC<import("react-intl-next").WithIntlProps<DragControlsProps & WrappedComponentProps<"intl">>> & {

package/dist/types/plugins/table/ui/TableFloatingControls/index.d.ts

@@ -42,6 +42,7 @@ export default class TableFloatingControls extends Component<Props, State> {
     componentWillUnmount(): void;
     render(): JSX.Element | null;
     private selectRow;
+    private selectRows;
     private hoverRows;
     private updateCellHoverLocation;
 }

package/dist/types/plugins/table/utils/index.d.ts

@@ -9,4 +9,4 @@ export type { RowParams } from './row-controls';
 export { getSelectedTableInfo, getSelectedCellInfo } from './analytics';
 export { getMergedCellsPositions } from './table';
 export { updatePluginStateDecorations } from './update-plugin-state-decorations';
-export { hasMergedCellsInColumn, hasMergedCellsInRow } from './merged-cells';
+export { hasMergedCellsInColumn, hasMergedCellsInRow, hasMergedCellsInBetween, } from './merged-cells';

package/dist/types/plugins/table/utils/merged-cells.d.ts

@@ -1,3 +1,6 @@
 import type { Selection } from '@atlaskit/editor-prosemirror/state';
+type MergeType = 'row' | 'column';
 export declare const hasMergedCellsInColumn: (columnIndexes: number | number[]) => (selection: Selection) => boolean;
 export declare const hasMergedCellsInRow: (rowIndexes: number | number[]) => (selection: Selection) => boolean;
+export declare const hasMergedCellsInBetween: (indexes: number[], type: MergeType) => (selection: Selection) => boolean;
+export {};

package/dist/types-ts4.5/plugins/table/commands/index.d.ts

@@ -2,7 +2,7 @@ export { hoverColumns, hoverRows, hoverTable, hoverCell, hoverMergedCells, clear
 export { insertColumn, insertRow, createTable } from './insert';
 export { getNextLayout, toggleContextualMenu, toggleHeaderColumn, toggleHeaderRow, toggleNumberColumn, toggleTableLayout, } from './toggle';
 export { clearMultipleCells } from './clear';
-export { autoSizeTable, convertFirstRowToHeader, deleteTable, hideInsertColumnOrRowButton, moveCursorBackward, selectColumn, selectRow, setCellAttr, setEditorFocus, setMultipleCellAttrs, setTableRef, showInsertColumnButton, showInsertRowButton, transformSliceToAddTableHeaders, triggerUnlessTableHeader, addBoldInEmptyHeaderCells, addResizeHandleDecorations, } from './misc';
+export { autoSizeTable, convertFirstRowToHeader, deleteTable, hideInsertColumnOrRowButton, moveCursorBackward, selectColumn, selectColumns, selectRow, selectRows, setCellAttr, setEditorFocus, setMultipleCellAttrs, setTableRef, showInsertColumnButton, showInsertRowButton, transformSliceToAddTableHeaders, triggerUnlessTableHeader, addBoldInEmptyHeaderCells, addResizeHandleDecorations, } from './misc';
 export { sortByColumn } from './sort';
 export { goToNextCell } from './go-to-next-cell';
 export { removeDescendantNodes } from './referentiality';

package/dist/types-ts4.5/plugins/table/commands/misc.d.ts

@@ -20,7 +20,9 @@ export declare const convertFirstRowToHeader: (schema: Schema) => (tr: Transacti
 export declare const moveCursorBackward: Command;
 export declare const setMultipleCellAttrs: (attrs: Object, targetCellPosition?: number) => Command;
 export declare const selectColumn: (column: number, expand?: boolean) => Command;
+export declare const selectColumns: (columnIndexes: number[]) => Command;
 export declare const selectRow: (row: number, expand?: boolean) => Command;
+export declare const selectRows: (rowIndexes: number[]) => Command;
 export declare const showInsertColumnButton: (columnIndex: number) => Command;
 export declare const showInsertRowButton: (rowIndex: number) => Command;
 export declare const hideInsertColumnOrRowButton: () => Command;

package/dist/types-ts4.5/plugins/table/ui/TableFloatingControls/RowControls/DragControls.d.ts

@@ -16,6 +16,7 @@ type DragControlsProps = {
     canDrag?: boolean;
     hoverRows: (rows: number[], danger?: boolean) => void;
     selectRow: (row: number, expand: boolean) => void;
+    selectRows: (rowIndexes: number[]) => void;
     updateCellHoverLocation: (rowIndex: number) => void;
 };
 export declare const DragControls: React.FC<import("react-intl-next").WithIntlProps<DragControlsProps & WrappedComponentProps<"intl">>> & {

package/dist/types-ts4.5/plugins/table/ui/TableFloatingControls/index.d.ts

@@ -42,6 +42,7 @@ export default class TableFloatingControls extends Component<Props, State> {
     componentWillUnmount(): void;
     render(): JSX.Element | null;
     private selectRow;
+    private selectRows;
     private hoverRows;
     private updateCellHoverLocation;
 }

package/dist/types-ts4.5/plugins/table/utils/index.d.ts

@@ -9,4 +9,4 @@ export type { RowParams } from './row-controls';
 export { getSelectedTableInfo, getSelectedCellInfo } from './analytics';
 export { getMergedCellsPositions } from './table';
 export { updatePluginStateDecorations } from './update-plugin-state-decorations';
-export { hasMergedCellsInColumn, hasMergedCellsInRow } from './merged-cells';
+export { hasMergedCellsInColumn, hasMergedCellsInRow, hasMergedCellsInBetween, } from './merged-cells';

package/dist/types-ts4.5/plugins/table/utils/merged-cells.d.ts

@@ -1,3 +1,6 @@
 import type { Selection } from '@atlaskit/editor-prosemirror/state';
+type MergeType = 'row' | 'column';
 export declare const hasMergedCellsInColumn: (columnIndexes: number | number[]) => (selection: Selection) => boolean;
 export declare const hasMergedCellsInRow: (rowIndexes: number | number[]) => (selection: Selection) => boolean;
+export declare const hasMergedCellsInBetween: (indexes: number[], type: MergeType) => (selection: Selection) => boolean;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/editor-plugin-table",
-  "version": "5.5.3",
+  "version": "5.5.5",
   "description": "Table plugin for the @atlaskit/editor",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"

package/src/__tests__/unit/ui/FloatingInsertButton.tsx

@@ -144,9 +144,9 @@ describe('Floating Insert Button when findDomRefAtPos fails', () => {
         docSize: 46,
         error: 'Error: Error message from mock',
       }),
-      nonPrivacySafeAttributes: expect.objectContaining({
-        errorStack: 'stack trace',
-      }),
+    });
+    expect(createAnalyticsEvent).not.toHaveBeenCalledWith({
+      nonPrivacySafeAttributes: expect.any(Object),
     });
   });
 

package/src/__tests__/unit/ui/RowDragControls.tsx

@@ -74,6 +74,7 @@ describe('NumberColumn', () => {
           isTableHovered={true}
           hoverRows={jest.fn()}
           selectRow={jest.fn()}
+          selectRows={jest.fn()}
           updateCellHoverLocation={jest.fn()}
           tableWidth={760}
         />
@@ -111,6 +112,7 @@ describe('NumberColumn', () => {
           }}
           hoverRows={jest.fn()}
           selectRow={jest.fn()}
+          selectRows={jest.fn()}
           updateCellHoverLocation={jest.fn()}
           tableWidth={760}
         />

package/src/__tests__/unit/utils/merged-cells.ts

@@ -0,0 +1,156 @@
+import type { DocBuilder } from '@atlaskit/editor-common/types';
+// eslint-disable-next-line import/no-extraneous-dependencies -- Removed import for fixing circular dependencies
+import { analyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import { contentInsertionPlugin } from '@atlaskit/editor-plugin-content-insertion';
+import { guidelinePlugin } from '@atlaskit/editor-plugin-guideline';
+import { selectionPlugin } from '@atlaskit/editor-plugin-selection';
+import { widthPlugin } from '@atlaskit/editor-plugin-width';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import type { LightEditorPlugin } from '@atlaskit/editor-test-helpers/create-prosemirror-editor';
+// eslint-disable-next-line import/no-extraneous-dependencies -- Removed import for fixing circular dependencies
+import {
+  createProsemirrorEditorFactory,
+  Preset,
+} from '@atlaskit/editor-test-helpers/create-prosemirror-editor';
+// eslint-disable-next-line import/no-extraneous-dependencies -- Removed import for fixing circular dependencies
+import {
+  doc,
+  p,
+  table,
+  td,
+  tdEmpty,
+  tr,
+} from '@atlaskit/editor-test-helpers/doc-builder';
+
+import tablePlugin from '../../../plugins/table-plugin';
+import { pluginKey } from '../../../plugins/table/pm-plugins/plugin-key';
+import { hasMergedCellsInBetween } from '../../../plugins/table/utils';
+
+describe('table merge cells logic', () => {
+  const createEditor = createProsemirrorEditorFactory();
+
+  const editor = (doc: DocBuilder) =>
+    createEditor({
+      doc,
+      preset: new Preset<LightEditorPlugin>()
+        .add([analyticsPlugin, {}])
+        .add(contentInsertionPlugin)
+        .add(widthPlugin)
+        .add(guidelinePlugin)
+        .add(selectionPlugin)
+        .add(tablePlugin),
+      pluginKey,
+    });
+
+  describe('#hasMergedCellsInBetween', () => {
+    describe('when first and second columns are merged', () => {
+      const { editorView } = editor(
+        doc(
+          table()(
+            tr(td({ colspan: 2 })(p('')), tdEmpty, tdEmpty),
+            tr(tdEmpty, tdEmpty, tdEmpty, tdEmpty),
+            tr(tdEmpty, tdEmpty, tdEmpty, tdEmpty),
+          ),
+        ),
+      );
+
+      it('should return false when pass indexs [-1, 0]', () => {
+        expect(
+          hasMergedCellsInBetween(
+            [-1, 0],
+            'column',
+          )(editorView.state.selection),
+        ).toEqual(false);
+      });
+
+      it('should return true when pass indexs [0,1]', () => {
+        expect(
+          hasMergedCellsInBetween([0, 1], 'column')(editorView.state.selection),
+        ).toEqual(true);
+      });
+
+      it('should return false when pass indexs [1,2]', () => {
+        expect(
+          hasMergedCellsInBetween([1, 2], 'column')(editorView.state.selection),
+        ).toEqual(false);
+      });
+    });
+
+    describe('when second and third columns are merged', () => {
+      const { editorView } = editor(
+        doc(
+          table()(
+            tr(tdEmpty, td({ colspan: 2 })(p('')), tdEmpty),
+            tr(tdEmpty, tdEmpty, tdEmpty, tdEmpty),
+            tr(tdEmpty, tdEmpty, tdEmpty, tdEmpty),
+          ),
+        ),
+      );
+      it('should return false when pass indexs [0,1]', () => {
+        expect(
+          hasMergedCellsInBetween([0, 1], 'column')(editorView.state.selection),
+        ).toEqual(false);
+      });
+
+      it('should return true when pass indexs [1,2]', () => {
+        expect(
+          hasMergedCellsInBetween([1, 2], 'column')(editorView.state.selection),
+        ).toEqual(true);
+      });
+    });
+
+    describe('when first and second rows are merged', () => {
+      const { editorView } = editor(
+        doc(
+          table()(
+            tr(td({ rowspan: 2 })(p('')), tdEmpty, tdEmpty, tdEmpty),
+            tr(tdEmpty, tdEmpty, tdEmpty),
+            tr(tdEmpty, tdEmpty, tdEmpty, tdEmpty),
+          ),
+        ),
+      );
+
+      it('should return false when pass indexs [-1, 0]', () => {
+        expect(
+          hasMergedCellsInBetween([-1, 0], 'row')(editorView.state.selection),
+        ).toEqual(false);
+      });
+
+      it('should return true when pass indexs [0,1]', () => {
+        expect(
+          hasMergedCellsInBetween([0, 1], 'row')(editorView.state.selection),
+        ).toEqual(true);
+      });
+
+      it('should return false when pass indexs [1,2]', () => {
+        expect(
+          hasMergedCellsInBetween([1, 2], 'row')(editorView.state.selection),
+        ).toEqual(false);
+      });
+    });
+
+    describe('when second and third rows are merged', () => {
+      const { editorView } = editor(
+        doc(
+          table()(
+            tr(tdEmpty, tdEmpty, tdEmpty, tdEmpty),
+            tr(td({ rowspan: 2 })(p('')), tdEmpty, tdEmpty),
+            tr(tdEmpty, tdEmpty, tdEmpty, tdEmpty),
+          ),
+        ),
+      );
+
+      it('should return false when pass indexs [0,1]', () => {
+        expect(
+          hasMergedCellsInBetween([0, 1], 'row')(editorView.state.selection),
+        ).toEqual(false);
+      });
+
+      it('should return true when pass indexs [1,2]', () => {
+        expect(
+          hasMergedCellsInBetween([1, 2], 'row')(editorView.state.selection),
+        ).toEqual(true);
+      });
+    });
+  });
+});

package/src/plugins/table/commands/index.ts

@@ -26,7 +26,9 @@ export {
   hideInsertColumnOrRowButton,
   moveCursorBackward,
   selectColumn,
+  selectColumns,
   selectRow,
+  selectRows,
   setCellAttr,
   setEditorFocus,
   setMultipleCellAttrs,