@atlaskit/editor-core 153.1.5 → 157.0.0

package/dist/es2019/plugins/paste/pm-plugins/clipboard-text-serializer.js

@@ -0,0 +1,37 @@
+/**
+ * Returns a plain text serialization of a given slice. This is used for populating the plain text
+ * section of the clipboard on copy.
+ * The current implementation is bare bones - only inlineCards and blockCards are tested (they
+ * previously were empty on plain text copy).
+ * Unknown nodes are passed to node.textBetween().
+ *
+ * By default (without this function passed to the editor), the editor uses
+ * `slice.content.textBetween(0, slice.content.size, "\n\n")`
+ * (see https://prosemirror.net/docs/ref/#view.EditorProps.clipboardTextSerializer)
+ */
+export function clipboardTextSerializer(slice) {
+  let text = '';
+  const blockSeparater = '\n\n';
+  slice.content.nodesBetween(0, slice.content.size, node => {
+    if (node.type.isBlock) {
+      text += blockSeparater;
+    }
+
+    if (node.type.name === 'paragraph') {
+      return true;
+    } else if (node.type.name === 'hardBreak') {
+      text += '\n';
+    } else if (node.type.name === 'text') {
+      text += node.text;
+    } else if (node.type.name === 'inlineCard') {
+      text += node.attrs.url;
+    } else if (node.type.name === 'blockCard') {
+      text += node.attrs.url;
+    } else {
+      text += node.textBetween(0, node.content.size, '\n\n');
+    }
+
+    return false;
+  });
+  return text.trim();
+}

package/dist/es2019/plugins/paste/pm-plugins/main.js

@@ -1,10 +1,12 @@
 // @ts-ignore: outdated type definitions
 import { handlePaste as handlePasteTable } from '@atlaskit/editor-tables/utils';
 import { Slice, Fragment } from 'prosemirror-model';
-import { Plugin, PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
 import uuid from 'uuid';
 import { MarkdownTransformer } from '@atlaskit/editor-markdown-transformer';
 import { getExtensionAutoConvertersFromProvider } from '@atlaskit/editor-common/extensions';
+sendPasteAnalyticsEvent;
 import * as clipboard from '../../../utils/clipboard';
 import { transformSliceForMedia } from '../../media/utils/media-single';
 import { escapeLinks, htmlContainsSingleFile, isPastedFromWord, isPastedFromExcel, htmlHasInvalidLinkTags, removeDuplicateInvalidLinks } from '../util';
@@ -29,6 +31,8 @@ import { transformUnsupportedBlockCardToInline } from '../../card/utils';
 import { transformSliceToDecisionList } from '../../tasks-and-decisions/utils';
 import { containsAnyAnnotations, stripNonExistingAnnotations } from '../../annotation/utils';
 import { pluginKey as betterTypePluginKey } from '../../base/pm-plugins/better-type-history';
+import { clipboardTextSerializer } from './clipboard-text-serializer';
+import { htmlHasIncompleteTable, tryRebuildCompleteTableHtml, isPastedFromTinyMCEConfluence } from '../util/tinyMCE';
 export const stateKey = new PluginKey('pastePlugin');
 export { md } from '../md';
 
@@ -47,7 +51,7 @@ function isBackgroundCellAllowed(state) {
   return tableState && tableState.pluginConfig.allowBackgroundColor;
 }
 
-export function createPlugin(schema, dispatchAnalyticsEvent, cardOptions, sanitizePrivateContent, providerFactory) {
+export function createPlugin(schema, dispatchAnalyticsEvent, plainTextPasteLinkification, cardOptions, sanitizePrivateContent, providerFactory) {
   const atlassianMarkDownParser = new MarkdownTransformer(schema, md);
 
   function getMarkdownSlice(text, openStart, openEnd) {
@@ -85,9 +89,19 @@ export function createPlugin(schema, dispatchAnalyticsEvent, cardOptions, saniti
     providerFactory.subscribe('extensionProvider', setExtensionAutoConverter);
   }
 
-  return new Plugin({
+  let mostRecentPasteEvent;
+  return new SafePlugin({
     key: stateKey,
     props: {
+      // For serialising to plain text
+      clipboardTextSerializer,
+      handleDOMEvents: {
+        paste: (view, event) => {
+          mostRecentPasteEvent = event;
+          return false;
+        }
+      },
+
       handlePaste(view, rawEvent, slice) {
         var _analyticsPlugin$perf, _analyticsPlugin$perf2;
 
@@ -174,8 +188,9 @@ export function createPlugin(schema, dispatchAnalyticsEvent, cardOptions, saniti
         };
 
         slice = handleParagraphBlockMarks(state, slice);
+        const plainTextPasteSlice = plainTextPasteLinkification === true ? linkifyContent(state.schema)(slice) : slice;
 
-        if (handlePasteAsPlainTextWithAnalytics(view, event, slice)(state, dispatch, view)) {
+        if (handlePasteAsPlainTextWithAnalytics(view, event, plainTextPasteSlice)(state, dispatch, view)) {
           return true;
         } // transform slices based on destination
 
@@ -343,6 +358,17 @@ export function createPlugin(schema, dispatchAnalyticsEvent, cardOptions, saniti
         if (html.indexOf('id="docs-internal-guid-') >= 0) {
           html = html.replace(/white-space:pre/g, '');
           html = html.replace(/white-space:pre-wrap/g, '');
+        } // Partial fix for ED-7331: During a copy/paste from the legacy tinyMCE
+        // confluence editor, if we encounter an incomplete table (e.g. table elements
+        // not wrapped in <table>), we try to rebuild a complete, valid table if possible.
+
+
+        if (mostRecentPasteEvent && isPastedFromTinyMCEConfluence(mostRecentPasteEvent, html) && htmlHasIncompleteTable(html)) {
+          const completeTableHtml = tryRebuildCompleteTableHtml(html);
+
+          if (completeTableHtml) {
+            html = completeTableHtml;
+          }
         }
 
         if (!isPastedFromWord(html) && !isPastedFromExcel(html) && html.indexOf('<img ') >= 0) {
@@ -356,6 +382,7 @@ export function createPlugin(schema, dispatchAnalyticsEvent, cardOptions, saniti
           html = removeDuplicateInvalidLinks(html);
         }
 
+        mostRecentPasteEvent = null;
         return html;
       }
 

package/dist/es2019/plugins/paste/util/tinyMCE.js

@@ -0,0 +1,185 @@
+import chunk from 'lodash/chunk';
+
+const isPastedFromTinyMCE = pasteEvent => {
+  var _pasteEvent$clipboard, _pasteEvent$clipboard2, _pasteEvent$clipboard3;
+
+  return (_pasteEvent$clipboard = pasteEvent === null || pasteEvent === void 0 ? void 0 : (_pasteEvent$clipboard2 = pasteEvent.clipboardData) === null || _pasteEvent$clipboard2 === void 0 ? void 0 : (_pasteEvent$clipboard3 = _pasteEvent$clipboard2.types) === null || _pasteEvent$clipboard3 === void 0 ? void 0 : _pasteEvent$clipboard3.some(mimeType => mimeType === 'x-tinymce/html')) !== null && _pasteEvent$clipboard !== void 0 ? _pasteEvent$clipboard : false;
+};
+
+export const isPastedFromTinyMCEConfluence = (pasteEvent, html) => {
+  return isPastedFromTinyMCE(pasteEvent) && !!html && !!html.match(/class=\"\s?(confluenceTd|confluenceTh|confluenceTable).+"/gim);
+};
+/**
+ * Wraps html markup with a `<table>` and uses `DOMParser` to generate
+ * and return both the table-wrapped and non-table-wrapped DOM document
+ * instances.
+ */
+
+export const wrapWithTable = html => {
+  const parser = new DOMParser();
+  const nonTableWrappedDoc = parser.parseFromString(html, 'text/html');
+  const tableWrappedDoc = parser.parseFromString(`<table>${html}</table>`, 'text/html');
+  tableWrappedDoc.body.querySelectorAll('meta').forEach(meta => {
+    tableWrappedDoc.head.prepend(meta);
+  });
+  return {
+    tableWrappedDoc,
+    nonTableWrappedDoc
+  };
+};
+
+const exactlyDivisible = (larger, smaller) => larger % smaller === 0;
+
+const getTableElementsInfo = doc => {
+  const cellCount = doc.querySelectorAll('td').length;
+  const thCount = doc.querySelectorAll('th').length;
+  const mergedCellCount = doc.querySelectorAll('td[colspan]:not([colspan="1"])').length;
+  let hasThAfterTd = false;
+  const thsAndCells = doc.querySelectorAll('th,td');
+
+  for (let i = 0, cellFound = false; i < thsAndCells.length; i++) {
+    if (cellFound && thsAndCells[i].nodeName === 'TH') {
+      hasThAfterTd = true;
+      break;
+    }
+
+    if (thsAndCells[i].nodeName === 'TD') {
+      cellFound = true;
+    }
+  }
+
+  const onlyTh = thCount > 0 && cellCount === 0;
+  const onlyCells = cellCount > 0 && thCount === 0;
+  const hasCompleteRow = // we take header-only and cell-only tables to be
+  // row-complete
+  onlyTh || onlyCells || // if headers and cells can "fit" against each other,
+  // then we assume a complete row exists
+  (exactlyDivisible(thCount, cellCount) || exactlyDivisible(cellCount, thCount)) && // all numbers are divisible by 1, so we carve out a specific
+  // check for when there is only 1 table cell, and more than 1
+  // table header.
+  !(thCount > 1 && cellCount === 1);
+  return {
+    cellCount,
+    thCount,
+    mergedCellCount,
+    hasThAfterTd,
+    hasIncompleteRow: !hasCompleteRow
+  };
+};
+
+const configureTableRows = (doc, colsInRow) => {
+  var _Array$from;
+
+  const tableHeadersAndCells = Array.from(doc.body.querySelectorAll('th,td'));
+  const evenlySplitChunks = chunk(tableHeadersAndCells, colsInRow);
+  const tableBody = doc.body.querySelector('tbody');
+  evenlySplitChunks.forEach(chunk => {
+    const tr = doc.createElement('tr');
+    tableBody === null || tableBody === void 0 ? void 0 : tableBody.append(tr);
+    tr.append(...chunk);
+  }); // We remove any leftover empty rows which may cause fabric editor
+  // to no-op when parsing the table
+
+  const emptyRows = (_Array$from = Array.from(tableBody.querySelectorAll('tr'))) === null || _Array$from === void 0 ? void 0 : _Array$from.filter(row => row.innerHTML.trim().length === 0);
+  emptyRows.forEach(row => row.remove());
+  return doc.body.innerHTML;
+};
+
+const fillIncompleteRowWithEmptyCells = (doc, thCount, cellCount) => {
+  var _lastCell$parentEleme;
+
+  let extraCellsCount = 0;
+
+  while (!exactlyDivisible(cellCount + extraCellsCount, thCount)) {
+    extraCellsCount++;
+  }
+
+  const extraEmptyCells = Array.from(Array(extraCellsCount)).map(() => doc.createElement('td'));
+  const lastCell = doc.body.querySelector('td:last-of-type');
+  lastCell === null || lastCell === void 0 ? void 0 : (_lastCell$parentEleme = lastCell.parentElement) === null || _lastCell$parentEleme === void 0 ? void 0 : _lastCell$parentEleme.append(...extraEmptyCells);
+  return {
+    updatedCellCount: cellCount + extraCellsCount
+  };
+};
+/**
+ * Given a DOM document, it will try to rebuild table rows by using the
+ * table headers count as an initial starting point for the assumed
+ * number of columns that make up a row (`colsInRow`). It will slowly
+ * decrease that `colsInRow` count until it finds exact fit for table
+ * headers and cells with `colsInRow` else it returns the original
+ * document's markup.
+ *
+ * NOTE: It will NOT try to rebuild table rows if it encounters merged cells
+ * or compex table configurations (where table headers exist after normal
+ * table cells). It will build a single column table if NO table
+ * headers exist.
+ */
+
+
+export const tryReconstructTableRows = doc => {
+  let {
+    cellCount,
+    thCount,
+    mergedCellCount,
+    hasThAfterTd,
+    hasIncompleteRow
+  } = getTableElementsInfo(doc);
+
+  if (mergedCellCount || hasThAfterTd) {
+    // bail out to avoid handling more complex table structures
+    return doc.body.innerHTML;
+  }
+
+  if (!thCount) {
+    // if no table headers exist for reference, fallback to a single column table structure
+    return configureTableRows(doc, 1);
+  }
+
+  if (hasIncompleteRow) {
+    // if shift-click selection copies a partial table row to the clipboard,
+    // and we do have table headers for reference, then we add empty table cells
+    // to fill out the partial row
+    const {
+      updatedCellCount
+    } = fillIncompleteRowWithEmptyCells(doc, thCount, cellCount);
+    cellCount = updatedCellCount;
+  }
+
+  for (let possibleColsInRow = thCount; possibleColsInRow > 0; possibleColsInRow--) {
+    if (exactlyDivisible(thCount, possibleColsInRow) && exactlyDivisible(cellCount, possibleColsInRow)) {
+      return configureTableRows(doc, possibleColsInRow);
+    }
+  }
+
+  return doc.body.innerHTML;
+};
+export const htmlHasIncompleteTable = html => {
+  return !html.includes('<table ') && (html.includes('<td ') || html.includes('<th '));
+};
+/**
+ * Strictly for ED-7331. Given incomplete table html from tinyMCE, it will try to rebuild
+ * a whole valid table. If it rebuilds the table, it may first rebuild it as a single
+ * row table, so this also then tries to reconstruct the table rows/columns if
+ * possible (best effort).
+ */
+
+export const tryRebuildCompleteTableHtml = incompleteTableHtml => {
+  // first we try wrapping the table elements with <table> and let DOMParser try to rebuild
+  // a valid DOM tree. we also keep the non-wrapped table for comparison purposes.
+  const {
+    nonTableWrappedDoc,
+    tableWrappedDoc
+  } = wrapWithTable(incompleteTableHtml);
+  const didPreserveTableElements = Boolean(!nonTableWrappedDoc.body.querySelector('th, td') && tableWrappedDoc.body.querySelector('th, td'));
+  const isExpectedStructure = tableWrappedDoc.querySelectorAll('body > table:only-child') && !tableWrappedDoc.querySelector(`body > table > tbody > tr > :not(th,td)`); // if DOMParser saves table elements that we would otherwise lose, and
+  // if the table html is what we'd expect (a single table, with no extraneous
+  // elements in table rows other than th, td), then we can now also try to
+  // rebuild table rows/columns.
+
+  if (didPreserveTableElements && isExpectedStructure) {
+    const completeTableHtml = tryReconstructTableRows(tableWrappedDoc);
+    return completeTableHtml;
+  }
+
+  return null;
+};

package/dist/es2019/plugins/placeholder/index.js

@@ -1,4 +1,5 @@
-import { Plugin, PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
 import { DecorationSet, Decoration } from 'prosemirror-view';
 import { isInEmptyLine, isEmptyDocument, bracketTyped } from '../../utils/document';
 import { pluginKey as alignmentPluginKey } from '../alignment/pm-plugins/main';
@@ -98,7 +99,7 @@ export function createPlugin(defaultPlaceholderText, placeholderHints, bracketPl
   }
 
   const getPlaceholderHintMessage = createGetPlaceholderHintMessage(placeholderHints);
-  return new Plugin({
+  return new SafePlugin({
     key: pluginKey,
     state: {
       init: (_, state) => createPlaceHolderStateFrom(state, getPlaceholderHintMessage, defaultPlaceholderText, bracketPlaceholderText),

package/dist/es2019/plugins/placeholder-text/index.js

@@ -1,5 +1,6 @@
 import React from 'react';
-import { NodeSelection, Plugin, TextSelection } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { NodeSelection, TextSelection } from 'prosemirror-state';
 import { placeholder } from '@atlaskit/adf-schema';
 import MediaServicesTextIcon from '@atlaskit/icon/glyph/media-services/text';
 import WithPluginState from '../../ui/WithPluginState';
@@ -13,7 +14,7 @@ import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, addAnalytics, EVENT_TYPE, IN
 import { messages } from '../insert-block/ui/ToolbarInsertBlock/messages';
 export function createPlugin(dispatch, options) {
   const allowInserting = !!options.allowInserting;
-  return new Plugin({
+  return new SafePlugin({
     key: pluginKey,
     state: {
       init: () => ({

package/dist/es2019/plugins/quick-insert/index.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { Plugin } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import memoizeOne from 'memoize-one';
 import { TypeAheadAvailableNodes } from '@atlaskit/editor-common/type-ahead';
 import { pluginKey } from './plugin-key';
@@ -109,7 +109,7 @@ const setProviderState = providerState => (state, dispatch) => {
 };
 
 function quickInsertPluginFactory(quickInsertItems, providerFactory, getIntl, dispatch, emptyStateHandler) {
-  return new Plugin({
+  return new SafePlugin({
     key: pluginKey,
     state: {
       init() {

package/dist/es2019/plugins/rank.js

@@ -11,6 +11,6 @@ export default {
   marks: [// Fragment mark is both for inline and block elements
   'fragment', // Inline marks
   'link', 'em', 'strong', 'textColor', 'strike', 'subsup', 'underline', 'code', 'typeAheadQuery', // Block marks
-  'alignment', 'breakout', 'indentation', 'annotation', //Unsupported mark
+  'alignment', 'breakout', 'indentation', 'annotation', 'dataConsumer', // Unsupported mark
   'unsupportedMark', 'unsupportedNodeAttribute']
 };

package/dist/es2019/plugins/scroll-into-view/index.js

@@ -1,4 +1,5 @@
-import { Plugin, PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
 import { TEXT_INPUT_RULE_TRANSACTION_KEY } from '@atlaskit/prosemirror-input-rules';
 /**
  * Plugin to scroll the user's selection into view whenever the user updates
@@ -12,7 +13,7 @@ import { TEXT_INPUT_RULE_TRANSACTION_KEY } from '@atlaskit/prosemirror-input-rul
 
 export const scrollIntoViewPluginKey = new PluginKey('scrollIntoViewPlugin');
 
-const createPlugin = () => new Plugin({
+const createPlugin = () => new SafePlugin({
   key: scrollIntoViewPluginKey,
   appendTransaction: (transactions, oldState, newState) => {
     if (!transactions.length) {

package/dist/es2019/plugins/selection/pm-plugins/gap-cursor-main.js

@@ -1,4 +1,5 @@
-import { Plugin, NodeSelection } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { NodeSelection } from 'prosemirror-state';
 import { Decoration, DecorationSet } from 'prosemirror-view';
 import { findPositionOfNodeBefore } from 'prosemirror-utils';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
@@ -9,7 +10,7 @@ import { toDOM } from '../gap-cursor/utils/place-gap-cursor';
 import { deleteNode, setGapCursorAtPos } from '../gap-cursor/actions';
 import { Direction } from '../gap-cursor/direction';
 import { gapCursorPluginKey } from './gap-cursor-plugin-key';
-const plugin = new Plugin({
+const plugin = new SafePlugin({
   key: gapCursorPluginKey,
   state: {
     init: () => false,

package/dist/es2019/plugins/selection/pm-plugins/selection-main.js

@@ -1,4 +1,5 @@
-import { Plugin, NodeSelection, TextSelection } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { NodeSelection, TextSelection } from 'prosemirror-state';
 import { browser } from '@atlaskit/editor-common/utils';
 import { createPluginState, getPluginState } from '../plugin-factory';
 import { selectionPluginKey } from '../types';
@@ -28,7 +29,7 @@ const toggleContentEditable = (node, root = false) => {
 };
 
 export const createPlugin = (dispatch, dispatchAnalyticsEvent, options = {}) => {
-  return new Plugin({
+  return new SafePlugin({
     key: selectionPluginKey,
     state: createPluginState(dispatch, getInitialState),
     view: () => ({

package/dist/es2019/plugins/status/nodeviews/status.js

@@ -5,7 +5,6 @@ import styled from 'styled-components';
 import { ZERO_WIDTH_SPACE } from '@atlaskit/editor-common/utils';
 import { Status } from '@atlaskit/status/element';
 import { ReactNodeView } from '../../../nodeviews';
-import InlineNodeWrapper, { createMobileInlineDomRef } from '../../../ui/InlineNodeWrapper';
 import { messages } from './messages';
 export const StyledStatus = styled.span`
   opacity: ${props => props.placeholderStyle ? 0.5 : 1};
@@ -52,10 +51,6 @@ _defineProperty(StatusContainerView, "displayName", 'StatusContainerView');
 export const IntlStatusContainerView = injectIntl(StatusContainerView);
 export class StatusNodeView extends ReactNodeView {
   createDomRef() {
-    if (this.reactComponentProps.options && this.reactComponentProps.options.useInlineWrapper) {
-      return createMobileInlineDomRef();
-    }
-
     return super.createDomRef();
   }
 
@@ -80,9 +75,7 @@ export class StatusNodeView extends ReactNodeView {
       localId,
       style
     } = this.node.attrs;
-    return /*#__PURE__*/React.createElement(InlineNodeWrapper, {
-      useInlineWrapper: options && options.useInlineWrapper
-    }, options && options.allowZeroWidthSpaceAfter && ZERO_WIDTH_SPACE, /*#__PURE__*/React.createElement(IntlStatusContainerView, {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, options && options.allowZeroWidthSpaceAfter && ZERO_WIDTH_SPACE, /*#__PURE__*/React.createElement(IntlStatusContainerView, {
       view: this.view,
       text: text,
       color: color,

package/dist/es2019/plugins/status/plugin.js

@@ -1,10 +1,11 @@
-import { NodeSelection, Plugin, TextSelection } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { NodeSelection, TextSelection } from 'prosemirror-state';
 import statusNodeView from './nodeviews/status';
 import { pluginKey } from './plugin-key';
 import { isEmptyStatus, mayGetStatusAtSelection } from './utils';
 export { pluginKey, pluginKeyName } from './plugin-key';
 
-const createPlugin = (dispatch, portalProviderAPI, eventDispatcher, options) => new Plugin({
+const createPlugin = (dispatch, portalProviderAPI, eventDispatcher, options) => new SafePlugin({
   state: {
     init: () => ({
       isNew: false,

package/dist/es2019/plugins/status/ui/statusPicker.js

@@ -203,8 +203,7 @@ export class StatusPickerWithoutAnalytcs extends React.Component {
     } = this.props;
     const {
       color,
-      text,
-      localId
+      text
     } = this.state;
     return target && /*#__PURE__*/React.createElement(PopupWithListeners, {
       target: target,
@@ -222,8 +221,7 @@ export class StatusPickerWithoutAnalytcs extends React.Component {
       onColorClick: this.onColorClick,
       onColorHover: this.onColorHover,
       onTextChanged: this.onTextChanged,
-      onEnter: this.onEnter,
-      localId: localId
+      onEnter: this.onEnter
     })));
   }
 

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

@@ -263,8 +263,19 @@ export const moveCursorBackward = (state, dispatch) => {
   // it doesn't join node before (last cell) with node after (content after the cursor)
   // due to ridiculous amount of PM code that would have been required to overwrite
 
+  tr.setSelection(new TextSelection(state.doc.resolve(pos))); // if we are inside an empty paragraph not at the end of the doc we delete it
+
+  const cursorNode = $cursor.node();
+  const docEnd = state.doc.content.size;
+  const paragraphWrapStart = $cursor.pos - 1;
+  const paragraphWrapEnd = $cursor.pos + 1;
+
+  if (cursorNode.content.size === 0 && $cursor.pos + 1 !== docEnd) {
+    tr.delete(paragraphWrapStart, paragraphWrapEnd);
+  }
+
   if (dispatch) {
-    dispatch(tr.setSelection(new TextSelection(state.doc.resolve(pos))));
+    dispatch(tr);
   }
 
   return true;

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

@@ -220,7 +220,8 @@ const tablesPlugin = options => ({
           targetRef: tableWrapperTarget,
           layout: layout,
           isResizing: !!resizingPluginState && !!resizingPluginState.dragging,
-          tableWidth: tableRenderOptimization ? tableWidth : undefined
+          tableWidth: tableRenderOptimization ? tableWidth : undefined,
+          stickyHeader: stickyHeader
         }));
       }
     }));

package/dist/es2019/plugins/table/nodeviews/TableComponent.js

@@ -26,22 +26,6 @@ const isIE11 = browser.ie_version === 11;
 
 const NOOP = () => undefined;
 
-// in Chrome, if none of the parent elements
-// have content, then it will auto-scroll the container
-// which interferes with us applying padding to the
-// sticky header to make up for us taking it out of
-// the layout flow.
-//
-// this is only an issue when scrolling down the
-// page without row controls active, and doesn't
-// occur in other browsers afaik
-const FloatingPlaceholder = () => /*#__PURE__*/React.createElement("div", {
-  style: {
-    position: 'absolute',
-    top: '30px'
-  }
-}, ' ');
-
 class TableComponent extends React.Component {
   constructor(props) {
     super(props);
@@ -547,7 +531,7 @@ class TableComponent extends React.Component {
       "data-layout": node.attrs.layout
     }, stickyHeadersOptimization && /*#__PURE__*/React.createElement("div", {
       className: ClassName.TABLE_STICKY_SENTINEL_TOP
-    }), /*#__PURE__*/React.createElement(FloatingPlaceholder, null), allowControls && (!isLoading || initialRenderOptimization) && rowControls, /*#__PURE__*/React.createElement("div", {
+    }), allowControls && (!isLoading || initialRenderOptimization) && rowControls, /*#__PURE__*/React.createElement("div", {
       style: shadowStyle(showBeforeShadow),
       className: ClassName.TABLE_LEFT_SHADOW
     }), this.state.stickyHeader && /*#__PURE__*/React.createElement("div", {

package/dist/es2019/plugins/table/pm-plugins/decorations/plugin.js

@@ -1,4 +1,5 @@
-import { Plugin, PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
 import { DecorationSet } from 'prosemirror-view';
 import { pluginKey as tablePluginKey } from '../plugin-factory';
@@ -25,7 +26,7 @@ export const handleDocOrSelectionChanged = (tr, decorationSet, oldState) => {
   return decorationSet;
 };
 export const createPlugin = () => {
-  return new Plugin({
+  return new SafePlugin({
     state: {
       init: () => DecorationSet.empty,
       apply: (tr, decorationSet, oldState) => {

package/dist/es2019/plugins/table/pm-plugins/main.js

@@ -1,4 +1,4 @@
-import { Plugin } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { findParentDomRefOfType, findParentNodeOfType } from 'prosemirror-utils';
 import { findTable } from '@atlaskit/editor-tables/utils';
 import { browser } from '@atlaskit/editor-common/utils';
@@ -50,7 +50,7 @@ export const createPlugin = (dispatchAnalyticsEvent, dispatch, portalProviderAPI
   } : {}; // Used to prevent invalid table cell spans being reported more than once per editor/document
 
   const invalidTableIds = [];
-  return new Plugin({
+  return new SafePlugin({
     state: state,
     key: pluginKey,
     appendTransaction: (transactions, oldState, newState) => {

package/dist/es2019/plugins/table/pm-plugins/safari-delayed-dom-selection-syncing-workaround.js

@@ -1,4 +1,5 @@
-import { PluginKey, Plugin } from 'prosemirror-state';
+import { PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 export const tableSafariDelayedDomSelectionSyncingWorkaroundKey = new PluginKey('tableSafariDelayedDomSelectionSyncingWorkaround');
 export const createPlugin = () => {
   // From a review of the prosemirror-view source code,
@@ -11,7 +12,7 @@ export const createPlugin = () => {
   // Because we are manually wiping the view.mouseDown,
   // we manage this custom cleanup ourselves
   let prevMouseDownDone = null;
-  return new Plugin({
+  return new SafePlugin({
     key: tableSafariDelayedDomSelectionSyncingWorkaroundKey,
     props: {
       handleDOMEvents: {