@atlaskit/editor-core 172.1.1 → 172.2.0

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

@@ -2,11 +2,7 @@ import { TextSelection, Selection } from 'prosemirror-state';
 import { TableMap } from '@atlaskit/editor-tables/table-map';
 import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
 import { findTable, isTableSelected } from '@atlaskit/editor-tables/utils';
-import { GapCursorSelection, Side } from '../../selection/gap-cursor-selection';
-import { setSelectionRelativeToNode } from '../../selection/commands';
-import { RelativeSelectionPos } from '../../selection/types';
-import { getPluginState as getSelectionPluginState } from '../../selection/plugin-factory';
-import { isSelectionAtStartOfNode, isSelectionAtEndOfNode } from '../../../utils/selection';
+import { RelativeSelectionPos, GapCursorSelection, Side, isSelectionAtStartOfNode, isSelectionAtEndOfNode } from '@atlaskit/editor-common/selection';
 export var TableSelectionDirection;
 
 (function (TableSelectionDirection) {
@@ -14,200 +10,220 @@ export var TableSelectionDirection;
   TableSelectionDirection["BottomToTop"] = "BottomToTop";
 })(TableSelectionDirection || (TableSelectionDirection = {}));
 
-export var arrowLeftFromTable = function arrowLeftFromTable(state, dispatch) {
-  var selection = state.selection;
-
-  if (selection instanceof CellSelection) {
-    return arrowLeftFromCellSelection(selection)(state, dispatch);
-  } else if (selection instanceof GapCursorSelection) {
-    return arrowLeftFromGapCursor(selection)(state, dispatch);
-  } else if (selection instanceof TextSelection) {
-    return arrowLeftFromText(selection)(state, dispatch);
-  }
+export var arrowLeftFromTable = function arrowLeftFromTable(editorSelectionAPI) {
+  return function () {
+    return function (state, dispatch) {
+      var selection = state.selection;
+
+      if (selection instanceof CellSelection) {
+        return arrowLeftFromCellSelection(editorSelectionAPI)(selection)(state, dispatch);
+      } else if (selection instanceof GapCursorSelection) {
+        return arrowLeftFromGapCursor(editorSelectionAPI)(selection)(state, dispatch);
+      } else if (selection instanceof TextSelection) {
+        return arrowLeftFromText(editorSelectionAPI)(selection)(state, dispatch);
+      }
 
-  return false;
+      return false;
+    };
+  };
 };
-export var arrowRightFromTable = function arrowRightFromTable(state, dispatch) {
-  var selection = state.selection;
-
-  if (selection instanceof CellSelection) {
-    return arrowRightFromCellSelection(selection)(state, dispatch);
-  } else if (selection instanceof GapCursorSelection) {
-    return arrowRightFromGapCursor(selection)(state, dispatch);
-  } else if (selection instanceof TextSelection) {
-    return arrowRightFromText(selection)(state, dispatch);
-  }
-
-  return false;
+export var arrowRightFromTable = function arrowRightFromTable(editorSelectionAPI) {
+  return function () {
+    return function (state, dispatch) {
+      var selection = state.selection;
+
+      if (selection instanceof CellSelection) {
+        return arrowRightFromCellSelection(editorSelectionAPI)(selection)(state, dispatch);
+      } else if (selection instanceof GapCursorSelection) {
+        return arrowRightFromGapCursor(editorSelectionAPI)(selection)(state, dispatch);
+      } else if (selection instanceof TextSelection) {
+        return arrowRightFromText(editorSelectionAPI)(selection)(state, dispatch);
+      }
+
+      return false;
+    };
+  };
 };
 
-var arrowLeftFromCellSelection = function arrowLeftFromCellSelection(selection) {
-  return function (state, dispatch) {
-    if (isTableSelected(state.selection)) {
-      var _getSelectionPluginSt = getSelectionPluginState(state),
-          selectionRelativeToNode = _getSelectionPluginSt.selectionRelativeToNode;
-
-      if (selectionRelativeToNode === RelativeSelectionPos.Start) {
-        // we have full table cell selection and want to set gap cursor selection before table
-        return setGapCursorBeforeTable()(state, dispatch);
-      } else if (selectionRelativeToNode === RelativeSelectionPos.End) {
-        // we have full table cell selection and want to set selection at end of last cell
-        return setSelectionAtEndOfLastCell(selection)(state, dispatch);
-      } else if (selectionRelativeToNode === undefined) {
-        // we have full table cell selection and want to set selection at start of first cell
-        return setSelectionAtStartOfFirstCell(selection, RelativeSelectionPos.Before)(state, dispatch);
+var arrowLeftFromCellSelection = function arrowLeftFromCellSelection(editorSelectionAPI) {
+  return function (selection) {
+    return function (state, dispatch) {
+      if (isTableSelected(state.selection) && editorSelectionAPI) {
+        var _editorSelectionAPI$g = editorSelectionAPI.getSelectionPluginState(state),
+            selectionRelativeToNode = _editorSelectionAPI$g.selectionRelativeToNode;
+
+        if (selectionRelativeToNode === RelativeSelectionPos.Start) {
+          // we have full table cell selection and want to set gap cursor selection before table
+          return setGapCursorBeforeTable(editorSelectionAPI)()(state, dispatch);
+        } else if (selectionRelativeToNode === RelativeSelectionPos.End) {
+          // we have full table cell selection and want to set selection at end of last cell
+          return setSelectionAtEndOfLastCell(editorSelectionAPI)(selection)(state, dispatch);
+        } else if (selectionRelativeToNode === undefined) {
+          // we have full table cell selection and want to set selection at start of first cell
+          return setSelectionAtStartOfFirstCell(editorSelectionAPI)(selection, RelativeSelectionPos.Before)(state, dispatch);
+        }
       }
-    }
 
-    return false;
+      return false;
+    };
   };
 };
 
-var arrowRightFromCellSelection = function arrowRightFromCellSelection(selection) {
-  return function (state, dispatch) {
-    if (isTableSelected(state.selection)) {
-      var _getSelectionPluginSt2 = getSelectionPluginState(state),
-          selectionRelativeToNode = _getSelectionPluginSt2.selectionRelativeToNode;
-
-      if (selectionRelativeToNode === RelativeSelectionPos.Start) {
-        // we have full table cell selection and want to set selection at start of first cell
-        return setSelectionAtStartOfFirstCell(selection)(state, dispatch);
-      } else if (selectionRelativeToNode === RelativeSelectionPos.End || selectionRelativeToNode === undefined) {
-        // we have full table cell selection and want to set gap cursor selection after table
-        return setGapCursorAfterTable()(state, dispatch);
+var arrowRightFromCellSelection = function arrowRightFromCellSelection(editorSelectionAPI) {
+  return function (selection) {
+    return function (state, dispatch) {
+      if (isTableSelected(state.selection) && editorSelectionAPI) {
+        var _editorSelectionAPI$g2 = editorSelectionAPI.getSelectionPluginState(state),
+            selectionRelativeToNode = _editorSelectionAPI$g2.selectionRelativeToNode;
+
+        if (selectionRelativeToNode === RelativeSelectionPos.Start) {
+          // we have full table cell selection and want to set selection at start of first cell
+          return setSelectionAtStartOfFirstCell(editorSelectionAPI)(selection)(state, dispatch);
+        } else if (selectionRelativeToNode === RelativeSelectionPos.End || selectionRelativeToNode === undefined) {
+          // we have full table cell selection and want to set gap cursor selection after table
+          return setGapCursorAfterTable(editorSelectionAPI)()(state, dispatch);
+        }
       }
-    }
 
-    return false;
+      return false;
+    };
   };
 };
 
-var arrowLeftFromGapCursor = function arrowLeftFromGapCursor(selection) {
-  return function (state, dispatch) {
-    var doc = state.doc;
-    var $from = selection.$from,
-        from = selection.from,
-        side = selection.side;
-
-    if (side === Side.RIGHT) {
-      if ($from.nodeBefore && $from.nodeBefore.type.name === 'table') {
-        // we have a gap cursor after a table node and want to set a full table cell selection
-        return selectFullTable({
-          node: $from.nodeBefore,
-          startPos: doc.resolve(from - 1).start($from.depth + 1),
-          dir: TableSelectionDirection.TopToBottom
-        })(state, dispatch);
+var arrowLeftFromGapCursor = function arrowLeftFromGapCursor(editorSelectionAPI) {
+  return function (selection) {
+    return function (state, dispatch) {
+      var doc = state.doc;
+      var $from = selection.$from,
+          from = selection.from,
+          side = selection.side;
+
+      if (side === Side.RIGHT) {
+        if ($from.nodeBefore && $from.nodeBefore.type.name === 'table') {
+          // we have a gap cursor after a table node and want to set a full table cell selection
+          return selectFullTable(editorSelectionAPI)({
+            node: $from.nodeBefore,
+            startPos: doc.resolve(from - 1).start($from.depth + 1),
+            dir: TableSelectionDirection.TopToBottom
+          })(state, dispatch);
+        }
+      } else if (side === Side.LEFT) {
+        var table = findTable(selection);
+
+        if (table && isSelectionAtStartOfTable($from, selection) && editorSelectionAPI) {
+          var _editorSelectionAPI$g3 = editorSelectionAPI.getSelectionPluginState(state),
+              selectionRelativeToNode = _editorSelectionAPI$g3.selectionRelativeToNode;
+
+          if (selectionRelativeToNode === RelativeSelectionPos.Before) {
+            // we have a gap cursor at start of first table cell and want to set a gap cursor selection before table
+            return setGapCursorBeforeTable(editorSelectionAPI)()(state, dispatch);
+          } else {
+            // we have a gap cursor at start of first table cell and want to set a full table cell selection
+            return selectFullTable(editorSelectionAPI)({
+              node: table.node,
+              startPos: table.start,
+              dir: TableSelectionDirection.BottomToTop
+            })(state, dispatch);
+          }
+        }
       }
-    } else if (side === Side.LEFT) {
-      var table = findTable(selection);
 
-      if (table && isSelectionAtStartOfTable($from, selection)) {
-        var _getSelectionPluginSt3 = getSelectionPluginState(state),
-            selectionRelativeToNode = _getSelectionPluginSt3.selectionRelativeToNode;
+      return false;
+    };
+  };
+};
 
-        if (selectionRelativeToNode === RelativeSelectionPos.Before) {
-          // we have a gap cursor at start of first table cell and want to set a gap cursor selection before table
-          return setGapCursorBeforeTable()(state, dispatch);
-        } else {
-          // we have a gap cursor at start of first table cell and want to set a full table cell selection
-          return selectFullTable({
+var arrowRightFromGapCursor = function arrowRightFromGapCursor(editorSelectionAPI) {
+  return function (selection) {
+    return function (state, dispatch) {
+      var $from = selection.$from,
+          from = selection.from,
+          $to = selection.$to,
+          side = selection.side;
+
+      if (side === Side.LEFT) {
+        if ($from.nodeAfter && $from.nodeAfter.type.name === 'table') {
+          // we have a gap cursor before a table node and want to set a full table cell selection
+          return selectFullTable(editorSelectionAPI)({
+            node: $from.nodeAfter,
+            startPos: from + 1,
+            dir: TableSelectionDirection.BottomToTop
+          })(state, dispatch);
+        }
+      } else if (side === Side.RIGHT) {
+        var table = findTable(selection);
+
+        if (table && isSelectionAtEndOfTable($to, selection)) {
+          // we have a gap cursor at end of last table cell and want to set a full table cell selection
+          return selectFullTable(editorSelectionAPI)({
             node: table.node,
             startPos: table.start,
-            dir: TableSelectionDirection.BottomToTop
+            dir: TableSelectionDirection.TopToBottom
           })(state, dispatch);
         }
       }
-    }
 
-    return false;
+      return false;
+    };
   };
 };
 
-var arrowRightFromGapCursor = function arrowRightFromGapCursor(selection) {
-  return function (state, dispatch) {
-    var $from = selection.$from,
-        from = selection.from,
-        $to = selection.$to,
-        side = selection.side;
-
-    if (side === Side.LEFT) {
-      if ($from.nodeAfter && $from.nodeAfter.type.name === 'table') {
-        // we have a gap cursor before a table node and want to set a full table cell selection
-        return selectFullTable({
-          node: $from.nodeAfter,
-          startPos: from + 1,
-          dir: TableSelectionDirection.BottomToTop
-        })(state, dispatch);
-      }
-    } else if (side === Side.RIGHT) {
+var arrowLeftFromText = function arrowLeftFromText(editorSelectionAPI) {
+  return function (selection) {
+    return function (state, dispatch) {
       var table = findTable(selection);
 
-      if (table && isSelectionAtEndOfTable($to, selection)) {
-        // we have a gap cursor at end of last table cell and want to set a full table cell selection
-        return selectFullTable({
-          node: table.node,
-          startPos: table.start,
-          dir: TableSelectionDirection.TopToBottom
-        })(state, dispatch);
+      if (table) {
+        var $from = selection.$from;
+
+        if (isSelectionAtStartOfTable($from, selection) && $from.parent.type.name === 'paragraph' && $from.depth === table.depth + 3 && // + 3 for: row, cell & paragraph nodes
+        editorSelectionAPI) {
+          var _editorSelectionAPI$g4 = editorSelectionAPI.getSelectionPluginState(state),
+              selectionRelativeToNode = _editorSelectionAPI$g4.selectionRelativeToNode;
+
+          if (selectionRelativeToNode === RelativeSelectionPos.Before) {
+            // we have a text selection at start of first table cell, directly inside a top level paragraph,
+            // and want to set gap cursor selection before table
+            return setGapCursorBeforeTable(editorSelectionAPI)()(state, dispatch);
+          } else {
+            // we have a text selection at start of first table cell, directly inside a top level paragraph,
+            // and want to set a full table cell selection
+            return selectFullTable(editorSelectionAPI)({
+              node: table.node,
+              startPos: table.start,
+              dir: TableSelectionDirection.BottomToTop
+            })(state, dispatch);
+          }
+        }
       }
-    }
 
-    return false;
+      return false;
+    };
   };
 };
 
-var arrowLeftFromText = function arrowLeftFromText(selection) {
-  return function (state, dispatch) {
-    var table = findTable(selection);
-
-    if (table) {
-      var $from = selection.$from;
+var arrowRightFromText = function arrowRightFromText(editorSelectionAPI) {
+  return function (selection) {
+    return function (state, dispatch) {
+      var table = findTable(selection);
 
-      if (isSelectionAtStartOfTable($from, selection) && $from.parent.type.name === 'paragraph' && $from.depth === table.depth + 3 // + 3 for: row, cell & paragraph nodes
-      ) {
-        var _getSelectionPluginSt4 = getSelectionPluginState(state),
-            selectionRelativeToNode = _getSelectionPluginSt4.selectionRelativeToNode;
+      if (table) {
+        var $to = selection.$to;
 
-        if (selectionRelativeToNode === RelativeSelectionPos.Before) {
-          // we have a text selection at start of first table cell, directly inside a top level paragraph,
-          // and want to set gap cursor selection before table
-          return setGapCursorBeforeTable()(state, dispatch);
-        } else {
-          // we have a text selection at start of first table cell, directly inside a top level paragraph,
+        if (isSelectionAtEndOfTable($to, selection) && $to.parent.type.name === 'paragraph' && $to.depth === table.depth + 3 // + 3 for: row, cell & paragraph nodes
+        ) {
+          // we have a text selection at end of last table cell, directly inside a top level paragraph,
           // and want to set a full table cell selection
-          return selectFullTable({
+          return selectFullTable(editorSelectionAPI)({
             node: table.node,
             startPos: table.start,
-            dir: TableSelectionDirection.BottomToTop
+            dir: TableSelectionDirection.TopToBottom
           })(state, dispatch);
         }
       }
-    }
 
-    return false;
-  };
-};
-
-var arrowRightFromText = function arrowRightFromText(selection) {
-  return function (state, dispatch) {
-    var table = findTable(selection);
-
-    if (table) {
-      var $to = selection.$to;
-
-      if (isSelectionAtEndOfTable($to, selection) && $to.parent.type.name === 'paragraph' && $to.depth === table.depth + 3 // + 3 for: row, cell & paragraph nodes
-      ) {
-        // we have a text selection at end of last table cell, directly inside a top level paragraph,
-        // and want to set a full table cell selection
-        return selectFullTable({
-          node: table.node,
-          startPos: table.start,
-          dir: TableSelectionDirection.TopToBottom
-        })(state, dispatch);
-      }
-    }
-
-    return false;
+      return false;
+    };
   };
 };
 /**
@@ -218,89 +234,161 @@ var arrowRightFromText = function arrowRightFromText(selection) {
  */
 
 
-var selectFullTable = function selectFullTable(_ref) {
-  var node = _ref.node,
-      startPos = _ref.startPos,
-      dir = _ref.dir;
-  return function (state, dispatch) {
-    var doc = state.doc;
-
-    var _TableMap$get = TableMap.get(node),
-        map = _TableMap$get.map;
+var selectFullTable = function selectFullTable(editorSelectionAPI) {
+  return function (_ref) {
+    var node = _ref.node,
+        startPos = _ref.startPos,
+        dir = _ref.dir;
+    return function (state, dispatch) {
+      var doc = state.doc;
+
+      var _TableMap$get = TableMap.get(node),
+          map = _TableMap$get.map;
+
+      var $firstCell = doc.resolve(startPos + map[0]);
+      var $lastCell = doc.resolve(startPos + map[map.length - 1]);
+      var fullTableSelection;
+      var selectionRelativeToNode;
+
+      if (dir === TableSelectionDirection.TopToBottom) {
+        fullTableSelection = new CellSelection($firstCell, $lastCell);
+        selectionRelativeToNode = RelativeSelectionPos.End;
+      } else {
+        fullTableSelection = new CellSelection($lastCell, $firstCell);
+        selectionRelativeToNode = RelativeSelectionPos.Start;
+      }
 
-    var $firstCell = doc.resolve(startPos + map[0]);
-    var $lastCell = doc.resolve(startPos + map[map.length - 1]);
-    var fullTableSelection;
-    var selectionRelativeToNode;
+      if (editorSelectionAPI) {
+        var tr = editorSelectionAPI.setSelectionRelativeToNode({
+          selectionRelativeToNode: selectionRelativeToNode,
+          selection: fullTableSelection
+        })(state);
 
-    if (dir === TableSelectionDirection.TopToBottom) {
-      fullTableSelection = new CellSelection($firstCell, $lastCell);
-      selectionRelativeToNode = RelativeSelectionPos.End;
-    } else {
-      fullTableSelection = new CellSelection($lastCell, $firstCell);
-      selectionRelativeToNode = RelativeSelectionPos.Start;
-    }
+        if (dispatch) {
+          dispatch(tr);
+          return true;
+        }
+      }
 
-    return setSelectionRelativeToNode(selectionRelativeToNode, fullTableSelection)(state, dispatch);
+      return false;
+    };
   };
 };
 
-var setSelectionAtStartOfFirstCell = function setSelectionAtStartOfFirstCell(selection, selectionRelativeToNode) {
-  return function (state, dispatch) {
-    var $anchorCell = selection.$anchorCell,
-        $headCell = selection.$headCell;
-    var $firstCell = $anchorCell.pos < $headCell.pos ? $anchorCell : $headCell;
-    var $firstPosInsideCell = state.doc.resolve($firstCell.pos + 1); // check if first pos should have a gap cursor, otherwise find closest text selection
+var setSelectionAtStartOfFirstCell = function setSelectionAtStartOfFirstCell(editorSelectionAPI) {
+  return function (selection, selectionRelativeToNode) {
+    return function (state, dispatch) {
+      var $anchorCell = selection.$anchorCell,
+          $headCell = selection.$headCell;
+      var $firstCell = $anchorCell.pos < $headCell.pos ? $anchorCell : $headCell;
+      var $firstPosInsideCell = state.doc.resolve($firstCell.pos + 1); // check if first pos should have a gap cursor, otherwise find closest text selection
+
+      var selectionAtStartOfCell = GapCursorSelection.valid($firstPosInsideCell) ? new GapCursorSelection($firstPosInsideCell, Side.LEFT) : Selection.findFrom($firstPosInsideCell, 1);
+
+      if (editorSelectionAPI) {
+        var tr = editorSelectionAPI.setSelectionRelativeToNode({
+          selectionRelativeToNode: selectionRelativeToNode,
+          selection: selectionAtStartOfCell
+        })(state);
+
+        if (dispatch) {
+          dispatch(tr);
+          return true;
+        }
+      }
 
-    var selectionAtStartOfCell = GapCursorSelection.valid($firstPosInsideCell) ? new GapCursorSelection($firstPosInsideCell, Side.LEFT) : Selection.findFrom($firstPosInsideCell, 1);
-    return setSelectionRelativeToNode(selectionRelativeToNode, selectionAtStartOfCell)(state, dispatch);
+      return false;
+    };
   };
 };
 
-var setSelectionAtEndOfLastCell = function setSelectionAtEndOfLastCell(selection, selectionRelativeToNode) {
-  return function (state, dispatch) {
-    var $anchorCell = selection.$anchorCell,
-        $headCell = selection.$headCell;
-    var $lastCell = $anchorCell.pos > $headCell.pos ? $anchorCell : $headCell;
-    var lastPosInsideCell = $lastCell.pos + ($lastCell.nodeAfter ? $lastCell.nodeAfter.content.size : 0) + 1;
-    var $lastPosInsideCell = state.doc.resolve(lastPosInsideCell); // check if last pos should have a gap cursor, otherwise find closest text selection
+var setSelectionAtEndOfLastCell = function setSelectionAtEndOfLastCell(editorSelectionAPI) {
+  return function (selection, selectionRelativeToNode) {
+    return function (state, dispatch) {
+      var $anchorCell = selection.$anchorCell,
+          $headCell = selection.$headCell;
+      var $lastCell = $anchorCell.pos > $headCell.pos ? $anchorCell : $headCell;
+      var lastPosInsideCell = $lastCell.pos + ($lastCell.nodeAfter ? $lastCell.nodeAfter.content.size : 0) + 1;
+      var $lastPosInsideCell = state.doc.resolve(lastPosInsideCell); // check if last pos should have a gap cursor, otherwise find closest text selection
+
+      var selectionAtEndOfCell = GapCursorSelection.valid($lastPosInsideCell) ? new GapCursorSelection($lastPosInsideCell, Side.RIGHT) : Selection.findFrom($lastPosInsideCell, -1);
+
+      if (editorSelectionAPI) {
+        var tr = editorSelectionAPI.setSelectionRelativeToNode({
+          selectionRelativeToNode: selectionRelativeToNode,
+          selection: selectionAtEndOfCell
+        })(state);
+
+        if (dispatch) {
+          dispatch(tr);
+          return true;
+        }
+      }
 
-    var selectionAtEndOfCell = GapCursorSelection.valid($lastPosInsideCell) ? new GapCursorSelection($lastPosInsideCell, Side.RIGHT) : Selection.findFrom($lastPosInsideCell, -1);
-    return setSelectionRelativeToNode(selectionRelativeToNode, selectionAtEndOfCell)(state, dispatch);
+      return false;
+    };
   };
 };
 
-var setGapCursorBeforeTable = function setGapCursorBeforeTable() {
-  return function (state, dispatch) {
-    var table = findTable(state.selection);
+var setGapCursorBeforeTable = function setGapCursorBeforeTable(editorSelectionAPI) {
+  return function () {
+    return function (state, dispatch) {
+      var table = findTable(state.selection);
+
+      if (table) {
+        var $beforeTablePos = state.doc.resolve(table.pos);
+
+        if (GapCursorSelection.valid($beforeTablePos)) {
+          var selectionBeforeTable = new GapCursorSelection($beforeTablePos, Side.LEFT);
 
-    if (table) {
-      var $beforeTablePos = state.doc.resolve(table.pos);
+          if (editorSelectionAPI) {
+            var tr = editorSelectionAPI.setSelectionRelativeToNode({
+              selectionRelativeToNode: undefined,
+              selection: selectionBeforeTable
+            })(state);
 
-      if (GapCursorSelection.valid($beforeTablePos)) {
-        var selectionBeforeTable = new GapCursorSelection($beforeTablePos, Side.LEFT);
-        return setSelectionRelativeToNode(undefined, selectionBeforeTable)(state, dispatch);
+            if (dispatch) {
+              dispatch(tr);
+              return true;
+            }
+          }
+        }
       }
-    }
 
-    return false;
+      return false;
+    };
   };
 };
 
-var setGapCursorAfterTable = function setGapCursorAfterTable() {
-  return function (state, dispatch) {
-    var table = findTable(state.selection);
+var setGapCursorAfterTable = function setGapCursorAfterTable(editorSelectionAPI) {
+  return function () {
+    return function (state, dispatch) {
+      var table = findTable(state.selection);
+
+      if (table) {
+        var $afterTablePos = state.doc.resolve(table.pos + table.node.nodeSize);
+
+        if (GapCursorSelection.valid($afterTablePos)) {
+          var selectionAfterTable = new GapCursorSelection($afterTablePos, Side.RIGHT);
 
-    if (table) {
-      var $afterTablePos = state.doc.resolve(table.pos + table.node.nodeSize);
+          if (editorSelectionAPI) {
+            var tr = editorSelectionAPI.setSelectionRelativeToNode({
+              selectionRelativeToNode: undefined,
+              selection: selectionAfterTable
+            })(state);
 
-      if (GapCursorSelection.valid($afterTablePos)) {
-        var selectionAfterTable = new GapCursorSelection($afterTablePos, Side.RIGHT);
-        return setSelectionRelativeToNode(undefined, selectionAfterTable)(state, dispatch);
+            if (dispatch) {
+              dispatch(tr);
+              return true;
+            }
+          }
+
+          return false;
+        }
       }
-    }
 
-    return false;
+      return false;
+    };
   };
 };