@seafile/sdoc-editor 1.0.53 → 1.0.55

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

@@ -1,13 +1,20 @@
-import isHotkey from 'is-hotkey';
-import { Editor, Transforms, Path, Element } from '@seafile/slate';
-import { ReactEditor } from '@seafile/slate-react';
-import { getNodeType, getParentNode, getSelectedNodeByType, isLastNode, generateEmptyElement, focusEditor, getAboveBlockNode } from '../../core';
-import { ELEMENT_TYPE, KEYBOARD, PARAGRAPH, CLIPBOARD_FORMAT_KEY, CHECK_LIST_ITEM, ORDERED_LIST, UNORDERED_LIST, TABLE_ROW, TABLE, TABLE_CELL } from '../../constants';
-import { TABLE_MAX_ROWS, EMPTY_SELECTED_RANGE, TABLE_ELEMENT, TABLE_ELEMENT_POSITION, TABLE_CELL_MIN_WIDTH, TABLE_ROW_MIN_HEIGHT } from './constants';
-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';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _core = require("../../core");
+var _constants = require("../../constants");
+var _constants2 = require("./constants");
+var _objectUtils = _interopRequireDefault(require("../../../utils/object-utils"));
+var _helpers = require("./helpers");
+var _eventBus = _interopRequireDefault(require("../../../utils/event-bus"));
+var _constants3 = require("../../../constants");
 const withTable = editor => {
   const {
     insertBreak,
@@ -23,16 +30,16 @@ const withTable = editor => {
     cut
   } = editor;
   const newEditor = editor;
-  newEditor.tableSelectedRange = EMPTY_SELECTED_RANGE;
-  const eventBus = EventBus.getInstance();
+  newEditor.tableSelectedRange = _constants2.EMPTY_SELECTED_RANGE;
+  const eventBus = _eventBus.default.getInstance();
   newEditor.tableOnKeyDown = event => {
     // Handle special keyboard events
-    if (isHotkey('mod+a', event)) {
+    if ((0, _isHotkey.default)('mod+a', event)) {
       event.preventDefault();
       const {
         table,
         tableSize
-      } = getSelectedInfo(newEditor);
+      } = (0, _helpers.getSelectedInfo)(newEditor);
       const allTableRange = {
         minRowIndex: 0,
         maxRowIndex: tableSize[0] - 1,
@@ -40,33 +47,33 @@ const withTable = editor => {
         maxColIndex: tableSize[1] - 1
       };
       newEditor.tableSelectedRange = allTableRange;
-      eventBus.dispatch(INTERNAL_EVENT.SET_TABLE_SELECT_RANGE, table, allTableRange);
+      eventBus.dispatch(_constants3.INTERNAL_EVENT.SET_TABLE_SELECT_RANGE, table, allTableRange);
     }
-    if (isHotkey(KEYBOARD.UP, event)) {
-      focusCell(newEditor, event, KEYBOARD.UP);
+    if ((0, _isHotkey.default)(_constants.KEYBOARD.UP, event)) {
+      (0, _helpers.focusCell)(newEditor, event, _constants.KEYBOARD.UP);
     }
-    if (isHotkey(KEYBOARD.RIGHT, event)) {
-      focusCell(newEditor, event, KEYBOARD.RIGHT);
+    if ((0, _isHotkey.default)(_constants.KEYBOARD.RIGHT, event)) {
+      (0, _helpers.focusCell)(newEditor, event, _constants.KEYBOARD.RIGHT);
     }
-    if (isHotkey(KEYBOARD.DOWN, event)) {
-      focusCell(newEditor, event, KEYBOARD.DOWN);
+    if ((0, _isHotkey.default)(_constants.KEYBOARD.DOWN, event)) {
+      (0, _helpers.focusCell)(newEditor, event, _constants.KEYBOARD.DOWN);
     }
-    if (isHotkey(KEYBOARD.LEFT, event)) {
-      focusCell(newEditor, event, KEYBOARD.LEFT);
+    if ((0, _isHotkey.default)(_constants.KEYBOARD.LEFT, event)) {
+      (0, _helpers.focusCell)(newEditor, event, _constants.KEYBOARD.LEFT);
     }
-    if (isHotkey('tab', event)) {
+    if ((0, _isHotkey.default)('tab', event)) {
       event.preventDefault();
     }
-    if (isHotkey('shift+enter', event)) {
+    if ((0, _isHotkey.default)('shift+enter', event)) {
       event.preventDefault();
-      const [, tablePath] = getAboveBlockNode(newEditor);
+      const [, tablePath] = (0, _core.getAboveBlockNode)(newEditor);
       const focusPath = [tablePath[0] + 1];
-      const focusPoint = Editor.start(newEditor, focusPath);
-      focusEditor(newEditor, focusPoint);
+      const focusPoint = _slate.Editor.start(newEditor, focusPath);
+      (0, _core.focusEditor)(newEditor, focusPoint);
     }
   };
   newEditor.insertBreak = () => {
-    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
+    const selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants.ELEMENT_TYPE.TABLE);
     if (selectedNode != null) {
       newEditor.insertText('\n'); // If table is selected, wrap in cell
       return;
@@ -74,18 +81,18 @@ const withTable = editor => {
     insertBreak();
   };
   newEditor.deleteBackward = unit => {
-    const deleteType = deleteHandler(newEditor);
+    const deleteType = (0, _helpers.deleteHandler)(newEditor);
     if (deleteType === 'table') {
       const {
         tablePath
-      } = getSelectedInfo(editor);
-      removeTable(editor, tablePath);
+      } = (0, _helpers.getSelectedInfo)(editor);
+      (0, _helpers.removeTable)(editor, tablePath);
       return;
     }
 
     // range selection delete
     if (deleteType === 'range') {
-      deleteTableRangeData(newEditor);
+      (0, _helpers.deleteTableRangeData)(newEditor);
       return;
     }
     if (deleteType === 'default') return;
@@ -93,24 +100,24 @@ const withTable = editor => {
       selection
     } = newEditor;
     if (selection) {
-      const before = Editor.before(newEditor, selection);
+      const before = _slate.Editor.before(newEditor, selection);
       if (before) {
-        const isTableOnBeforeLocation = isTableLocation(newEditor, before);
-        const isTableOnCurSelection = isTableLocation(newEditor, selection);
+        const isTableOnBeforeLocation = (0, _helpers.isTableLocation)(newEditor, before);
+        const isTableOnCurSelection = (0, _helpers.isTableLocation)(newEditor, selection);
         // If the current is not a table and the previous one is a table.
         if (isTableOnBeforeLocation && !isTableOnCurSelection) {
-          const [currentNodeEntry] = Editor.nodes(editor, {
-            match: n => Element.isElement(n) && !Editor.parent(n, ReactEditor.findPath(editor, n))[1].length
+          const [currentNodeEntry] = _slate.Editor.nodes(editor, {
+            match: n => _slate.Element.isElement(n) && !_slate.Editor.parent(n, _slateReact.ReactEditor.findPath(editor, n))[1].length
           });
           if (!currentNodeEntry) return;
           const [currentNode, currentPath] = Array.from(currentNodeEntry);
 
           // If the current is paragraph.
-          if (currentNode.type === PARAGRAPH) {
+          if (currentNode.type === _constants.PARAGRAPH) {
             const {
               path
             } = before;
-            Transforms.select(editor, {
+            _slate.Transforms.select(editor, {
               anchor: {
                 offset: 0,
                 path: [path[0], 0, 0, 0]
@@ -120,8 +127,8 @@ const withTable = editor => {
                 path: [path[0], 0, 0, 0]
               }
             });
-            const beforeTable = Editor.node(editor, [path[0]]);
-            const beforeRow = Editor.node(editor, [path[0], path[1]]);
+            const beforeTable = _slate.Editor.node(editor, [path[0]]);
+            const beforeRow = _slate.Editor.node(editor, [path[0], path[1]]);
             const tableSize = [beforeTable[0].children.length, beforeRow[0].children.length];
             const allTableRange = {
               minRowIndex: 0,
@@ -130,20 +137,20 @@ const withTable = editor => {
               maxColIndex: tableSize[1] - 1
             };
             newEditor.tableSelectedRange = allTableRange;
-            eventBus.dispatch(INTERNAL_EVENT.SET_TABLE_SELECT_RANGE, beforeTable[0], allTableRange);
+            eventBus.dispatch(_constants3.INTERNAL_EVENT.SET_TABLE_SELECT_RANGE, beforeTable[0], allTableRange);
             return;
           }
 
           // If deleting node is empty check-list, order-list, unordered-list, change to paragraph
-          const transformTypes = [CHECK_LIST_ITEM, ORDERED_LIST, UNORDERED_LIST];
+          const transformTypes = [_constants.CHECK_LIST_ITEM, _constants.ORDERED_LIST, _constants.UNORDERED_LIST];
           if (transformTypes.includes(currentNode.type)) {
-            Transforms.delete(newEditor, {
+            _slate.Transforms.delete(newEditor, {
               at: currentPath
             });
-            Transforms.insertNodes(newEditor, generateEmptyElement(PARAGRAPH), {
+            _slate.Transforms.insertNodes(newEditor, (0, _core.generateEmptyElement)(_constants.PARAGRAPH), {
               at: currentPath
             });
-            focusEditor(editor, Editor.start(editor, currentPath));
+            (0, _core.focusEditor)(editor, _slate.Editor.start(editor, currentPath));
           }
           return;
         }
@@ -152,27 +159,27 @@ const withTable = editor => {
     deleteBackward(unit);
   };
   newEditor.deleteForward = unit => {
-    const nextNode = Editor.next(newEditor);
-    const newNodeParent = getParentNode(newEditor.children, nextNode[0].id);
-    if (newNodeParent.type === ELEMENT_TYPE.TABLE_CELL) return;
+    const nextNode = _slate.Editor.next(newEditor);
+    const newNodeParent = (0, _core.getParentNode)(newEditor.children, nextNode[0].id);
+    if (newNodeParent.type === _constants.ELEMENT_TYPE.TABLE_CELL) return;
     deleteForward(unit);
   };
   newEditor.getFragment = () => {
-    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
+    const selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants.ELEMENT_TYPE.TABLE);
     if (!selectedNode) {
       return getFragment();
     }
     const {
       tableSelectedRange
     } = newEditor;
-    if (ObjectUtils.isSameObject(tableSelectedRange, EMPTY_SELECTED_RANGE)) {
+    if (_objectUtils.default.isSameObject(tableSelectedRange, _constants2.EMPTY_SELECTED_RANGE)) {
       const 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: ELEMENT_TYPE.PARAGRAPH
+        type: _constants.ELEMENT_TYPE.PARAGRAPH
       })];
     }
     const {
@@ -211,37 +218,37 @@ const withTable = editor => {
 
   // copy: mod + c
   newEditor.setFragmentData = dataTransfer => {
-    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
+    const selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants.ELEMENT_TYPE.TABLE);
     if (!selectedNode) {
       return setFragmentData(dataTransfer);
     }
     const {
       tableSelectedRange
     } = newEditor;
-    if (ObjectUtils.isSameObject(tableSelectedRange, EMPTY_SELECTED_RANGE)) {
+    if (_objectUtils.default.isSameObject(tableSelectedRange, _constants2.EMPTY_SELECTED_RANGE)) {
       return setFragmentData(dataTransfer);
     }
-    return setTableFragmentData(newEditor, dataTransfer);
+    return (0, _helpers.setTableFragmentData)(newEditor, dataTransfer);
   };
   newEditor.cut = event => {
-    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
+    const selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants.ELEMENT_TYPE.TABLE);
     const {
       tableSelectedRange
     } = newEditor;
-    if (selectedNode && !ObjectUtils.isSameObject(tableSelectedRange, EMPTY_SELECTED_RANGE)) {
-      setTableFragmentData(newEditor, event.clipboardData);
-      const deleteType = deleteHandler(newEditor);
+    if (selectedNode && !_objectUtils.default.isSameObject(tableSelectedRange, _constants2.EMPTY_SELECTED_RANGE)) {
+      (0, _helpers.setTableFragmentData)(newEditor, event.clipboardData);
+      const deleteType = (0, _helpers.deleteHandler)(newEditor);
       if (deleteType === 'table') {
         const {
           tablePath
-        } = getSelectedInfo(editor);
-        removeTable(editor, tablePath);
+        } = (0, _helpers.getSelectedInfo)(editor);
+        (0, _helpers.removeTable)(editor, tablePath);
         return;
       }
 
       // range selection delete
       if (deleteType === 'range') {
-        deleteTableRangeData(newEditor);
+        (0, _helpers.deleteTableRangeData)(newEditor);
         return;
       }
       return;
@@ -251,28 +258,28 @@ const withTable = editor => {
 
   // copy insert text
   newEditor.insertData = data => {
-    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE_CELL);
+    const selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants.ELEMENT_TYPE.TABLE_CELL);
     if (!selectedNode) {
       insertData(data);
       return;
     }
-    const fragment = data.getData("application/".concat(CLIPBOARD_FORMAT_KEY));
+    const fragment = data.getData(`application/${_constants.CLIPBOARD_FORMAT_KEY}`);
     if (fragment) {
       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);
+      if (Array.isArray(parsedData) && parsedData.some(item => item.type === _constants.ELEMENT_TYPE.TABLE)) {
+        const tableElement = parsedData.find(item => item.type === _constants.ELEMENT_TYPE.TABLE);
+        (0, _helpers.insertMultipleRowsAndColumns)(newEditor, tableElement.children, tableElement.columns);
         return;
       }
     }
     const text = data.getData('text/plain');
     if (!text) return;
-    Editor.insertText(newEditor, text);
+    _slate.Editor.insertText(newEditor, text);
   };
   newEditor.insertFragment = data => {
-    if (data.type === ELEMENT_TYPE.TABLE) {
-      Transforms.insertNodes(editor, data);
+    if (data.type === _constants.ELEMENT_TYPE.TABLE) {
+      _slate.Transforms.insertNodes(editor, data);
       return;
     }
     return insertFragment(data);
@@ -283,7 +290,7 @@ const withTable = editor => {
       selectAll();
       return;
     }
-    const selectedCell = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE_CELL);
+    const selectedCell = (0, _core.getSelectedNodeByType)(newEditor, _constants.ELEMENT_TYPE.TABLE_CELL);
     if (!selectedCell) {
       selectAll();
       return;
@@ -292,15 +299,15 @@ const withTable = editor => {
       anchor,
       focus
     } = selection;
-    if (!Path.equals(anchor.path.slice(0, 3), focus.path.slice(0, 3))) {
+    if (!_slate.Path.equals(anchor.path.slice(0, 3), focus.path.slice(0, 3))) {
       selectAll();
       return;
     }
     const {
       table,
       tableSize
-    } = getSelectedInfo(newEditor);
-    eventBus.dispatch(INTERNAL_EVENT.SET_TABLE_SELECT_RANGE, table, {
+    } = (0, _helpers.getSelectedInfo)(newEditor);
+    eventBus.dispatch(_constants3.INTERNAL_EVENT.SET_TABLE_SELECT_RANGE, table, {
       minRowIndex: 0,
       maxRowIndex: tableSize[0] - 1,
       minColIndex: 0,
@@ -312,26 +319,26 @@ const withTable = editor => {
   newEditor.normalizeNode = _ref => {
     var _node$children$, _node$children$$child, _node$children$2, _node$children$2$chil;
     let [node, path] = _ref;
-    const type = getNodeType(node);
-    if (node.type === TABLE_ROW) {
-      const parentEntry = Editor.parent(editor, path);
-      if ((parentEntry === null || parentEntry === void 0 ? void 0 : parentEntry[0].type) !== TABLE) {
-        Transforms.unwrapNodes(editor, {
+    const type = (0, _core.getNodeType)(node);
+    if (node.type === _constants.TABLE_ROW) {
+      const parentEntry = _slate.Editor.parent(editor, path);
+      if ((parentEntry === null || parentEntry === void 0 ? void 0 : parentEntry[0].type) !== _constants.TABLE) {
+        _slate.Transforms.unwrapNodes(editor, {
           at: path
         });
         return;
       }
     }
-    if (node.type === TABLE_CELL) {
-      const parentEntry = Editor.parent(editor, path);
-      if ((parentEntry === null || parentEntry === void 0 ? void 0 : parentEntry[0].type) !== TABLE_ROW) {
-        Transforms.unwrapNodes(editor, {
+    if (node.type === _constants.TABLE_CELL) {
+      const parentEntry = _slate.Editor.parent(editor, path);
+      if ((parentEntry === null || parentEntry === void 0 ? void 0 : parentEntry[0].type) !== _constants.TABLE_ROW) {
+        _slate.Transforms.unwrapNodes(editor, {
           at: path
         });
         return;
       }
     }
-    if (type !== ELEMENT_TYPE.TABLE) {
+    if (type !== _constants.ELEMENT_TYPE.TABLE) {
       return normalizeNode([node, path]);
     }
 
@@ -341,11 +348,11 @@ const withTable = editor => {
     if (isMissColumn) {
       if (!node.columns) {
         const columnCount = node.children[0].children.length;
-        const width = Math.max(TABLE_CELL_MIN_WIDTH, parseInt(editor.width / columnCount));
+        const width = Math.max(_constants2.TABLE_CELL_MIN_WIDTH, parseInt(editor.width / columnCount));
         const columns = Array(node.children[0].children.length).fill({
           width
         });
-        Transforms.setNodes(newEditor, {
+        _slate.Transforms.setNodes(newEditor, {
           columns
         }, {
           at: path
@@ -356,11 +363,11 @@ const withTable = editor => {
     // Check table - style
     if (!node.style) {
       const columnCount = node.children[0].children.length;
-      const columnWidth = Math.max(TABLE_CELL_MIN_WIDTH, parseInt(editor.width / columnCount));
-      Transforms.setNodes(newEditor, {
+      const columnWidth = Math.max(_constants2.TABLE_CELL_MIN_WIDTH, parseInt(editor.width / columnCount));
+      _slate.Transforms.setNodes(newEditor, {
         style: {
-          gridTemplateColumns: "repeat(".concat(columnCount, ", ").concat(columnWidth, "px)"),
-          gridAutoRows: "minmax(".concat(TABLE_ROW_MIN_HEIGHT, "}px, auto)")
+          gridTemplateColumns: `repeat(${columnCount}, ${columnWidth}px)`,
+          gridAutoRows: `minmax(${_constants2.TABLE_ROW_MIN_HEIGHT}}px, auto)`
         }
       }, {
         at: path
@@ -369,7 +376,7 @@ const withTable = editor => {
 
     // Check table - ui
     if (!node.ui) {
-      Transforms.setNodes(newEditor, {
+      _slate.Transforms.setNodes(newEditor, {
         ui: {
           alternate_highlight: false
         }
@@ -381,11 +388,11 @@ const withTable = editor => {
     // Check row - style
     if (!node.children[0].style) {
       const style = {
-        min_height: TABLE_ROW_MIN_HEIGHT
+        min_height: _constants2.TABLE_ROW_MIN_HEIGHT
       };
       node.children.forEach((row, index) => {
         if (!row.style) {
-          Transforms.setNodes(newEditor, {
+          _slate.Transforms.setNodes(newEditor, {
             style
           }, {
             at: path.concat(index)
@@ -395,13 +402,13 @@ const withTable = editor => {
     }
 
     // Check cell - style & inherit_style
-    if ((node === null || node === void 0 ? void 0 : (_node$children$ = node.children[0]) === null || _node$children$ === void 0 ? void 0 : (_node$children$$child = _node$children$.children[0]) === null || _node$children$$child === void 0 ? void 0 : _node$children$$child.style) || (node === null || node === void 0 ? void 0 : (_node$children$2 = node.children[0]) === null || _node$children$2 === void 0 ? void 0 : (_node$children$2$chil = _node$children$2.children[0]) === null || _node$children$2$chil === void 0 ? void 0 : _node$children$2$chil.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((row, rowIndex) => {
         row.children.forEach((cell, cellIndex) => {
           if (!cell.style || !cell.inherit_style) {
             const style = cell.style || {};
             const inherit_style = cell.inherit_style || {};
-            Transforms.setNodes(newEditor, {
+            _slate.Transforms.setNodes(newEditor, {
               style,
               inherit_style
             }, {
@@ -413,10 +420,10 @@ const withTable = editor => {
     }
 
     // insert empty node，continue editor
-    const isLast = isLastNode(newEditor, node);
+    const isLast = (0, _core.isLastNode)(newEditor, node);
     if (isLast) {
-      const p = generateEmptyElement(PARAGRAPH);
-      Transforms.insertNodes(newEditor, p, {
+      const p = (0, _core.generateEmptyElement)(_constants.PARAGRAPH);
+      _slate.Transforms.insertNodes(newEditor, p, {
         at: [path[0] + 1]
       });
     }
@@ -424,34 +431,34 @@ const withTable = editor => {
 
   // Jump to the next cell when pressing tab in the table
   newEditor.handleTab = event => {
-    const selectedNode = getSelectedNodeByType(newEditor, ELEMENT_TYPE.TABLE);
+    const selectedNode = (0, _core.getSelectedNodeByType)(newEditor, _constants.ELEMENT_TYPE.TABLE);
     if (!selectedNode) {
       handleTab(event);
       return;
     }
-    const above = Editor.above(newEditor);
+    const above = _slate.Editor.above(newEditor);
 
     // Select multiple cells, jump to the first selected cell
-    if (above[0].type === ELEMENT_TYPE.TABLE) {
+    if (above[0].type === _constants.ELEMENT_TYPE.TABLE) {
       const {
         selection
       } = newEditor;
       const {
         anchor
       } = selection;
-      Transforms.select(newEditor, [...anchor.path.slice(0, -1)]);
+      _slate.Transforms.select(newEditor, [...anchor.path.slice(0, -1)]);
       return;
     }
 
     // Add row to the last cell
-    if (isLastTableCell(newEditor, above)) {
+    if ((0, _helpers.isLastTableCell)(newEditor, above)) {
       const {
         tablePath,
         tableSize
-      } = getSelectedInfo(newEditor);
-      if (tableSize[0] === TABLE_MAX_ROWS) return;
-      insertTableElement(newEditor, TABLE_ELEMENT.ROW, TABLE_ELEMENT_POSITION.AFTER);
-      Transforms.select(newEditor, [...tablePath, tableSize[0], 0]);
+      } = (0, _helpers.getSelectedInfo)(newEditor);
+      if (tableSize[0] === _constants2.TABLE_MAX_ROWS) return;
+      (0, _helpers.insertTableElement)(newEditor, _constants2.TABLE_ELEMENT.ROW, _constants2.TABLE_ELEMENT_POSITION.AFTER);
+      _slate.Transforms.select(newEditor, [...tablePath, tableSize[0], 0]);
       return;
     }
     const {
@@ -466,21 +473,21 @@ const withTable = editor => {
         tablePath,
         rowIndex,
         cellIndex
-      } = getSelectedInfo(newEditor);
+      } = (0, _helpers.getSelectedInfo)(newEditor);
       const lastColumnIndex = tableSize[1] - 1;
       let nextCell = [rowIndex, cellIndex + 1];
       if (lastColumnIndex < nextCell[1]) {
         nextCell = [rowIndex + 1, 0];
       }
-      Transforms.select(newEditor, [...tablePath, ...nextCell]);
+      _slate.Transforms.select(newEditor, [...tablePath, ...nextCell]);
       return;
     }
-    const next = Editor.next(newEditor);
-    Transforms.select(newEditor, next[1]);
+    const next = _slate.Editor.next(newEditor);
+    _slate.Transforms.select(newEditor, next[1]);
   };
   newEditor.reSetTableSelectedRange = () => {
-    newEditor.tableSelectedRange = EMPTY_SELECTED_RANGE;
+    newEditor.tableSelectedRange = _constants2.EMPTY_SELECTED_RANGE;
   };
   return newEditor;
 };
-export default withTable;
+var _default = exports.default = withTable;

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

@@ -1,9 +1,17 @@
-import React, { useCallback, useRef, useState } from 'react';
-import classnames from 'classnames';
-import { useTranslation } from 'react-i18next';
-import { UncontrolledPopover } from 'reactstrap';
-import TableTemplate from '../table-template';
-import './index.css';
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _reactI18next = require("react-i18next");
+var _reactstrap = require("reactstrap");
+var _tableTemplate = _interopRequireDefault(require("../table-template"));
+require("./index.css");
 const TableSizePopover = _ref => {
   let {
     editor,
@@ -15,10 +23,10 @@ const TableSizePopover = _ref => {
   } = _ref;
   const minSize = [5, 10];
   const maxSize = [10, 10];
-  const [displaySize, setDisplaySize] = useState([5, 10]);
-  const [selectedSize, setSelectedSize] = useState([1, 1]);
-  const ref = useRef(null);
-  const onMouseEnter = useCallback(function (event) {
+  const [displaySize, setDisplaySize] = (0, _react.useState)([5, 10]);
+  const [selectedSize, setSelectedSize] = (0, _react.useState)([1, 1]);
+  const ref = (0, _react.useRef)(null);
+  const onMouseEnter = (0, _react.useCallback)(function (event) {
     let cellPosition = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [1, 1];
     let newDisplaySize = displaySize.slice(0);
     const cellPositionX = cellPosition[0];
@@ -36,21 +44,21 @@ const TableSizePopover = _ref => {
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [displaySize, selectedSize, maxSize, minSize]);
-  const onCreateTable = useCallback(() => {
+  const onCreateTable = (0, _react.useCallback)(() => {
     createTable(selectedSize);
     ref && ref.current && ref.current.toggle();
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [selectedSize, ref]);
-  const renderTableSize = useCallback(() => {
+  const renderTableSize = (0, _react.useCallback)(() => {
     let tableSize = [];
     for (let i = 1; i <= displaySize[0]; i++) {
       let children = [];
       for (let j = 1; j <= displaySize[1]; j++) {
         const isSelectedChild = i <= selectedSize[0] && selectedSize[0] !== 0 && j <= selectedSize[1] && selectedSize[1] !== 0;
-        const child = /*#__PURE__*/React.createElement("div", {
-          key: "sdoc-table-size-cell-".concat(i, "-").concat(j),
-          className: classnames('sdoc-table-size-cell', {
+        const child = /*#__PURE__*/_react.default.createElement("div", {
+          key: `sdoc-table-size-cell-${i}-${j}`,
+          className: (0, _classnames.default)('sdoc-table-size-cell', {
             'active': isSelectedChild
           }),
           onClick: onCreateTable,
@@ -58,8 +66,8 @@ const TableSizePopover = _ref => {
         });
         children.push(child);
       }
-      tableSize.push( /*#__PURE__*/React.createElement("div", {
-        key: "sdoc-table-size-row-".concat(i),
+      tableSize.push( /*#__PURE__*/_react.default.createElement("div", {
+        key: `sdoc-table-size-row-${i}`,
         className: "sdoc-table-size-row d-flex"
       }, children));
     }
@@ -67,7 +75,7 @@ const TableSizePopover = _ref => {
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [displaySize, selectedSize]);
-  return /*#__PURE__*/React.createElement(UncontrolledPopover, {
+  return /*#__PURE__*/_react.default.createElement(_reactstrap.UncontrolledPopover, {
     target: target,
     className: "sdoc-selected-table-size-popover sdoc-sub-dropdown-menu sdoc-dropdown-menu",
     trigger: trigger,
@@ -76,24 +84,24 @@ const TableSizePopover = _ref => {
     fade: false,
     ref: ref,
     popperClassName: popperClassName
-  }, /*#__PURE__*/React.createElement("div", {
+  }, /*#__PURE__*/_react.default.createElement("div", {
     className: "sdoc-selected-table-size-container w-100 h-100 d-flex flex-column"
-  }, /*#__PURE__*/React.createElement("div", {
+  }, /*#__PURE__*/_react.default.createElement("div", {
     className: "sdoc-selected-table-tools-container"
-  }, /*#__PURE__*/React.createElement(MenuItem, {
+  }, /*#__PURE__*/_react.default.createElement(MenuItem, {
     id: "sdoc-table-template-review-btn",
     text: "Table_template",
     iconClassname: "sdocfont sdoc-right-slide sdoc-dropdown-item-right-icon"
-  })), /*#__PURE__*/React.createElement("div", {
+  })), /*#__PURE__*/_react.default.createElement("div", {
     className: "sdoc-table-size-select"
-  }, renderTableSize()), /*#__PURE__*/React.createElement("div", {
+  }, renderTableSize()), /*#__PURE__*/_react.default.createElement("div", {
     className: "sdoc-selected-table-size-tip w-100 "
-  }, "".concat(selectedSize[0], " x ").concat(selectedSize[1])), /*#__PURE__*/React.createElement(TableTemplate, {
+  }, `${selectedSize[0]} x ${selectedSize[1]}`), /*#__PURE__*/_react.default.createElement(_tableTemplate.default, {
     editor: editor,
     targetId: "sdoc-table-template-review-btn"
   })));
 };
-export default TableSizePopover;
+var _default = exports.default = TableSizePopover;
 const MenuItem = _ref2 => {
   let {
     id,
@@ -103,13 +111,13 @@ const MenuItem = _ref2 => {
   } = _ref2;
   const {
     t
-  } = useTranslation();
-  return /*#__PURE__*/React.createElement("div", {
+  } = (0, _reactI18next.useTranslation)();
+  return /*#__PURE__*/_react.default.createElement("div", {
     id: id,
-    className: classnames('sdoc-selected-table-size-custom', {
+    className: (0, _classnames.default)('sdoc-selected-table-size-custom', {
       className
     })
-  }, /*#__PURE__*/React.createElement("span", null, t(text)), /*#__PURE__*/React.createElement("i", {
+  }, /*#__PURE__*/_react.default.createElement("span", null, t(text)), /*#__PURE__*/_react.default.createElement("i", {
     className: iconClassname
   }));
 };