@seafile/sdoc-editor 2.0.81 → 2.0.83

package/dist/extension/plugins/table/plugin.js

@@ -0,0 +1,603 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _constants = require("../../../constants");
+var _eventBus = _interopRequireDefault(require("../../../utils/event-bus"));
+var _objectUtils = _interopRequireDefault(require("../../../utils/object-utils"));
+var _constants2 = require("../../constants");
+var _core = require("../../core");
+var _constants3 = require("./constants");
+var _helpers = require("./helpers");
+var withTable = function withTable(editor) {
+  var insertBreak = editor.insertBreak,
+    deleteBackward = editor.deleteBackward,
+    deleteForward = editor.deleteForward,
+    insertData = editor.insertData,
+    selectAll = editor.selectAll,
+    normalizeNode = editor.normalizeNode,
+    handleTab = editor.handleTab,
+    getFragment = editor.getFragment,
+    setFragmentData = editor.setFragmentData,
+    insertFragment = editor.insertFragment,
+    deleteFragment = editor.deleteFragment;
+  var newEditor = editor;
+  newEditor.tableSelectedRange = _constants3.EMPTY_SELECTED_RANGE;
+  var eventBus = _eventBus["default"].getInstance();
+  newEditor.tableOnKeyDown = function (event) {
+    // Handle special keyboard events
+    if ((0, _isHotkey["default"])('mod+a', event)) {
+      event.preventDefault();
+      var _getSelectedInfo = (0, _helpers.getSelectedInfo)(newEditor),
+        table = _getSelectedInfo.table,
+        tableSize = _getSelectedInfo.tableSize;
+      var allTableRange = {
+        minRowIndex: 0,
+        maxRowIndex: tableSize[0] - 1,
+        minColIndex: 0,
+        maxColIndex: tableSize[1] - 1
+      };
+      newEditor.tableSelectedRange = allTableRange;
+      eventBus.dispatch(_constants.INTERNAL_EVENT.SET_TABLE_SELECT_RANGE, table, allTableRange);
+    }
+    if ((0, _isHotkey["default"])(_constants2.KEYBOARD.UP, event)) {
+      (0, _helpers.focusCell)(newEditor, event, _constants2.KEYBOARD.UP);
+    }
+    if ((0, _isHotkey["default"])(_constants2.KEYBOARD.RIGHT, event)) {
+      (0, _helpers.focusCell)(newEditor, event, _constants2.KEYBOARD.RIGHT);
+    }
+    if ((0, _isHotkey["default"])(_constants2.KEYBOARD.DOWN, event)) {
+      (0, _helpers.focusCell)(newEditor, event, _constants2.KEYBOARD.DOWN);
+    }
+    if ((0, _isHotkey["default"])(_constants2.KEYBOARD.LEFT, event)) {
+      (0, _helpers.focusCell)(newEditor, event, _constants2.KEYBOARD.LEFT);
+    }
+    if ((0, _isHotkey["default"])('tab', event)) {
+      event.preventDefault();
+    }
+    if ((0, _isHotkey["default"])('shift+enter', event)) {
+      event.preventDefault();
+      var _getAboveBlockNode = (0, _core.getAboveBlockNode)(newEditor),
+        _getAboveBlockNode2 = (0, _slicedToArray2["default"])(_getAboveBlockNode, 2),
+        tablePath = _getAboveBlockNode2[1];
+      var focusPath = [tablePath[0] + 1];
+      var focusPoint = _slate.Editor.start(newEditor, focusPath);
+      (0, _core.focusEditor)(newEditor, focusPoint);
+    }
+  };
+  newEditor.insertBreak = function () {
+    var selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants2.ELEMENT_TYPE.TABLE);
+    if (selectedNode != null) {
+      newEditor.insertText('\n'); // If table is selected, wrap in cell
+      return;
+    }
+    insertBreak();
+  };
+  newEditor.deleteBackward = function (unit) {
+    var deleteType = (0, _helpers.deleteHandler)(newEditor);
+    if (deleteType === 'table') {
+      var _getSelectedInfo2 = (0, _helpers.getSelectedInfo)(editor),
+        tablePath = _getSelectedInfo2.tablePath;
+      (0, _helpers.removeTable)(editor, tablePath);
+      return;
+    }
+
+    // range selection delete
+    if (deleteType === 'range') {
+      (0, _helpers.deleteTableRangeData)(newEditor);
+      return;
+    }
+    if (deleteType === 'default') return;
+    var selection = newEditor.selection;
+    if (selection) {
+      var before = _slate.Editor.before(newEditor, selection);
+      if (before) {
+        var isTableOnBeforeLocation = (0, _helpers.isTableLocation)(newEditor, before);
+        var isTableOnCurSelection = (0, _helpers.isTableLocation)(newEditor, selection);
+        // If the current is not a table and the previous one is a table.
+        if (isTableOnBeforeLocation && !isTableOnCurSelection) {
+          var _Editor$nodes = _slate.Editor.nodes(editor, {
+              match: function match(n) {
+                return _slate.Element.isElement(n) && !_slate.Editor.parent(n, _slateReact.ReactEditor.findPath(editor, n))[1].length;
+              }
+            }),
+            _Editor$nodes2 = (0, _slicedToArray2["default"])(_Editor$nodes, 1),
+            currentNodeEntry = _Editor$nodes2[0];
+          if (!currentNodeEntry) return;
+          var _Array$from = Array.from(currentNodeEntry),
+            _Array$from2 = (0, _slicedToArray2["default"])(_Array$from, 2),
+            currentNode = _Array$from2[0],
+            currentPath = _Array$from2[1];
+
+          // If the current is paragraph.
+          if (currentNode.type === _constants2.PARAGRAPH) {
+            var path = before.path;
+            _slate.Transforms.select(editor, {
+              anchor: {
+                offset: 0,
+                path: [path[0], 0, 0, 0]
+              },
+              focus: {
+                offset: 0,
+                path: [path[0], 0, 0, 0]
+              }
+            });
+            var beforeTable = _slate.Editor.node(editor, [path[0]]);
+            var beforeRow = _slate.Editor.node(editor, [path[0], path[1]]);
+            var tableSize = [beforeTable[0].children.length, beforeRow[0].children.length];
+            var allTableRange = {
+              minRowIndex: 0,
+              maxRowIndex: tableSize[0] - 1,
+              minColIndex: 0,
+              maxColIndex: tableSize[1] - 1
+            };
+            newEditor.tableSelectedRange = allTableRange;
+            eventBus.dispatch(_constants.INTERNAL_EVENT.SET_TABLE_SELECT_RANGE, beforeTable[0], allTableRange);
+            return;
+          }
+
+          // If deleting node is empty check-list, order-list, unordered-list, change to paragraph
+          var transformTypes = [_constants2.CHECK_LIST_ITEM, _constants2.ORDERED_LIST, _constants2.UNORDERED_LIST];
+          if (transformTypes.includes(currentNode.type)) {
+            _slate.Transforms["delete"](newEditor, {
+              at: currentPath
+            });
+            _slate.Transforms.insertNodes(newEditor, (0, _core.generateEmptyElement)(_constants2.PARAGRAPH), {
+              at: currentPath
+            });
+            (0, _core.focusEditor)(editor, _slate.Editor.start(editor, currentPath));
+          }
+          return;
+        }
+      }
+    }
+    deleteBackward(unit);
+  };
+  newEditor.deleteFragment = function (unit) {
+    var selection = editor.selection;
+    if (!selection) {
+      return deleteFragment(unit);
+    }
+    var match = function match(n) {
+      return n.type === _constants2.TABLE;
+    };
+    if (_slate.Range.isRange(selection) && (0, _core.isRangeAcrossBlocks)(editor, {
+      at: selection,
+      match: match
+    })) {
+      var anchorEntry = (0, _core.getAboveBlockNode)(editor, {
+        at: selection.anchor,
+        match: match
+      });
+      if (anchorEntry) {
+        var columnLength = anchorEntry[0].columns.length;
+        var anchor = selection.anchor;
+        var isForward = _slate.Range.isForward(selection);
+        if (isForward) {
+          if (!(0, _core.isStartPoint)(editor, anchor, anchorEntry[1])) {
+            // delete table cells
+            var endPoint = (0, _core.getEndPoint)(editor, anchorEntry[1]);
+            (0, _helpers.deleteTableSelectCells)(editor, {
+              start: anchor.path,
+              end: endPoint.path,
+              columnLength: columnLength
+            });
+
+            // delete other module
+            var newAnchor = (0, _core.getStartPoint)(editor, _slate.Path.next(anchorEntry[1]));
+            _slate.Transforms["delete"](editor, {
+              at: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, selection), {}, {
+                anchor: newAnchor
+              })
+            });
+            (0, _core.focusEditor)(editor, newAnchor.path);
+            return;
+          }
+        } else {
+          if (!(0, _core.isEndPoint)(editor, anchor, anchorEntry[1])) {
+            // delete table cells
+            var startPoint = (0, _core.getStartPoint)(editor, anchorEntry[1]);
+            (0, _helpers.deleteTableSelectCells)(editor, {
+              start: startPoint.path,
+              end: anchor.path,
+              columnLength: columnLength
+            });
+
+            // delete other module
+            var _newAnchor = (0, _core.getEndPoint)(editor, _slate.Path.previous(anchorEntry[1]));
+            _slate.Transforms["delete"](editor, {
+              at: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, selection), {}, {
+                anchor: _newAnchor
+              })
+            });
+            (0, _core.focusEditor)(editor, _newAnchor.path);
+            return;
+          }
+        }
+      } else {
+        var focusEntry = (0, _core.getAboveBlockNode)(editor, {
+          at: selection.focus,
+          match: match
+        });
+        var _columnLength = focusEntry[0].columns.length;
+        if (focusEntry) {
+          var focus = selection.focus;
+          var _isForward = _slate.Range.isForward(selection);
+          if (_isForward) {
+            if (!(0, _core.isEndPoint)(editor, focus, focusEntry[1])) {
+              var _startPoint = (0, _core.getStartPoint)(editor, focusEntry[1]);
+              (0, _helpers.deleteTableSelectCells)(editor, {
+                start: _startPoint.path,
+                end: focus.path,
+                columnLength: _columnLength
+              });
+
+              // delete other module
+              var newFocus = (0, _core.getEndPoint)(editor, _slate.Path.previous(focusEntry[1]));
+              _slate.Transforms["delete"](editor, {
+                at: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, selection), {}, {
+                  focus: newFocus
+                })
+              });
+              (0, _core.focusEditor)(editor, focus.path);
+              return;
+            }
+          } else {
+            if (!(0, _core.isEndPoint)(editor, focus, focusEntry[1])) {
+              var _endPoint = (0, _core.getEndPoint)(editor, focusEntry[1]);
+              (0, _helpers.deleteTableSelectCells)(editor, {
+                start: focus.path,
+                end: _endPoint.path,
+                columnLength: _columnLength
+              });
+
+              // delete other module
+              var _newFocus = (0, _core.getStartPoint)(editor, _slate.Path.next(focusEntry[1]));
+              _slate.Transforms["delete"](editor, {
+                at: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, selection), {}, {
+                  focus: _newFocus
+                })
+              });
+              (0, _core.focusEditor)(editor, focus.path);
+              return;
+            }
+          }
+        }
+      }
+    }
+    if (_slate.Range.isRange(selection) && (0, _helpers.isAllInTable)(editor) && !(0, _helpers.isInTableSameCell)(editor)) {
+      var _getTopLevelBlockNode = (0, _core.getTopLevelBlockNode)(editor),
+        _getTopLevelBlockNode2 = (0, _slicedToArray2["default"])(_getTopLevelBlockNode, 1),
+        node = _getTopLevelBlockNode2[0];
+      if (_slate.Range.isRange(selection) && (node === null || node === void 0 ? void 0 : node.type) === _constants2.ELEMENT_TYPE.TABLE) {
+        newEditor.deleteBackward();
+        return;
+      }
+    }
+    deleteFragment(unit);
+  };
+  newEditor.deleteForward = function (unit) {
+    var nextNode = _slate.Editor.next(newEditor);
+    var newNodeParent = (0, _core.getParentNode)(newEditor.children, nextNode[0].id);
+    if (newNodeParent.type === _constants2.ELEMENT_TYPE.TABLE_CELL) return;
+    deleteForward(unit);
+  };
+  newEditor.getFragment = function () {
+    var selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants2.ELEMENT_TYPE.TABLE);
+    if (!selectedNode) {
+      return getFragment();
+    }
+    var tableSelectedRange = newEditor.tableSelectedRange;
+    if (_objectUtils["default"].isSameObject(tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
+      var fragment = getFragment();
+
+      // When a cell is selected, it should be converted to text
+      return [Object.freeze({
+        children: fragment[0].children[0].children[0]['children'],
+        id: fragment[0]['id'],
+        type: _constants2.ELEMENT_TYPE.PARAGRAPH
+      })];
+    }
+    var minColIndex = tableSelectedRange.minColIndex,
+      maxColIndex = tableSelectedRange.maxColIndex,
+      minRowIndex = tableSelectedRange.minRowIndex,
+      maxRowIndex = tableSelectedRange.maxRowIndex;
+    var rows = selectedNode.children;
+    var columns = selectedNode.columns;
+    var selectedRows = [];
+    var selectedColumns = [];
+    for (var i = minRowIndex; i <= maxRowIndex; i++) {
+      var row = rows[i];
+      var rowChildren = row.children;
+      var newRowChildren = [];
+      for (var j = minColIndex; j <= maxColIndex; j++) {
+        var column = rowChildren[j];
+        newRowChildren.push(column);
+      }
+      selectedRows.push((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, row), {}, {
+        children: newRowChildren
+      }));
+    }
+    for (var _j = minColIndex; _j <= maxColIndex; _j++) {
+      var _column = columns[_j];
+      selectedColumns.push(_column);
+    }
+    return [Object.freeze((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, selectedNode), {}, {
+      children: selectedRows,
+      columns: selectedColumns
+    }))];
+  };
+
+  // copy: mod + c
+  newEditor.setFragmentData = function (dataTransfer) {
+    var selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants2.ELEMENT_TYPE.TABLE);
+    if (!selectedNode) {
+      return setFragmentData(dataTransfer);
+    }
+    var tableSelectedRange = newEditor.tableSelectedRange;
+    if (_objectUtils["default"].isSameObject(tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
+      return setFragmentData(dataTransfer);
+    }
+    return (0, _helpers.setTableFragmentData)(newEditor, dataTransfer);
+  };
+  newEditor.cut = function (event) {
+    var selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants2.ELEMENT_TYPE.TABLE);
+    var tableSelectedRange = newEditor.tableSelectedRange;
+    if (selectedNode && !_objectUtils["default"].isSameObject(tableSelectedRange, _constants3.EMPTY_SELECTED_RANGE)) {
+      (0, _helpers.setTableFragmentData)(newEditor, event.clipboardData);
+      var deleteType = (0, _helpers.deleteHandler)(newEditor);
+      if (deleteType === 'table') {
+        var _getSelectedInfo3 = (0, _helpers.getSelectedInfo)(editor),
+          tablePath = _getSelectedInfo3.tablePath;
+        (0, _helpers.removeTable)(editor, tablePath);
+        return;
+      }
+
+      // range selection delete
+      if (deleteType === 'range') {
+        (0, _helpers.deleteTableRangeData)(newEditor);
+        return;
+      }
+      return;
+    }
+  };
+
+  // copy insert text
+  newEditor.insertData = function (data) {
+    var selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants2.ELEMENT_TYPE.TABLE_CELL);
+    if (!selectedNode) {
+      insertData(data);
+      return;
+    }
+    var fragment = data.getData("application/".concat(_constants2.CLIPBOARD_FORMAT_KEY));
+    if (fragment) {
+      var decoded = decodeURIComponent(window.atob(fragment));
+      var parsedData = JSON.parse(decoded);
+      if (Array.isArray(parsedData) && parsedData.some(function (item) {
+        return item.type === _constants2.ELEMENT_TYPE.TABLE;
+      })) {
+        var tableElement = parsedData.find(function (item) {
+          return item.type === _constants2.ELEMENT_TYPE.TABLE;
+        });
+        (0, _helpers.insertMultipleRowsAndColumns)(newEditor, tableElement.children, tableElement.columns);
+        return;
+      }
+    }
+    var text = data.getData('text/plain');
+    if (!text) return;
+    _slate.Editor.insertText(newEditor, text);
+  };
+  newEditor.insertFragment = function (data) {
+    if (data.type === _constants2.ELEMENT_TYPE.TABLE) {
+      _slate.Transforms.insertNodes(editor, data);
+      return;
+    }
+    return insertFragment(data);
+  };
+  newEditor.selectAll = function () {
+    var selection = newEditor.selection;
+    if (!selection) {
+      selectAll();
+      return;
+    }
+    var selectedCell = (0, _core.getSelectedNodeByType)(newEditor, _constants2.ELEMENT_TYPE.TABLE_CELL);
+    if (!selectedCell) {
+      selectAll();
+      return;
+    }
+    var anchor = selection.anchor,
+      focus = selection.focus;
+    if (!_slate.Path.equals(anchor.path.slice(0, 3), focus.path.slice(0, 3))) {
+      selectAll();
+      return;
+    }
+    var _getSelectedInfo4 = (0, _helpers.getSelectedInfo)(newEditor),
+      table = _getSelectedInfo4.table,
+      tableSize = _getSelectedInfo4.tableSize;
+    eventBus.dispatch(_constants.INTERNAL_EVENT.SET_TABLE_SELECT_RANGE, table, {
+      minRowIndex: 0,
+      maxRowIndex: tableSize[0] - 1,
+      minColIndex: 0,
+      maxColIndex: tableSize[1] - 1
+    });
+  };
+
+  // Rewrite normalizeNode
+  newEditor.normalizeNode = function (_ref) {
+    var _node$children$, _node$children$$child, _node$children$2, _node$children$2$chil;
+    var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
+      node = _ref2[0],
+      path = _ref2[1];
+    var type = (0, _core.getNodeType)(node);
+    if (node.type === _constants2.TABLE_ROW) {
+      var parentEntry = _slate.Editor.parent(editor, path);
+      if ((parentEntry === null || parentEntry === void 0 ? void 0 : parentEntry[0].type) !== _constants2.TABLE) {
+        _slate.Transforms.unwrapNodes(editor, {
+          at: path
+        });
+        return;
+      }
+    }
+    if (node.type === _constants2.TABLE_CELL) {
+      var _parentEntry = _slate.Editor.parent(editor, path);
+      if ((_parentEntry === null || _parentEntry === void 0 ? void 0 : _parentEntry[0].type) !== _constants2.TABLE_ROW) {
+        _slate.Transforms.unwrapNodes(editor, {
+          at: path
+        });
+        return;
+      }
+    }
+    if (type !== _constants2.ELEMENT_TYPE.TABLE) {
+      return normalizeNode([node, path]);
+    }
+
+    // Check field integrity
+    // Check table - columns
+    var isMissColumn = !node.columns;
+    if (isMissColumn) {
+      if (!node.columns) {
+        var columnCount = node.children[0].children.length;
+        var width = Math.max(_constants3.TABLE_CELL_MIN_WIDTH, parseInt(editor.width / columnCount));
+        var columns = Array(node.children[0].children.length).fill({
+          width: width
+        });
+        _slate.Transforms.setNodes(newEditor, {
+          columns: columns
+        }, {
+          at: path
+        });
+      }
+    }
+
+    // Check table - style
+    if (!node.style) {
+      var _columnCount = node.children[0].children.length;
+      var columnWidth = Math.max(_constants3.TABLE_CELL_MIN_WIDTH, parseInt(editor.width / _columnCount));
+      _slate.Transforms.setNodes(newEditor, {
+        style: {
+          gridTemplateColumns: "repeat(".concat(_columnCount, ", ").concat(columnWidth, "px)"),
+          gridAutoRows: "minmax(".concat(_constants3.TABLE_ROW_MIN_HEIGHT, "}px, auto)")
+        }
+      }, {
+        at: path
+      });
+    }
+
+    // Check table - ui
+    if (!node.ui) {
+      _slate.Transforms.setNodes(newEditor, {
+        ui: {
+          alternate_highlight: false
+        }
+      }, {
+        at: path
+      });
+    }
+
+    // Check row - style
+    if (!node.children[0].style) {
+      var style = {
+        min_height: _constants3.TABLE_ROW_MIN_HEIGHT
+      };
+      node.children.forEach(function (row, index) {
+        if (!row.style) {
+          _slate.Transforms.setNodes(newEditor, {
+            style: style
+          }, {
+            at: path.concat(index)
+          });
+        }
+      });
+    }
+
+    // Check cell - style & inherit_style
+    if (node !== null && node !== void 0 && (_node$children$ = node.children[0]) !== null && _node$children$ !== void 0 && (_node$children$$child = _node$children$.children[0]) !== null && _node$children$$child !== void 0 && _node$children$$child.style || node !== null && node !== void 0 && (_node$children$2 = node.children[0]) !== null && _node$children$2 !== void 0 && (_node$children$2$chil = _node$children$2.children[0]) !== null && _node$children$2$chil !== void 0 && _node$children$2$chil.inherit_style) {
+      node.children.forEach(function (row, rowIndex) {
+        row.children.forEach(function (cell, cellIndex) {
+          if (!cell.style || !cell.inherit_style) {
+            var _style = cell.style || {};
+            var inherit_style = cell.inherit_style || {};
+            _slate.Transforms.setNodes(newEditor, {
+              style: _style,
+              inherit_style: inherit_style
+            }, {
+              at: path.concat(rowIndex, cellIndex)
+            });
+          }
+        });
+      });
+    }
+
+    // insert empty node，continue editor
+    var isLast = (0, _core.isLastNode)(newEditor, node);
+    if (isLast) {
+      var p = (0, _core.generateEmptyElement)(_constants2.PARAGRAPH);
+      _slate.Transforms.insertNodes(newEditor, p, {
+        at: [path[0] + 1]
+      });
+    }
+  };
+
+  // Jump to the next cell when pressing tab in the table
+  newEditor.handleTab = function (event) {
+    var selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants2.ELEMENT_TYPE.TABLE);
+    if (!selectedNode) {
+      handleTab(event);
+      return;
+    }
+    var above = _slate.Editor.above(newEditor);
+
+    // Select multiple cells, jump to the first selected cell
+    if (above[0].type === _constants2.ELEMENT_TYPE.TABLE) {
+      var _selection = newEditor.selection;
+      var anchor = _selection.anchor;
+      _slate.Transforms.select(newEditor, (0, _toConsumableArray2["default"])(anchor.path.slice(0, -1)));
+      return;
+    }
+
+    // Add row to the last cell
+    if ((0, _helpers.isLastTableCell)(newEditor, above)) {
+      var _getSelectedInfo5 = (0, _helpers.getSelectedInfo)(newEditor),
+        tablePath = _getSelectedInfo5.tablePath,
+        tableSize = _getSelectedInfo5.tableSize;
+      if (tableSize[0] === _constants3.TABLE_MAX_ROWS) return;
+      (0, _helpers.insertTableElement)(newEditor, _constants3.TABLE_ELEMENT.ROW, _constants3.TABLE_ELEMENT_POSITION.AFTER);
+      _slate.Transforms.select(newEditor, [].concat((0, _toConsumableArray2["default"])(tablePath), [tableSize[0], 0]));
+      return;
+    }
+    var selection = newEditor.selection;
+
+    // The default behavior, the cursor is in the middle of the text, and the current text content is selected
+    // Change to jump to next cell
+    if (selection.anchor.offset === selection.focus.offset) {
+      var _getSelectedInfo6 = (0, _helpers.getSelectedInfo)(newEditor),
+        _tableSize = _getSelectedInfo6.tableSize,
+        _tablePath = _getSelectedInfo6.tablePath,
+        rowIndex = _getSelectedInfo6.rowIndex,
+        cellIndex = _getSelectedInfo6.cellIndex;
+      var lastColumnIndex = _tableSize[1] - 1;
+      var nextCell = [rowIndex, cellIndex + 1];
+      if (lastColumnIndex < nextCell[1]) {
+        nextCell = [rowIndex + 1, 0];
+      }
+      _slate.Transforms.select(newEditor, [].concat((0, _toConsumableArray2["default"])(_tablePath), (0, _toConsumableArray2["default"])(nextCell)));
+      return;
+    }
+    var next = _slate.Editor.next(newEditor);
+    _slate.Transforms.select(newEditor, next[1]);
+  };
+  newEditor.reSetTableSelectedRange = function () {
+    newEditor.tableSelectedRange = _constants3.EMPTY_SELECTED_RANGE;
+  };
+  return newEditor;
+};
+var _default = exports["default"] = withTable;