@atlaskit/editor-plugin-table 5.5.4 → 5.5.5

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @atlaskit/editor-plugin-table
 
+## 5.5.5
+
+### Patch Changes
+
+- [#59951](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/59951) [`a42a17e8af1b`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/a42a17e8af1b) - ED-21106: Remove nonPrivacySafeAttributes from editor operational events
+- [#59453](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/59453) [`e23de3e96559`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/e23de3e96559) - Fix drop table row/column next to merged cells
+
 ## 5.5.4
 
 ### Patch Changes

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

@@ -13,7 +13,6 @@ var _cellSelection = require("@atlaskit/editor-tables/cell-selection");
 var _utils = require("@atlaskit/editor-tables/utils");
 var _element = require("@atlaskit/pragmatic-drag-and-drop/adapter/element");
 var _utils2 = require("../../utils");
-var _mergedCells = require("../../utils/merged-cells");
 var _pluginFactory = require("../plugin-factory");
 var _pluginKey = require("../plugin-key");
 var _actions = require("./actions");
@@ -182,8 +181,7 @@ var createPlugin = exports.createPlugin = function createPlugin(dispatch, eventD
             }
 
             // If the drop target index contains merged cells then we should not allow the drop to occur.
-            var hasMergedCells = sourceType === 'table-row' ? _mergedCells.hasMergedCellsInRow : _mergedCells.hasMergedCellsInColumn;
-            if (hasMergedCells(targetAdjustedIndex)(editorView.state.selection)) {
+            if ((0, _utils2.hasMergedCellsInBetween)([targetAdjustedIndex - 1, targetAdjustedIndex], sourceType === 'table-row' ? _consts.DropTargetType.ROW : _consts.DropTargetType.COLUMN)(editorView.state.selection)) {
               (0, _commands.clearDropTarget)(tr)(editorView.state, editorView.dispatch);
               return;
             }

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

@@ -105,9 +105,6 @@ var FloatingInsertButton = exports.FloatingInsertButton = /*#__PURE__*/function
               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/cjs/plugins/table/utils/index.js

@@ -213,6 +213,12 @@ Object.defineProperty(exports, "getTableWidth", {
     return _nodes.getTableWidth;
   }
 });
+Object.defineProperty(exports, "hasMergedCellsInBetween", {
+  enumerable: true,
+  get: function get() {
+    return _mergedCells.hasMergedCellsInBetween;
+  }
+});
 Object.defineProperty(exports, "hasMergedCellsInColumn", {
   enumerable: true,
   get: function get() {

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

@@ -1,9 +1,11 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.hasMergedCellsInRow = exports.hasMergedCellsInColumn = void 0;
+exports.hasMergedCellsInRow = exports.hasMergedCellsInColumn = exports.hasMergedCellsInBetween = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _editorTables = require("@atlaskit/editor-tables");
 var hasMergedCells = function hasMergedCells(indexes, normalizeRect) {
   return function (selection) {
@@ -63,4 +65,76 @@ var hasMergedCellsInRow = exports.hasMergedCellsInRow = function hasMergedCellsI
       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
+    };
+  }
+};
+var hasMergedCellsInBetween = exports.hasMergedCellsInBetween = function hasMergedCellsInBetween(indexes, type) {
+  return function (selection) {
+    var table = (0, _editorTables.findTable)(selection);
+    if (!table) {
+      return false;
+    }
+    var map = _editorTables.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 (0, _toConsumableArray2.default)(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/es2019/plugins/table/pm-plugins/drag-and-drop/plugin.js

@@ -3,8 +3,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';
@@ -184,8 +183,7 @@ export const createPlugin = (dispatch, eventDispatcher) => {
             }
 
             // If the drop target index contains merged cells then we should not allow the drop to occur.
-            const 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;
             }

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

@@ -85,9 +85,6 @@ export class FloatingInsertButton extends 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/es2019/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/es2019/plugins/table/utils/merged-cells.js

@@ -45,4 +45,66 @@ export const hasMergedCellsInRow = rowIndexes => hasMergedCells(rowIndexes, (ind
     top: y,
     bottom: y === index ? y + 1 : y
   };
-});
+});
+const getRect = (index, type, map) => {
+  if (type === 'column') {
+    const 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 {
+    const 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 const hasMergedCellsInBetween = (indexes, type) => selection => {
+  const table = findTable(selection);
+  if (!table) {
+    return false;
+  }
+  const map = TableMap.get(table.node);
+  const cellPositions = new Set();
+  const mergedCells = new Set();
+  map.map.forEach(value => {
+    if (cellPositions.has(value)) {
+      mergedCells.add(value);
+    } else {
+      cellPositions.add(value);
+    }
+  });
+  if (!mergedCells.size) {
+    return false;
+  }
+  const getMergedCellsInRect = (index, type) => {
+    const rect = getRect(index, type, map);
+    const isValidRectangle = rect.left < rect.right && rect.top < rect.bottom;
+    if (!isValidRectangle) {
+      return [];
+    }
+    const cells = map.cellsInRect(rect);
+    let allCellsInRect = [];
+    if (type === 'column') {
+      allCellsInRect = map.map.filter((_, key) => key % map.width === index);
+    } else {
+      allCellsInRect = map.map.filter((_, key) => Math.floor(key / map.width) === index);
+    }
+    const mergedCell = allCellsInRect.filter(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 [...new Set(mergedCell)];
+  };
+  const mergedCellsInRectArr = indexes.map(index => getMergedCellsInRect(index, type));
+
+  // Currently only support 2 indexes, but we can extend this to support more indexes in the future.
+  return mergedCellsInRectArr[0].some(cell => mergedCellsInRectArr[1].includes(cell));
+};

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;
             }

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/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/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/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.4",
+  "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/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/pm-plugins/drag-and-drop/plugin.ts

@@ -10,11 +10,10 @@ import { getCellsInRow } from '@atlaskit/editor-tables/utils';
 import { monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/adapter/element';
 
 import type { DraggableSourceData } from '../../types';
-import { findNearestCellIndexToPoint } from '../../utils';
 import {
-  hasMergedCellsInColumn,
-  hasMergedCellsInRow,
-} from '../../utils/merged-cells';
+  findNearestCellIndexToPoint,
+  hasMergedCellsInBetween,
+} from '../../utils';
 import { getPluginState as getTablePluginState } from '../plugin-factory';
 import { pluginKey as tablePluginKey } from '../plugin-key';
 
@@ -215,12 +214,13 @@ export const createPlugin = (
             }
 
             // If the drop target index contains merged cells then we should not allow the drop to occur.
-            const hasMergedCells =
-              sourceType === 'table-row'
-                ? hasMergedCellsInRow
-                : hasMergedCellsInColumn;
             if (
-              hasMergedCells(targetAdjustedIndex)(editorView.state.selection)
+              hasMergedCellsInBetween(
+                [targetAdjustedIndex - 1, targetAdjustedIndex],
+                sourceType === 'table-row'
+                  ? DropTargetType.ROW
+                  : DropTargetType.COLUMN,
+              )(editorView.state.selection)
             ) {
               clearDropTarget(tr)(editorView.state, editorView.dispatch);
               return;

package/src/plugins/table/ui/FloatingInsertButton/index.tsx

@@ -153,9 +153,6 @@ export class FloatingInsertButton extends React.Component<
             docSize: editorView.state.doc.nodeSize,
             error: (error as any)?.toString(),
           },
-          nonPrivacySafeAttributes: {
-            errorStack: (error as any).stack || undefined,
-          },
         };
         dispatchAnalyticsEvent(payload);
       }

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

@@ -79,4 +79,8 @@ 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/src/plugins/table/utils/merged-cells.ts

@@ -2,6 +2,8 @@ import type { Selection } from '@atlaskit/editor-prosemirror/state';
 import type { Rect } from '@atlaskit/editor-tables';
 import { findTable, TableMap } from '@atlaskit/editor-tables';
 
+type MergeType = 'row' | 'column';
+
 const hasMergedCells =
   (
     indexes: number | number[],
@@ -65,3 +67,83 @@ export const hasMergedCellsInRow = (rowIndexes: number | number[]) =>
       bottom: y === index ? y + 1 : y,
     };
   });
+
+const getRect = (index: number, type: MergeType, map: TableMap) => {
+  if (type === 'column') {
+    const 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 {
+    const 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 const hasMergedCellsInBetween =
+  (indexes: number[], type: MergeType) =>
+  (selection: Selection): boolean => {
+    const table = findTable(selection);
+    if (!table) {
+      return false;
+    }
+
+    const map = TableMap.get(table.node);
+    const cellPositions = new Set<number>();
+    const mergedCells = new Set<number>();
+
+    map.map.forEach((value) => {
+      if (cellPositions.has(value)) {
+        mergedCells.add(value);
+      } else {
+        cellPositions.add(value);
+      }
+    });
+
+    if (!mergedCells.size) {
+      return false;
+    }
+
+    const getMergedCellsInRect = (index: number, type: MergeType) => {
+      const rect = getRect(index, type, map);
+      const isValidRectangle = rect.left < rect.right && rect.top < rect.bottom;
+      if (!isValidRectangle) {
+        return [];
+      }
+
+      const cells = map.cellsInRect(rect);
+
+      let allCellsInRect = [];
+      if (type === 'column') {
+        allCellsInRect = map.map.filter((_, key) => key % map.width === index);
+      } else {
+        allCellsInRect = map.map.filter(
+          (_, key) => Math.floor(key / map.width) === index,
+        );
+      }
+      const mergedCell = allCellsInRect.filter((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 [...new Set(mergedCell)];
+    };
+
+    const mergedCellsInRectArr = indexes.map((index) =>
+      getMergedCellsInRect(index, type),
+    );
+
+    // Currently only support 2 indexes, but we can extend this to support more indexes in the future.
+    return mergedCellsInRectArr[0].some((cell) =>
+      mergedCellsInRectArr[1].includes(cell),
+    );
+  };