@seafile/sdoc-editor 0.3.6 → 0.3.7

package/dist/basic-sdk/extension/plugins/table/menu/table-context-menu/insert-table-element.js

@@ -1,92 +1,88 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React, { Component } from 'react';
 import { withTranslation } from 'react-i18next';
 import { Input } from 'reactstrap';
 import isHotkey from 'is-hotkey';
 import { TABLE_MAX_COLUMNS, TABLE_MAX_ROWS, TABLE_ELEMENT, TABLE_ELEMENT_POSITION } from '../../constants';
-var InsertTableElement = /*#__PURE__*/function (_Component) {
-  _inherits(InsertTableElement, _Component);
-  var _super = _createSuper(InsertTableElement);
-  function InsertTableElement(props) {
-    var _this;
-    _classCallCheck(this, InsertTableElement);
-    _this = _super.call(this, props);
-    _this.insertTableElement = function () {
-      var _this$props = _this.props,
-        type = _this$props.type,
-        position = _this$props.position;
-      var count = _this.state.count;
-      _this.props.insertTableElement(type, position, count);
+class InsertTableElement extends Component {
+  constructor(props) {
+    super(props);
+    this.insertTableElement = () => {
+      const {
+        type,
+        position
+      } = this.props;
+      const {
+        count
+      } = this.state;
+      this.props.insertTableElement(type, position, count);
     };
-    _this.getTip = function () {
-      var _this$props2 = _this.props,
-        type = _this$props2.type,
-        position = _this$props2.position,
-        t = _this$props2.t;
+    this.getTip = () => {
+      const {
+        type,
+        position,
+        t
+      } = this.props;
       if (type === TABLE_ELEMENT.ROW) {
         return position === TABLE_ELEMENT_POSITION.AFTER ? t('Insert_below') : t('Insert_above');
       }
       return position === TABLE_ELEMENT_POSITION.AFTER ? t('Insert_on_the_right') : t('Insert_on_the_left');
     };
-    _this.onKeyDown = function (event) {
+    this.onKeyDown = event => {
       if (isHotkey('enter', event)) {
         event.preventDefault();
-        _this.insertTableElement();
+        this.insertTableElement();
         return;
       }
     };
-    _this.onChange = function (event) {
-      var value = event.target.value || '0';
-      var newValue = value ? value.replace(/[^\d,]/g, '') : value;
-      if (newValue === _this.state.count) return;
-      var currentCount = _this.props.currentCount;
-      var numberValue = parseInt(newValue);
-      if (currentCount + numberValue > _this.maxCount) {
-        _this.setState({
-          count: _this.maxCount - currentCount
+    this.onChange = event => {
+      const value = event.target.value || '0';
+      const newValue = value ? value.replace(/[^\d,]/g, '') : value;
+      if (newValue === this.state.count) return;
+      const {
+        currentCount
+      } = this.props;
+      const numberValue = parseInt(newValue);
+      if (currentCount + numberValue > this.maxCount) {
+        this.setState({
+          count: this.maxCount - currentCount
         });
         return;
       }
-      _this.setState({
+      this.setState({
         count: numberValue
       });
     };
-    _this.state = {
+    this.state = {
       count: props.count || 1
     };
-    _this.maxCount = props.type === TABLE_ELEMENT.ROW ? TABLE_MAX_ROWS : TABLE_MAX_COLUMNS;
-    return _this;
+    this.maxCount = props.type === TABLE_ELEMENT.ROW ? TABLE_MAX_ROWS : TABLE_MAX_COLUMNS;
   }
-  _createClass(InsertTableElement, [{
-    key: "render",
-    value: function render() {
-      var count = this.state.count;
-      var _this$props3 = this.props,
-        t = _this$props3.t,
-        type = _this$props3.type,
-        currentCount = _this$props3.currentCount;
-      var isDisabled = currentCount >= this.maxCount;
-      return /*#__PURE__*/React.createElement("button", {
-        onMouseDown: this.insertTableElement,
-        className: "dropdown-item d-flex align-items-center justify-content-between",
-        disabled: isDisabled
-      }, this.getTip(), /*#__PURE__*/React.createElement("div", {
-        className: "insert-number d-flex align-items-center"
-      }, /*#__PURE__*/React.createElement(Input, {
-        disabled: isDisabled,
-        className: "insert-number-input",
-        onMouseDown: function onMouseDown(e) {
-          e.stopPropagation();
-        },
-        onKeyDown: this.onKeyDown,
-        value: count,
-        onChange: this.onChange
-      }), /*#__PURE__*/React.createElement("span", null, type === TABLE_ELEMENT.ROW ? t('Row(s)') : t('Column(s)'))));
-    }
-  }]);
-  return InsertTableElement;
-}(Component);
+  render() {
+    const {
+      count
+    } = this.state;
+    const {
+      t,
+      type,
+      currentCount
+    } = this.props;
+    const isDisabled = currentCount >= this.maxCount;
+    return /*#__PURE__*/React.createElement("button", {
+      onMouseDown: this.insertTableElement,
+      className: "dropdown-item d-flex align-items-center justify-content-between",
+      disabled: isDisabled
+    }, this.getTip(), /*#__PURE__*/React.createElement("div", {
+      className: "insert-number d-flex align-items-center"
+    }, /*#__PURE__*/React.createElement(Input, {
+      disabled: isDisabled,
+      className: "insert-number-input",
+      onMouseDown: e => {
+        e.stopPropagation();
+      },
+      onKeyDown: this.onKeyDown,
+      value: count,
+      onChange: this.onChange
+    }), /*#__PURE__*/React.createElement("span", null, type === TABLE_ELEMENT.ROW ? t('Row(s)') : t('Column(s)'))));
+  }
+}
 export default withTranslation('sdoc-editor')(InsertTableElement);

package/dist/basic-sdk/extension/plugins/table/menu/table-menu/index.js

@@ -4,13 +4,15 @@ import { insertTable, isTableMenuDisabled } from '../../helpers';
 import { MENUS_CONFIG_MAP, ELEMENT_TYPE, INSERT_POSITION } from '../../../../constants';
 import TableSizePopover from '../../popover/table-size-popover';
 import ElementDropdownMenuItem from '../../../../commons/dropdown-menu-item';
-var TableMenu = function TableMenu(_ref) {
-  var editor = _ref.editor,
-    readonly = _ref.readonly,
-    eventBus = _ref.eventBus;
-  var disabled = isTableMenuDisabled(editor, readonly);
-  var menuConfig = MENUS_CONFIG_MAP[ELEMENT_TYPE.TABLE];
-  var createTable = useCallback(function (size) {
+const TableMenu = _ref => {
+  let {
+    editor,
+    readonly,
+    eventBus
+  } = _ref;
+  const disabled = isTableMenuDisabled(editor, readonly);
+  const menuConfig = MENUS_CONFIG_MAP[ELEMENT_TYPE.TABLE];
+  const createTable = useCallback(size => {
     insertTable(editor, size, editor.selection, INSERT_POSITION.CURRENT);
   }, [editor]);
   return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(ElementDropdownMenuItem, {

package/dist/basic-sdk/extension/plugins/table/model.js

@@ -1,19 +1,18 @@
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import { ELEMENT_TYPE } from '../../constants';
-var Table = /*#__PURE__*/_createClass(function Table(options) {
-  _classCallCheck(this, Table);
-  this.type = options.type || ELEMENT_TYPE.TABLE;
-  this.children = options.children || [
-  // 1 x 1
-  {
-    type: ELEMENT_TYPE.TABLE_ROW,
-    children: [{
-      type: ELEMENT_TYPE.TABLE_CELL,
+class Table {
+  constructor(options) {
+    this.type = options.type || ELEMENT_TYPE.TABLE;
+    this.children = options.children || [
+    // 1 x 1
+    {
+      type: ELEMENT_TYPE.TABLE_ROW,
       children: [{
-        text: ''
+        type: ELEMENT_TYPE.TABLE_CELL,
+        children: [{
+          text: ''
+        }]
       }]
-    }]
-  }];
-});
+    }];
+  }
+}
 export default Table;

package/dist/basic-sdk/extension/plugins/table/plugin.js

@@ -1,5 +1,3 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import isHotkey from 'is-hotkey';
 import { Editor, Transforms, Path } from '@seafile/slate';
@@ -10,29 +8,32 @@ import ObjectUtils from '../../../utils/object-utils';
 import { getSelectedInfo, insertTableElement, removeTable, insertMultipleRowsAndColumns, setTableFragmentData, deleteTableRangeData, focusCell, deleteHandler, isTableLocation, isLastTableCell } from './helpers';
 import EventBus from '../../../utils/event-bus';
 import { INTERNAL_EVENT } from '../../../constants';
-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;
-  var newEditor = editor;
+const withTable = editor => {
+  const {
+    insertBreak,
+    deleteBackward,
+    deleteForward,
+    insertData,
+    selectAll,
+    normalizeNode,
+    handleTab,
+    getFragment,
+    setFragmentData,
+    insertFragment
+  } = editor;
+  const newEditor = editor;
   newEditor.tableSelectedRange = EMPTY_SELECTED_RANGE;
-  var eventBus = EventBus.getInstance();
-  newEditor.tableOnKeyDown = function (event) {
+  const eventBus = EventBus.getInstance();
+  newEditor.tableOnKeyDown = event => {
     // Handle special keyboard events
 
     if (isHotkey('mod+a', event)) {
       event.preventDefault();
-      var _getSelectedInfo = getSelectedInfo(newEditor),
-        table = _getSelectedInfo.table,
-        tableSize = _getSelectedInfo.tableSize;
-      var allTableRange = {
+      const {
+        table,
+        tableSize
+      } = getSelectedInfo(newEditor);
+      const allTableRange = {
         minRowIndex: 0,
         maxRowIndex: tableSize[0] - 1,
         minColIndex: 0,
@@ -57,19 +58,20 @@ var withTable = function withTable(editor) {
       event.preventDefault();
     }
   };
-  newEditor.insertBreak = function () {
-    var selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
+  newEditor.insertBreak = () => {
+    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
     if (selectedNode != null) {
       newEditor.insertText('\n'); // If table is selected, wrap in cell
       return;
     }
     insertBreak();
   };
-  newEditor.deleteBackward = function (unit) {
-    var deleteType = deleteHandler(newEditor);
+  newEditor.deleteBackward = unit => {
+    const deleteType = deleteHandler(newEditor);
     if (deleteType === 'table') {
-      var _getSelectedInfo2 = getSelectedInfo(editor),
-        tablePath = _getSelectedInfo2.tablePath;
+      const {
+        tablePath
+      } = getSelectedInfo(editor);
       removeTable(editor, tablePath);
       return;
     }
@@ -80,13 +82,15 @@ var withTable = function withTable(editor) {
       return;
     }
     if (deleteType === 'default') return;
-    var selection = newEditor.selection;
+    const {
+      selection
+    } = newEditor;
     if (selection) {
-      var before = Editor.before(newEditor, selection);
+      const before = Editor.before(newEditor, selection);
       if (before) {
         // If the current is not a table and the previous one is a table, no deletion will be performed. Otherwise, the last cell of the table will be deleted
-        var isTableOnBeforeLocation = isTableLocation(newEditor, before);
-        var isTableOnCurSelection = isTableLocation(newEditor, selection);
+        const isTableOnBeforeLocation = isTableLocation(newEditor, before);
+        const isTableOnCurSelection = isTableLocation(newEditor, selection);
         if (isTableOnBeforeLocation && !isTableOnCurSelection) {
           return;
         }
@@ -94,20 +98,22 @@ var withTable = function withTable(editor) {
     }
     deleteBackward(unit);
   };
-  newEditor.deleteForward = function (unit) {
-    var nextNode = Editor.next(newEditor);
-    var newNodeParent = getParentNode(newEditor.children, nextNode[0].id);
+  newEditor.deleteForward = unit => {
+    const nextNode = Editor.next(newEditor);
+    const newNodeParent = getParentNode(newEditor.children, nextNode[0].id);
     if (newNodeParent.type === ELEMENT_TYPE.TABLE_CELL) return;
     deleteForward(unit);
   };
-  newEditor.getFragment = function () {
-    var selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
+  newEditor.getFragment = () => {
+    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
     if (!selectedNode) {
       return getFragment();
     }
-    var tableSelectedRange = newEditor.tableSelectedRange;
+    const {
+      tableSelectedRange
+    } = newEditor;
     if (ObjectUtils.isSameObject(tableSelectedRange, EMPTY_SELECTED_RANGE)) {
-      var fragment = getFragment();
+      const fragment = getFragment();
 
       // When a cell is selected, it should be converted to text
       return [Object.freeze({
@@ -116,29 +122,31 @@ var withTable = function withTable(editor) {
         type: 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];
+    const {
+      minColIndex,
+      maxColIndex,
+      minRowIndex,
+      maxRowIndex
+    } = tableSelectedRange;
+    const rows = selectedNode.children;
+    const columns = selectedNode.columns;
+    let selectedRows = [];
+    let selectedColumns = [];
+    for (let i = minRowIndex; i <= maxRowIndex; i++) {
+      const row = rows[i];
+      const rowChildren = row.children;
+      let newRowChildren = [];
+      for (let j = minColIndex; j <= maxColIndex; j++) {
+        const column = rowChildren[j];
         newRowChildren.push(column);
       }
       selectedRows.push(_objectSpread(_objectSpread({}, row), {}, {
         children: newRowChildren
       }));
     }
-    for (var _j = minColIndex; _j <= maxColIndex; _j++) {
-      var _column = columns[_j];
-      selectedColumns.push(_column);
+    for (let j = minColIndex; j <= maxColIndex; j++) {
+      const column = columns[j];
+      selectedColumns.push(column);
     }
     return [Object.freeze(_objectSpread(_objectSpread({}, selectedNode), {}, {
       children: selectedRows,
@@ -147,26 +155,31 @@ var withTable = function withTable(editor) {
   };
 
   // copy: mod + c
-  newEditor.setFragmentData = function (dataTransfer) {
-    var selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
+  newEditor.setFragmentData = dataTransfer => {
+    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
     if (!selectedNode) {
       return setFragmentData(dataTransfer);
     }
-    var tableSelectedRange = newEditor.tableSelectedRange;
+    const {
+      tableSelectedRange
+    } = newEditor;
     if (ObjectUtils.isSameObject(tableSelectedRange, EMPTY_SELECTED_RANGE)) {
       return setFragmentData(dataTransfer);
     }
     return setTableFragmentData(newEditor, dataTransfer);
   };
-  newEditor.cut = function (event) {
-    var selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
-    var tableSelectedRange = newEditor.tableSelectedRange;
+  newEditor.cut = event => {
+    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
+    const {
+      tableSelectedRange
+    } = newEditor;
     if (selectedNode && !ObjectUtils.isSameObject(tableSelectedRange, EMPTY_SELECTED_RANGE)) {
       setTableFragmentData(newEditor, event.clipboardData);
-      var deleteType = deleteHandler(newEditor);
+      const deleteType = deleteHandler(newEditor);
       if (deleteType === 'table') {
-        var _getSelectedInfo3 = getSelectedInfo(editor),
-          tablePath = _getSelectedInfo3.tablePath;
+        const {
+          tablePath
+        } = getSelectedInfo(editor);
         removeTable(editor, tablePath);
         return;
       }
@@ -181,57 +194,56 @@ var withTable = function withTable(editor) {
   };
 
   // copy insert text
-  newEditor.insertData = function (data) {
-    var selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE_CELL);
+  newEditor.insertData = data => {
+    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE_CELL);
     if (!selectedNode) {
       insertData(data);
       return;
     }
-    var fragment = data.getData("application/".concat(CLIPBOARD_FORMAT_KEY));
+    const fragment = data.getData("application/".concat(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 === ELEMENT_TYPE.TABLE;
-      })) {
-        var tableElement = parsedData.find(function (item) {
-          return item.type === ELEMENT_TYPE.TABLE;
-        });
+      const decoded = decodeURIComponent(window.atob(fragment));
+      const parsedData = JSON.parse(decoded);
+      if (Array.isArray(parsedData) && parsedData.some(item => item.type === ELEMENT_TYPE.TABLE)) {
+        const tableElement = parsedData.find(item => item.type === ELEMENT_TYPE.TABLE);
         insertMultipleRowsAndColumns(newEditor, tableElement.children, tableElement.columns);
         return;
       }
     }
-    var text = data.getData('text/plain');
+    const text = data.getData('text/plain');
     if (!text) return;
     Editor.insertText(newEditor, text);
   };
-  newEditor.insertFragment = function (data) {
+  newEditor.insertFragment = data => {
     if (data.type === ELEMENT_TYPE.TABLE) {
       Transforms.insertNodes(editor, data);
       return;
     }
     return insertFragment(data);
   };
-  newEditor.selectAll = function () {
-    var selection = newEditor.selection;
+  newEditor.selectAll = () => {
+    const selection = newEditor.selection;
     if (!selection) {
       selectAll();
       return;
     }
-    var selectedCell = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE_CELL);
+    const selectedCell = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE_CELL);
     if (!selectedCell) {
       selectAll();
       return;
     }
-    var anchor = selection.anchor,
-      focus = selection.focus;
+    const {
+      anchor,
+      focus
+    } = selection;
     if (!Path.equals(anchor.path.slice(0, 3), focus.path.slice(0, 3))) {
       selectAll();
       return;
     }
-    var _getSelectedInfo4 = getSelectedInfo(newEditor),
-      table = _getSelectedInfo4.table,
-      tableSize = _getSelectedInfo4.tableSize;
+    const {
+      table,
+      tableSize
+    } = getSelectedInfo(newEditor);
     eventBus.dispatch(INTERNAL_EVENT.SET_TABLE_SELECT_RANGE, table, {
       minRowIndex: 0,
       maxRowIndex: tableSize[0] - 1,
@@ -241,19 +253,17 @@ var withTable = function withTable(editor) {
   };
 
   // Rewrite normalizeNode
-  newEditor.normalizeNode = function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-      node = _ref2[0],
-      path = _ref2[1];
-    var type = getNodeType(node);
+  newEditor.normalizeNode = _ref => {
+    let [node, path] = _ref;
+    const type = getNodeType(node);
     if (type !== ELEMENT_TYPE.TABLE) {
       return normalizeNode([node, path]);
     }
 
     // insert empty node，continue editor
-    var isLast = isLastNode(newEditor, node);
+    const isLast = isLastNode(newEditor, node);
     if (isLast) {
-      var p = generateEmptyElement(PARAGRAPH);
+      const p = generateEmptyElement(PARAGRAPH);
       Transforms.insertNodes(newEditor, p, {
         at: [path[0] + 1]
       });
@@ -261,54 +271,62 @@ var withTable = function withTable(editor) {
   };
 
   // Jump to the next cell when pressing tab in the table
-  newEditor.handleTab = function (event) {
-    var selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
+  newEditor.handleTab = event => {
+    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
     if (!selectedNode) {
       handleTab(event);
       return;
     }
-    var above = Editor.above(newEditor);
+    const above = Editor.above(newEditor);
 
     // Select multiple cells, jump to the first selected cell
     if (above[0].type === ELEMENT_TYPE.TABLE) {
-      var _selection = newEditor.selection;
-      var anchor = _selection.anchor;
-      Transforms.select(newEditor, _toConsumableArray(anchor.path.slice(0, -1)));
+      const {
+        selection
+      } = newEditor;
+      const {
+        anchor
+      } = selection;
+      Transforms.select(newEditor, [...anchor.path.slice(0, -1)]);
       return;
     }
 
     // Add row to the last cell
     if (isLastTableCell(newEditor, above)) {
-      var _getSelectedInfo5 = getSelectedInfo(newEditor),
-        tablePath = _getSelectedInfo5.tablePath,
-        tableSize = _getSelectedInfo5.tableSize;
+      const {
+        tablePath,
+        tableSize
+      } = getSelectedInfo(newEditor);
       if (tableSize[0] === TABLE_MAX_ROWS) return;
       insertTableElement(newEditor, TABLE_ELEMENT.ROW, TABLE_ELEMENT_POSITION.AFTER);
-      Transforms.select(newEditor, [].concat(_toConsumableArray(tablePath), [tableSize[0], 0]));
+      Transforms.select(newEditor, [...tablePath, tableSize[0], 0]);
       return;
     }
-    var selection = newEditor.selection;
+    const {
+      selection
+    } = newEditor;
 
     // 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 = getSelectedInfo(newEditor),
-        _tableSize = _getSelectedInfo6.tableSize,
-        _tablePath = _getSelectedInfo6.tablePath,
-        rowIndex = _getSelectedInfo6.rowIndex,
-        cellIndex = _getSelectedInfo6.cellIndex;
-      var lastColumnIndex = _tableSize[1] - 1;
-      var nextCell = [rowIndex, cellIndex + 1];
+      const {
+        tableSize,
+        tablePath,
+        rowIndex,
+        cellIndex
+      } = getSelectedInfo(newEditor);
+      const lastColumnIndex = tableSize[1] - 1;
+      let nextCell = [rowIndex, cellIndex + 1];
       if (lastColumnIndex < nextCell[1]) {
         nextCell = [rowIndex + 1, 0];
       }
-      Transforms.select(newEditor, [].concat(_toConsumableArray(_tablePath), _toConsumableArray(nextCell)));
+      Transforms.select(newEditor, [...tablePath, ...nextCell]);
       return;
     }
-    var next = Editor.next(newEditor);
+    const next = Editor.next(newEditor);
     Transforms.select(newEditor, next[1]);
   };
-  newEditor.reSetTableSelectedRange = function () {
+  newEditor.reSetTableSelectedRange = () => {
     newEditor.tableSelectedRange = EMPTY_SELECTED_RANGE;
   };
   return newEditor;