@seafile/seafile-editor 1.0.0 → 1.0.2

package/src/extension/plugins/node-id/helpers.js

@@ -1,61 +0,0 @@
-import deepCopy from 'deep-copy';
-import slugid from 'slugid';
-import * as OPERATION from './constants';
-import ObjectUtils from '../../../utils/object-utils';
-
-export const decorateOperation = (operation) => {
-  let newOperation = deepCopy(operation);
-  const { type } = newOperation;
-  switch (type) {
-    case OPERATION.INSERT_NODE: {
-      let { node } = newOperation;
-      if (!node.id) node.id = slugid.nice();  // generate an id for insert node
-      break;
-    }
-    case OPERATION.SPLIT_NODE: {
-      // child: split [7, 0] -> [[7, 0],[7, 1]]
-      // parent: split [[7, 0], [7, 1]] -> [[7], [8]]
-      const { properties = {} } = newOperation;
-      // need generate a new id for new node
-      properties.id = slugid.nice();
-      break;
-    }
-    default: {
-      break;
-    }
-  }
-
-  return newOperation;
-};
-
-export const replaceNodeId = (node) => {
-  if (!ObjectUtils.isObject(node)) return node;
-  if (ObjectUtils.hasProperty(node, 'children')) {
-    return {
-      ...node,
-      id: slugid.nice(),
-      children: replacePastedDataId(node.children),
-    };
-  }
-
-  return {
-    ...node,
-    id: slugid.nice(),
-  };
-};
-
-export const replacePastedDataId = (pastedData) => {
-  // If children is malformed, return a list of correct child nodes
-  if (ObjectUtils.isObject(pastedData)) {
-    return replaceNodeId(pastedData);
-  }
-
-  if (!Array.isArray(pastedData)) return [{ id: slugid.nice(), text: '' }];
-  return pastedData.map(item => {
-    item.id = slugid.nice();
-    if (item.children) {
-      item.children = replacePastedDataId(item.children);
-    }
-    return item;
-  });
-};

package/src/extension/plugins/node-id/index.js

@@ -1,7 +0,0 @@
-import withNodeId from './with-node-id';
-
-const NodeIdPlugin = {
-  editorPlugin: withNodeId,
-};
-
-export default NodeIdPlugin;

package/src/extension/plugins/node-id/with-node-id.js

@@ -1,37 +0,0 @@
-import { decorateOperation, replacePastedDataId } from './helpers';
-
-const catchSlateFragment = /data-slate-fragment="(.+?)"/m;
-
-const getSlateFragmentAttribute = (dataTransfer) => {
-  const htmlData = dataTransfer.getData('text/html');
-  const [, fragment] = htmlData.match(catchSlateFragment) || [];
-  return fragment;
-};
-
-const withNodeId = (editor) => {
-  const { apply } = editor;
-  const newEditor = editor;
-
-  newEditor.apply = (op) => {
-    const newOp = decorateOperation(op);
-    apply(newOp);
-  };
-
-  // rewrite insert fragment data
-  newEditor.insertFragmentData = (data) => {
-    const fragment = data.getData('application/x-slate-fragment') || getSlateFragmentAttribute(data);
-
-    if (fragment) {
-      const decoded = decodeURIComponent(window.atob(fragment));
-      const parsed = JSON.parse(decoded);
-      const newData = replacePastedDataId(parsed);
-      newEditor.insertFragment(newData);
-      return newEditor;
-    }
-  };
-
-  return newEditor;
-
-};
-
-export default withNodeId;

package/src/extension/plugins/paragraph/helper.js

@@ -1,9 +0,0 @@
-import { Transforms } from 'slate';
-import { PARAGRAPH } from '../../constants/element-types';
-import { focusEditor } from '../../core';
-
-export const transformToParagraph = (editor, focusLocation) => {
-  if (!editor.selection) return;
-  Transforms.setNodes(editor, { type: PARAGRAPH });
-  focusEditor(editor, focusLocation);
-};

package/src/extension/plugins/paragraph/index.js

@@ -1,12 +0,0 @@
-import { PARAGRAPH } from '../../constants/element-types';
-import withParagraph from './plugin';
-import renderParagraph from './render-elem';
-
-const ParagraphPlugin = {
-  type: PARAGRAPH,
-  nodeType: 'element',
-  editorPlugin: withParagraph,
-  renderElements: [renderParagraph]
-};
-
-export default ParagraphPlugin;

package/src/extension/plugins/paragraph/plugin.js

@@ -1,40 +0,0 @@
-import { Editor, Node, Range, Transforms } from 'slate';
-import { getPrevNode, getSelectedNodeEntryByType, isStartPoint } from '../../core';
-import { CHECK_LIST_ITEM, PARAGRAPH } from '../../constants/element-types';
-
-const withParagraph = (editor) => {
-  const { deleteBackward } = editor;
-  const newEditor = editor;
-
-  newEditor.deleteBackward = (unit) => {
-    const { selection } = newEditor;
-    if (!selection) {
-      deleteBackward(unit);
-      return;
-    }
-    const selectedParagraphNodeEntry = getSelectedNodeEntryByType(newEditor, PARAGRAPH);
-    if (selectedParagraphNodeEntry) {
-      const isCollapsed = Range.isCollapsed(selection);
-      const isCursorAtStartOfLine = isStartPoint(editor, selection.anchor, selection);
-      const previousNodeEntry = getPrevNode(newEditor);
-      const isCheckListAtPrevious = previousNodeEntry && previousNodeEntry[0].type === CHECK_LIST_ITEM;
-      // If cursor is at start of line and previous node is check list,remove the paragraph
-      // instead of delete backward, which fix the bug that the check list will be removed when user
-      // press backspace at start of line.
-      if (isCollapsed && isCursorAtStartOfLine && isCheckListAtPrevious) {
-        const focusPoint = Editor.end(newEditor, previousNodeEntry[1]);
-        const selectedParagraphText = Node.string(selectedParagraphNodeEntry[0]);
-        const checkListText = Node.string(previousNodeEntry[0]);
-        const newCheckListText = checkListText + selectedParagraphText;
-        Transforms.insertText(newEditor, newCheckListText, { at: previousNodeEntry[1] });
-        Transforms.removeNodes(newEditor, { at: selectedParagraphNodeEntry[1] });
-        Transforms.select(newEditor, focusPoint);
-        return;
-      }
-    }
-    return deleteBackward(unit);
-  };
-  return newEditor;
-};
-
-export default withParagraph;

package/src/extension/plugins/paragraph/render-elem.js

@@ -1,11 +0,0 @@
-import React from 'react';
-
-const renderParagraph = ({ element, attributes, children }) => {
-  return (
-    <p data-id={element.id} data-root='true' {...attributes}>
-      {children}
-    </p>
-  );
-};
-
-export default renderParagraph;

package/src/extension/plugins/table/constant.js

@@ -1,3 +0,0 @@
-export const TABLE_CELL_NODE_NAME = 'td';
-export const TABLE_ROW_NODE_NAME = 'tr';
-export const TABLE_BODY_NODE_NAME = 'tbody';

package/src/extension/plugins/table/helper.js

@@ -1,175 +0,0 @@
-import { Editor, Node, Path, Transforms, insertFragment } from 'slate';
-import { generateTable, generateTableRow } from './model';
-import { CODE_BLOCK, COLUMN, FORMULA, PARAGRAPH, TABLE, TABLE_CELL, TABLE_ROW } from '../../constants/element-types';
-import { focusEditor, generateElement } from '../../core';
-import getEventTransfer from '../../../containers/custom/get-event-transfer';
-import { htmlDeserializer } from '../../../utils/deserialize-html';
-
-export const isDisabled = (editor, readonly) => {
-  const { selection } = editor;
-  if (readonly || !selection) return true;
-  const disableTypes = [TABLE, TABLE_ROW, TABLE_CELL, FORMULA, CODE_BLOCK, COLUMN];
-  const [nodeEntry] = Editor.nodes(editor, {
-    match: n => disableTypes.includes(n.type),
-    mode: 'highest'
-  });
-  if (nodeEntry) return true;
-  return false;
-};
-
-export const isInTable = (editor) => {
-  const { selection } = editor;
-  if (!selection) return false;
-  const [nodeEntry] = getTableEntry(editor);
-  if (!nodeEntry) return false;
-  return true;
-};
-
-export const insertTable = (editor, rowNum, columnNum) => {
-  const table = generateTable({ rowNum, columnNum });
-  Editor.insertNode(editor, table);
-  // Auto focus at the first cell in table
-  const [nodeEntry] = Editor.nodes(editor, {
-    match: node => node.id === table.id,
-    mode: 'highest'
-  });
-  const focusPoint = Editor.start(editor, nodeEntry[1]);
-  focusEditor(editor, focusPoint);
-};
-
-export const getTableFocusingInfos = (editor) => {
-  if (!isInTable(editor)) return null;
-  const nodeEntries = Editor.nodes(editor, {
-    match: n => [TABLE, TABLE_ROW, TABLE_CELL].includes(n.type),
-  });
-  const nodeEntryList = Array.from(nodeEntries);
-  const [tableEntry, rowEntry, cellEntry] = nodeEntryList;
-  const columnIndex = cellEntry[1].at(-1);
-  const rowIndex = cellEntry[1].at(-2);
-  return { cellEntry, tableEntry, rowEntry, columnIndex, rowIndex };
-};
-
-export const selectCellByGrid = (editor, rowIndex, colIndex) => {
-  const { tableEntry: [, tablePath] } = getTableFocusingInfos(editor);
-  const selectRange = Editor.range(editor, tablePath.concat(rowIndex, colIndex));
-  focusEditor(editor, selectRange);
-};
-
-export const getSelectedTableCells = (editor) => {
-  const [tableEntry] = getTableEntry(editor);
-  if (!tableEntry) return [];
-
-  const [tableNode] = tableEntry;
-  const tableRows = tableNode.children;
-  const selectGrid = getSelectGrid(editor);
-
-  const { startRowIndex, endRowIndex, startColIndex, endColIndex } = selectGrid;
-
-  const selectedTableRows = [];
-  for (let rowIndex = startRowIndex; rowIndex <= endRowIndex; rowIndex++) {
-    const currentRow = tableRows[rowIndex];
-    let selectedTableCells = [];
-    for (let colIndex = startColIndex; colIndex <= endColIndex; colIndex++) {
-      const currentCell = currentRow.children[colIndex];
-      selectedTableCells.push(currentCell);
-    }
-
-    selectedTableRows.push(generateTableRow({ childrenOrText: selectedTableCells }));
-    selectedTableCells = [];
-  }
-
-  return [generateTable({ childrenOrText: selectedTableRows })];
-};
-
-export const getSelectGrid = (editor) => {
-  const [tableEntry] = getTableEntry(editor);
-  if (!tableEntry) return null;
-
-  const selectedTableCells = document.querySelectorAll('.selected-cell');
-  if (selectedTableCells.length === 0) return null;
-
-  const selectGrid = Array.from(selectedTableCells).reduce((grid, cell) => {
-    const { startRowIndex, endRowIndex, startColIndex, endColIndex } = grid;
-    const { cellIndex: colIndex } = cell;
-    const { rowIndex } = cell.parentNode;
-    if (endRowIndex === -1 || rowIndex > endRowIndex) grid.endRowIndex = rowIndex;
-    if (startRowIndex === -1 || rowIndex < startRowIndex) grid.startRowIndex = rowIndex;
-    if (endColIndex === -1 || colIndex > endColIndex) grid.endColIndex = colIndex;
-    if (startColIndex === -1 || colIndex < startColIndex) grid.startColIndex = colIndex;
-    return { ...grid };
-  }, { startRowIndex: -1, endRowIndex: -1, startColIndex: -1, endColIndex: -1 });
-
-  return selectGrid;
-};
-
-export const pasteContentIntoTable = (editor, content) => {
-  const data = content;
-  let { fragment, text, type, html } = getEventTransfer(data);
-  const newText = text.replace(/\r\n|\n/g, ' ');
-
-  if (!fragment && type === 'text') {
-    Transforms.insertText(this.editor, newText);
-    return;
-  }
-
-  if (type === 'html') {
-    fragment = htmlDeserializer(html);
-  }
-
-  if (fragment.length === 1) {
-    if (fragment[0].type === TABLE) {
-      const clipboardTable = fragment[0];
-      const {
-        tableEntry: [tableNode, tablePath],
-        rowEntry: [rowNode],
-        rowIndex,
-        columnIndex
-      } = getTableFocusingInfos(editor);
-      const tableWidth = rowNode.children.length;
-      const tableHeight = tableNode.children.length;
-      clipboardTable.children.some((clipRow, clipRowIndex) => {
-        const currentInsertPath = tablePath.concat(rowIndex + clipRowIndex + rowIndex);
-        // Out of table
-        if (rowIndex + clipRowIndex >= tableHeight + 1) return true;
-        clipRow.children.some((clipCol, clipColIndex) => {
-          // Out of table
-          if (columnIndex + clipColIndex >= tableWidth + 1) return true;
-          const currentCellPath = currentInsertPath.concat(columnIndex + clipColIndex);
-          const currentCellChildPath = currentCellPath.concat(0);
-          Transforms.removeNodes(editor, { at: currentCellChildPath });
-          if (clipCol.children.type !== PARAGRAPH) {
-            const text = Node.string(clipCol);
-            const newChild = generateElement(PARAGRAPH, { childrenOrText: text });
-            Transforms.insertNodes(editor, newChild, { at: currentCellChildPath });
-          } else {
-            Transforms.insertNodes(editor, clipCol.children, { at: currentCellChildPath });
-          }
-          return false;
-        });
-        return false;
-      });
-    } else if (fragment[0].type === PARAGRAPH) {
-      insertFragment(editor, fragment);
-    } else {
-      Transforms.insertText(editor, text.replace(/\r\n|\n/g, ' '));
-    }
-  }
-};
-
-export const jumpOutTableInEditor = (editor) => {
-  const [tableEntry] = getTableEntry(editor);
-  if (!tableEntry) return;
-
-  const [, tablePath] = tableEntry;
-  const tableParentPath = Path.parent(tablePath);
-  const insertPath = tableParentPath.concat(tablePath.at(-1) + 1);
-  Transforms.insertNodes(editor, generateElement(PARAGRAPH), { at: insertPath });
-  Transforms.select(editor, { path: insertPath.concat(0), offset: 0 });
-};
-
-export const getTableEntry = (editor) => {
-  return Editor.nodes(editor, {
-    match: n => n.type === TABLE,
-    mode: 'highest'
-  });
-};

package/src/extension/plugins/table/index.js

@@ -1,15 +0,0 @@
-import { TABLE } from '../../constants/element-types';
-import TableMenu from './menu';
-import { AlignmentDropDown, ColumnOperationDropDownList, RowOperationDropDownList, RemoveTableMenu } from './menu/table-operator';
-import withTable from './plugin';
-import RenderTableContainer, { RenderTableCell, RenderTableRow } from './render-elem';
-
-const TablePlugin = {
-  type: TABLE,
-  nodeType: 'element',
-  editorMenus: [TableMenu, AlignmentDropDown, ColumnOperationDropDownList, RowOperationDropDownList, RemoveTableMenu],
-  editorPlugin: withTable,
-  renderElements: [RenderTableCell, RenderTableRow, RenderTableContainer],
-};
-
-export default TablePlugin;

package/src/extension/plugins/table/menu/index.js

@@ -1,69 +0,0 @@
-import React, { useCallback, useMemo, useState } from 'react';
-import PropTypes from 'prop-types';
-import MenuItem from '../../../commons/menu/menu-item';
-import { MENUS_CONFIG_MAP } from '../../../constants';
-import { TABLE } from '../../../constants/element-types';
-import { isDisabled, isInTable } from '../helper';
-import TableSizeSelector from './table-size-selector';
-
-import './style.css';
-
-const menuConfig = MENUS_CONFIG_MAP[TABLE];
-const propTypes = {
-  editor: PropTypes.object.isRequired,
-  readonly: PropTypes.bool.isRequired,
-  className: PropTypes.string,
-  isRichEditor: PropTypes.bool,
-};
-
-const TableMenu = ({ editor, readonly, className, isRichEditor }) => {
-  const [isOpenTableSizeSelector, setIsOpenTableSizeSelector] = useState(false);
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  const disabled = useMemo(() => isDisabled(editor, readonly), [editor.selection, readonly]);
-  const isActive = isInTable(editor);
-
-  const onSelectorHide = useCallback(() => {
-    setIsOpenTableSizeSelector(false);
-    unregisterEvent();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [setIsOpenTableSizeSelector]);
-
-  const registerEvent = useCallback(() => {
-    document.addEventListener('click', onSelectorHide);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  const unregisterEvent = useCallback(() => {
-    document.removeEventListener('click', onSelectorHide);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  const onMouseDown = useCallback((e) => {
-    e.stopPropagation();
-    e.preventDefault();
-    setIsOpenTableSizeSelector(true);
-    registerEvent();
-  }, [setIsOpenTableSizeSelector, registerEvent]);
-
-  return (
-    <div className='sf-table-menu-item'>
-      <MenuItem
-        isRichEditor={isRichEditor}
-        className={className}
-        disabled={disabled}
-        isActive={isActive}
-        onMouseDown={onMouseDown}
-        editor={editor}
-        {...menuConfig}
-      />
-      {isOpenTableSizeSelector && (
-        <TableSizeSelector
-          editor={editor}
-        />)}
-    </div>
-  );
-};
-
-TableMenu.propTypes = propTypes;
-
-export default TableMenu;

package/src/extension/plugins/table/menu/table-operator.js

@@ -1,101 +0,0 @@
-import React, { useMemo } from 'react';
-import MenuDropDown from '../../../commons/menu/menu-drop-down';
-import { MENUS_CONFIG_MAP, TABLE_SUBMENU_MAP, TEXT_ALIGN } from '../../../constants';
-import MenuItem from '../../../commons/menu/menu-item';
-import { changeCellAlign, insertColumn, insertRow, removeColumn, removeRow, removeTable } from '../table-operations';
-
-const AlignmentDropDown = ({ editor, readonly }) => {
-  const alignmentOperationDropDownList = useMemo(() => [
-    {
-      ...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_ALIGN_LEFT],
-      handleClick: (item) => changeCellAlign(editor, TEXT_ALIGN.LEFT)
-    },
-    {
-      ...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_ALIGN_CENTER],
-      handleClick: (item) => changeCellAlign(editor, TEXT_ALIGN.CENTER)
-    },
-    {
-      ...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_ALIGN_RIGHT],
-      handleClick: (item) => changeCellAlign(editor, TEXT_ALIGN.RIGHT)
-    },
-  ], [editor]);
-
-  return (
-    <MenuDropDown
-      editor={editor}
-      readonly={readonly}
-      isDisabled={false}
-      dropDownList={alignmentOperationDropDownList}
-      isShowListItemIcon={true}
-      {...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_ALIGN_LEFT]}
-    />
-  );
-};
-
-const ColumnOperationDropDownList = ({ editor, readonly }) => {
-  const columnOperationDropDownList = useMemo(() => [
-    {
-      ...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_INSERT_COLUMN],
-      handleClick: (item) => insertColumn(editor)
-    },
-    {
-      ...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_REMOVE_COLUMN],
-      handleClick: (item) => removeColumn(editor)
-    },
-  ], [editor]);
-
-  return (
-    <MenuDropDown
-      editor={editor}
-      readonly={readonly}
-      isDisabled={false}
-      dropDownList={columnOperationDropDownList}
-      {...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_INSERT_COLUMN]}
-    />
-  );
-};
-
-const RowOperationDropDownList = ({ editor, readonly }) => {
-  const rowOperationDropDownList = useMemo(() => [
-    {
-      ...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_INSERT_ROW],
-      handleClick: (item) => insertRow(editor)
-    },
-    {
-      ...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_REMOVE_ROW],
-      handleClick: (item) => removeRow(editor)
-    },
-  ], [editor]);
-
-  return (
-    <MenuDropDown
-      editor={editor}
-      readonly={readonly}
-      isDisabled={false}
-      dropDownList={rowOperationDropDownList}
-      {...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_INSERT_ROW]}
-    />
-  );
-};
-
-const RemoveTableMenu = ({ editor, readonly, className, isRichEditor }) => {
-  return (
-    <MenuItem
-      isRichEditor={isRichEditor}
-      className={className}
-      disabled={false}
-      isActive={false}
-      onMouseDown={() => removeTable(editor)}
-      editor={editor}
-
-      {...MENUS_CONFIG_MAP[TABLE_SUBMENU_MAP.TABLE_DELETE_TABLE]}
-    />
-  );
-};
-
-export {
-  AlignmentDropDown,
-  ColumnOperationDropDownList,
-  RowOperationDropDownList,
-  RemoveTableMenu
-};

package/src/extension/plugins/table/menu/table-size-selector.js

@@ -1,71 +0,0 @@
-import React, { useCallback, useMemo, useState } from 'react';
-import propType from 'prop-types';
-import classNames from 'classnames';
-import { insertTable } from '../helper';
-
-import './style.css';
-
-const TableSizeSelector = ({ editor }) => {
-  const [selectedGridInfo, setSelectedGridInfo] = useState({ row: 0, column: 0 });
-  const [showingGridInfo, setShowingGridInfo] = useState({ row: 4, column: 4 });
-
-  const preRenderTableGrid = useCallback((rowIndex, columnIndex) => {
-    const selectedRowNums = rowIndex + 1;
-    const selectedColumnNums = columnIndex + 1;
-    let preRenderRowNum = selectedRowNums + 1;
-    let preRenderColumnNum = selectedColumnNums + 1;
-    if (preRenderRowNum < 4) {
-      preRenderRowNum = 4;
-    } else if (preRenderRowNum > 10) {
-      preRenderRowNum = 10;
-    }
-    if (preRenderColumnNum < 4) {
-      preRenderColumnNum = 4;
-    } else if (preRenderColumnNum > 10) {
-      preRenderColumnNum = 10;
-    }
-    setSelectedGridInfo({ row: selectedRowNums, column: selectedColumnNums });
-    setShowingGridInfo({ row: preRenderRowNum, column: preRenderColumnNum });
-  }, []);
-
-  const handleClickTableCell = useCallback(() => {
-    insertTable(editor, selectedGridInfo.row, selectedGridInfo.column);
-  }, [editor, selectedGridInfo]);
-
-  const generateTableGrid = useCallback((rowNum, columnNum) => {
-    const { row: selectedRowIndex, column: selectedColumnIndex } = selectedGridInfo;
-    const rowElements = [];
-    for (let rowIndex = 0; rowIndex < rowNum; rowIndex++) {
-      const columnElements = [];
-      for (let columnIndex = 0; columnIndex < columnNum; columnIndex++) {
-        const isCellSelected = selectedRowIndex > rowIndex && selectedColumnIndex > columnIndex;
-        columnElements.push(
-          <div
-            onClick={handleClickTableCell}
-            onMouseEnter={() => preRenderTableGrid(rowIndex, columnIndex)}
-            className={classNames('sf-table-selector-cell', { selected: isCellSelected })}
-            key={`${rowIndex}-${columnIndex}`}
-          ></div>
-        );
-      }
-      rowElements.push(<div className='sf-table-row' key={rowIndex}>{columnElements}</div>);
-    }
-    return rowElements;
-  }, [handleClickTableCell, preRenderTableGrid, selectedGridInfo]);
-
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  const tableGridElement = useMemo(() => generateTableGrid(showingGridInfo.row, showingGridInfo.column), [generateTableGrid]);
-
-  return (
-    <div className='sf-table-size-selector-card'>
-      <p className='sf-table-grid-info'>{`${selectedGridInfo.row} x ${selectedGridInfo.column}`}</p>
-      {tableGridElement}
-    </div>
-  );
-};
-
-TableSizeSelector.propTypes = {
-  editor: propType.object.isRequired,
-};
-
-export default TableSizeSelector;