@seafile/sdoc-editor 2.0.24 → 2.0.25-alph-0.0.1

package/dist/basic-sdk/extension/plugins/seatable-row/dialog/add-seatable-row-dialog/row-card-header-cell.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _reactDom = _interopRequireDefault(require("react-dom"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _ResizeHandle = _interopRequireDefault(require("./resize-handle/ResizeHandle"));
+var _constants = require("../../../../../../constants");
+var _basicSdk = require("../../../../../../basic-sdk");
+class RowCardHeaderCell extends _react.default.Component {
+  constructor(props) {
+    super(props);
+    (0, _defineProperty2.default)(this, "getHeaderCellWidth", () => {
+      const {
+        column,
+        rowCardType,
+        table
+      } = this.props;
+      const {
+        key,
+        width
+      } = column;
+      let headerCellWidth = width;
+      if (rowCardType === 'link') {
+        const tableId = table._id;
+        const draggedCellId = `${tableId}-${key}`;
+        const existedWidth = JSON.parse(localStorage.getItem(draggedCellId));
+        if (existedWidth) {
+          headerCellWidth = existedWidth;
+        }
+      }
+      return headerCellWidth;
+    });
+    (0, _defineProperty2.default)(this, "onDrag", e => {
+      const headerCellWidth = this.getWidthFromMouseEvent(e);
+      this.setState({
+        headerCellWidth
+      });
+    });
+    (0, _defineProperty2.default)(this, "onDragStart", e => {
+      this.setState({
+        resizing: true
+      });
+    });
+    (0, _defineProperty2.default)(this, "onDragEnd", e => {
+      const {
+        column,
+        table
+      } = this.props;
+      const columnKey = column.key;
+      const {
+        _id: tableId
+      } = table;
+      const draggedCellId = `${tableId}-${columnKey}`;
+      let width = this.getWidthFromMouseEvent(e);
+      this.setState({
+        resizing: false
+      });
+      const eventBus = _basicSdk.EventBus.getInstance();
+      eventBus.dispatch(_constants.EXTERNAL_EVENT.CHANGE_HEADER_WIDTH, {
+        id: draggedCellId,
+        width
+      });
+      localStorage.setItem(draggedCellId, width);
+    });
+    (0, _defineProperty2.default)(this, "getWidthFromMouseEvent", e => {
+      let right = e.pageX || e.touches && e.touches[0] && e.touches[0].pageX || e.changedTouches && e.changedTouches[e.changedTouches.length - 1].pageX;
+      if (e.pageX === 0) {
+        right = 0;
+      }
+      const left = _reactDom.default.findDOMNode(this.headerCell).getBoundingClientRect().left;
+      // add 5px is ResizeHandle component DOM width, and the draggable column minimum width is 50px
+      return Math.max(right - left + 5, 50);
+    });
+    this.state = {
+      resizing: false,
+      headerCellWidth: this.getHeaderCellWidth(),
+      isDraggable: props.rowCardType === 'link'
+    };
+  }
+  render() {
+    const {
+      column
+    } = this.props;
+    const {
+      headerCellWidth,
+      resizing,
+      isDraggable
+    } = this.state;
+    const {
+      name,
+      key
+    } = column;
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: (0, _classnames.default)('row-card-column-name text-truncate position-relative', {
+        'row-card-column--resizing': resizing
+      }, {
+        'row-card-draggable': isDraggable
+      })
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      ref: ref => this.headerCell = ref,
+      className: "row-card-column-name-item position-relative",
+      style: {
+        width: headerCellWidth
+      },
+      key: key,
+      title: name
+    }, /*#__PURE__*/_react.default.createElement("span", {
+      title: name
+    }, name)), isDraggable && /*#__PURE__*/_react.default.createElement(_ResizeHandle.default, {
+      style: {
+        right: 0
+      },
+      onDrag: this.onDrag,
+      onDragStart: this.onDragStart,
+      onDragEnd: this.onDragEnd
+    }));
+  }
+}
+var _default = exports.default = RowCardHeaderCell;

package/dist/basic-sdk/extension/plugins/seatable-row/dialog/add-seatable-row-dialog/row-card-header.js

@@ -0,0 +1,144 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _rowCardHeaderCell = _interopRequireDefault(require("./row-card-header-cell"));
+class RowCardHeader extends _react.default.Component {
+  constructor(props) {
+    super(props);
+    (0, _defineProperty2.default)(this, "onScrollControlClick", type => {
+      const tablesNav = this.linkRecordsHeader;
+      const {
+        offsetWidth,
+        scrollWidth,
+        scrollLeft
+      } = tablesNav;
+      let targetScrollLeft;
+      if (type === 'prev') {
+        if (scrollLeft === 0) {
+          return;
+        }
+        targetScrollLeft = scrollLeft - offsetWidth;
+        targetScrollLeft = targetScrollLeft > 0 ? targetScrollLeft : 0;
+      }
+      if (type === 'next') {
+        if (scrollLeft + offsetWidth === scrollWidth) {
+          return;
+        }
+        targetScrollLeft = scrollLeft + offsetWidth;
+        targetScrollLeft = targetScrollLeft > scrollWidth - offsetWidth ? scrollWidth - offsetWidth : targetScrollLeft;
+      }
+      if (this.state.canCardHeaderScroll) {
+        this.setState({
+          canCardHeaderScroll: false
+        });
+        let timer = null;
+        let step = (targetScrollLeft - scrollLeft) / 10;
+        step = step > 0 ? Math.ceil(step) : Math.floor(step);
+        timer = setInterval(() => {
+          tablesNav.scrollLeft = tablesNav.scrollLeft + step;
+          if (Math.abs(targetScrollLeft - tablesNav.scrollLeft) <= Math.abs(step)) {
+            tablesNav.scrollLeft = targetScrollLeft;
+            clearInterval(timer);
+            this.setState({
+              canCardHeaderScroll: true
+            });
+          }
+        }, 30);
+      }
+    });
+    (0, _defineProperty2.default)(this, "onScrollHeader", () => {
+      let {
+        scrollLeft
+      } = this.linkRecordsHeader;
+      this.props.setItemScrollLeft(scrollLeft, -1);
+      if (this.timer) {
+        clearTimeout(this.timer);
+      }
+      this.timer = setTimeout(() => {
+        this.props.setScrollLeft(scrollLeft);
+      }, 60);
+    });
+    (0, _defineProperty2.default)(this, "setHeaderScrollLeft", scrollLeft => {
+      this.linkRecordsHeader.scrollLeft = scrollLeft;
+    });
+    (0, _defineProperty2.default)(this, "getCardHeaderCells", () => {
+      const cardHeaderCells = [];
+      const {
+        renderedColumns,
+        rowCardType,
+        table
+      } = this.props;
+      // Start from the second column without name
+      for (let i = 1; i < renderedColumns.length; i++) {
+        const renderedColumn = renderedColumns[i];
+        cardHeaderCells.push( /*#__PURE__*/_react.default.createElement(_rowCardHeaderCell.default, {
+          key: renderedColumn.key,
+          column: renderedColumn,
+          rowCardType: rowCardType,
+          table: table
+        }));
+      }
+      return cardHeaderCells;
+    });
+    this.state = {
+      canCardHeaderScroll: true,
+      linkRecordsNavScrollWidth: 0,
+      linkRecordsNavWidth: 0
+    };
+  }
+  componentDidUpdate(prevProps, prevState) {
+    const {
+      offsetWidth,
+      scrollWidth
+    } = this.linkRecordsHeader;
+    if (prevState.linkRecordsNavScrollWidth !== scrollWidth || prevState.linkRecordsNavWidth !== offsetWidth) {
+      this.props.getCurrentDisplayRowMaxIndex();
+      this.setState({
+        linkRecordsNavScrollWidth: scrollWidth,
+        linkRecordsNavWidth: offsetWidth
+      });
+    }
+  }
+  render() {
+    const {
+      showScrollBtn,
+      scrollLeft,
+      cardHeaderClassName
+    } = this.props;
+    const {
+      linkRecordsNavWidth,
+      linkRecordsNavScrollWidth
+    } = this.state;
+    const cardHeaderCells = this.getCardHeaderCells();
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: `row-card-header ${cardHeaderClassName ? cardHeaderClassName : ''}`
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      className: "row-card-column-names records-column-names",
+      ref: ref => this.recordItemRef = ref
+    }, showScrollBtn && /*#__PURE__*/_react.default.createElement("span", {
+      className: (0, _classnames.default)('dtable-font', 'dtable-icon-left', 'row-card-scroll', 'link-scroll-prev', {
+        'scroll-active': scrollLeft > 0
+      }),
+      onClick: this.onScrollControlClick.bind(this, 'prev')
+    }), /*#__PURE__*/_react.default.createElement("div", {
+      className: "row-card-columns-container",
+      onScroll: this.onScrollHeader,
+      ref: ref => this.linkRecordsHeader = ref
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      className: "d-inline-flex"
+    }, cardHeaderCells)), showScrollBtn && /*#__PURE__*/_react.default.createElement("span", {
+      className: (0, _classnames.default)('dtable-font', 'dtable-icon-right', 'row-card-scroll', 'link-scroll-next', {
+        'scroll-active': scrollLeft + linkRecordsNavWidth < linkRecordsNavScrollWidth
+      }),
+      onClick: this.onScrollControlClick.bind(this, 'next')
+    })));
+  }
+}
+var _default = exports.default = RowCardHeader;

package/dist/basic-sdk/extension/plugins/seatable-row/dialog/add-seatable-row-dialog/row-card-item.js

@@ -0,0 +1,161 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _react = _interopRequireWildcard(require("react"));
+var _dtableStore = require("dtable-store");
+var _helpers = require("../../helpers");
+var _constants = require("../../../../../../constants");
+var _basicSdk = require("../../../../../../basic-sdk");
+var _formatter = _interopRequireDefault(require("../../../seatable-tables/formatter"));
+const emptyComponent = /*#__PURE__*/_react.default.createElement("span", {
+  className: "row-cell-empty d-inline-block"
+});
+class RowCardItem extends _react.PureComponent {
+  constructor(props) {
+    super(props);
+    (0, _defineProperty2.default)(this, "setDraggedCell", draggedCell => {
+      this.setState({
+        draggedCell
+      });
+    });
+    (0, _defineProperty2.default)(this, "getRowRecord", () => {
+      return this.linkRowRecord();
+    });
+    (0, _defineProperty2.default)(this, "linkRowRecord", () => {
+      let {
+        row,
+        formulaRow,
+        columns,
+        table,
+        rowCardType
+      } = this.props;
+      const {
+        draggedCell
+      } = this.state;
+      const {
+        _id: tableId
+      } = table;
+      return columns.filter(column => column.key !== '0000').map(column => {
+        const {
+          key,
+          width
+        } = column;
+        const draggedCellId = `${tableId}-${key}`;
+        const existedWidth = JSON.parse(localStorage.getItem(draggedCellId));
+        let columnWidth = existedWidth && rowCardType === 'link' ? existedWidth : width;
+        if (draggedCell.id === draggedCellId) {
+          columnWidth = draggedCell.width;
+        }
+        let cellValue = row[column.key];
+        if ([_dtableStore.CellType.LINK, _dtableStore.CellType.LINK_FORMULA, _dtableStore.CellType.FORMULA].includes(column.type)) {
+          cellValue = formulaRow[column.key];
+        }
+        return /*#__PURE__*/_react.default.createElement("div", {
+          className: "row-cell-value text-truncate",
+          key: row._id + '_' + key,
+          style: {
+            width: columnWidth
+          }
+        }, /*#__PURE__*/_react.default.createElement(_formatter.default, {
+          isSample: true,
+          column: column,
+          cellValue: cellValue,
+          collaborators: (0, _helpers.getAllCollaborators)(),
+          components: {
+            emptyComponent
+          },
+          isSeatableRow: true
+        }));
+      });
+    });
+    (0, _defineProperty2.default)(this, "changeScroll", event => {
+      event.stopPropagation();
+      const {
+        setItemScrollLeft,
+        rowIdx
+      } = this.props;
+      if (this.scrollActive) {
+        this.scrollActive = false;
+        return;
+      }
+      if (setItemScrollLeft) setItemScrollLeft(this.cardRecordsItemRef.scrollLeft, rowIdx);
+    });
+    (0, _defineProperty2.default)(this, "setScrollLeft", scrollLeft => {
+      this.scrollActive = true;
+      this.cardRecordsItemRef.scrollLeft = scrollLeft;
+    });
+    (0, _defineProperty2.default)(this, "getScrollLeft", () => {
+      return this.cardRecordsItemRef.scrollLeft;
+    });
+    (0, _defineProperty2.default)(this, "setCardRecordsItemRef", ref => {
+      this.cardRecordsItemRef = ref;
+    });
+    this.state = {
+      draggedCell: {},
+      isShowTick: false
+    };
+  }
+  componentDidMount() {
+    const {
+      rowIdx,
+      onRef
+    } = this.props;
+    onRef && onRef(this, rowIdx);
+    const eventBus = _basicSdk.EventBus.getInstance();
+    this.unsubscribeChangeHeaderWidth = eventBus.subscribe(_constants.EXTERNAL_EVENT.CHANGE_HEADER_WIDTH, this.setDraggedCell);
+  }
+  componentWillUnmount() {
+    this.unsubscribeChangeHeaderWidth();
+  }
+  UNSAFE_componentWillUpdate(nextProps) {
+    const {
+      onRef
+    } = this.props;
+    onRef && onRef(this, nextProps.rowIdx);
+  }
+  render() {
+    const {
+      row,
+      columns,
+      isSelected,
+      onRowClick
+    } = this.props;
+    const nameColumn = columns.find(column => column.key === '0000');
+    const cellValue = row['0000'];
+    return /*#__PURE__*/_react.default.createElement("div", {
+      tabIndex: 0,
+      "aria-label": row['0000'],
+      className: "row-card-item",
+      onClick: onRowClick
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      className: "row-card-item-container"
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      className: "row-card-item-header"
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      className: "row-card-item-name seatable-row-card-name"
+    }, /*#__PURE__*/_react.default.createElement(_formatter.default, {
+      isSample: true,
+      column: nameColumn,
+      cellValue: cellValue,
+      collaborators: (0, _helpers.getAllCollaborators)(),
+      components: {
+        emptyComponent
+      }
+    })), isSelected && /*#__PURE__*/_react.default.createElement("span", {
+      className: "row-card-item-check dtable-font dtable-icon-check-circle"
+    })), /*#__PURE__*/_react.default.createElement("div", {
+      className: "row-card-item-content",
+      onScroll: this.changeScroll,
+      ref: this.setCardRecordsItemRef
+    }, /*#__PURE__*/_react.default.createElement("div", {
+      className: "d-inline-flex"
+    }, this.getRowRecord()))));
+  }
+}
+var _default = exports.default = RowCardItem;

package/dist/basic-sdk/extension/plugins/seatable-row/dialog/add-seatable-row-dialog/seatable-table-record.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _reactI18next = require("react-i18next");
+var _dtableUtils = require("dtable-utils");
+var _recordContent = _interopRequireDefault(require("./record-content"));
+const SeatableTableRecord = _ref => {
+  let {
+    table,
+    setSelectedRow
+  } = _ref;
+  const {
+    t
+  } = (0, _reactI18next.useTranslation)('sdoc-editor');
+  const renderedColumns = () => {
+    var _table$columns;
+    return table === null || table === void 0 ? void 0 : (_table$columns = table.columns) === null || _table$columns === void 0 ? void 0 : _table$columns.filter(column => {
+      if (column.type === _dtableUtils.CellType.LONG_TEXT) {
+        return false;
+      }
+      return true;
+    }).map(column => Object.assign({}, column, {
+      width: 100
+    }));
+  };
+  return /*#__PURE__*/_react.default.createElement(_recordContent.default, {
+    table: table,
+    renderedColumns: renderedColumns(),
+    columns: renderedColumns(),
+    rows: table.rows,
+    rowCardType: "link",
+    isAdditionEditorView: false,
+    showScrollBtn: !window.isMobile,
+    isShowRowCardHeader: true,
+    cardListClassName: window.isMobile ? 'mobile-link-row-card-list' : '',
+    cardHeaderClassName: window.isMobile ? 'mobile-link-row-card-header' : '',
+    noCardItemTip: t('No_linked_records'),
+    setSelectedRow: setSelectedRow,
+    t: t
+  });
+};
+var _default = exports.default = SeatableTableRecord;

package/dist/basic-sdk/extension/plugins/seatable-row/helpers.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateSeaTableTable = exports.isInsertSeaTableRowDisabled = exports.insertSeaTableRow = exports.getAllCollaborators = exports.generateSeaTableRow = void 0;
+var _slate = require("@seafile/slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _core = require("../../core");
+var _helpers = require("../seatable-column/helpers");
+var _constants = require("../../constants");
+var _helper = require("../paragraph/helper");
+const isInsertSeaTableRowDisabled = (editor, readonly) => {
+  if (readonly) return true;
+  const {
+    selection
+  } = editor;
+  if (selection === null) return true;
+  const [match] = _slate.Editor.nodes(editor, {
+    match: n => {
+      let type = (0, _core.getNodeType)(n);
+      if (!type && (0, _core.isTextNode)(n) && n.id) {
+        const parentNode = (0, _core.getParentNode)(editor.children, n.id);
+        type = (0, _core.getNodeType)(parentNode);
+      }
+      if (type.startsWith('header')) return true;
+      if (type === _constants.ELEMENT_TYPE.TITLE) return true;
+      if (type === _constants.ELEMENT_TYPE.SUBTITLE) return true;
+      if (type === _constants.ELEMENT_TYPE.CODE_BLOCK) return true;
+      if (type === _constants.ELEMENT_TYPE.ORDERED_LIST) return true;
+      if (type === _constants.ELEMENT_TYPE.UNORDERED_LIST) return true;
+      if (type === _constants.ELEMENT_TYPE.BLOCKQUOTE) return true;
+      if (type === _constants.ELEMENT_TYPE.LIST_ITEM) return true;
+      if (type === _constants.ELEMENT_TYPE.TABLE) return true;
+      if (type === _constants.ELEMENT_TYPE.TABLE_CELL) return true;
+      if (type === _constants.ELEMENT_TYPE.TABLE_ROW) return true;
+      if (type === _constants.ELEMENT_TYPE.CALL_OUT) return true;
+      if (type === _constants.ELEMENT_TYPE.MULTI_COLUMN) return true;
+      if (_slate.Editor.isVoid(editor, n)) return true;
+      return false;
+    },
+    universal: true
+  });
+  if (match) return true;
+  return false;
+};
+exports.isInsertSeaTableRowDisabled = isInsertSeaTableRowDisabled;
+const generateSeaTableRow = (table_id, selectedRowID, editor) => {
+  const table = editor.getTableById(table_id);
+  const columnWidth = {};
+  table.columns.forEach(item => {
+    columnWidth[item.key] = (0, _helpers.getColumnWidth)(item);
+  });
+  return {
+    id: _slugid.default.nice(),
+    type: _constants.SEATABLE_ROW,
+    table_id: table_id,
+    row_id: selectedRowID,
+    column_width: columnWidth,
+    children: [(0, _core.generateDefaultText)()]
+  };
+};
+exports.generateSeaTableRow = generateSeaTableRow;
+const insertSeaTableRow = function (editor, table_id, selectedRowID) {
+  let insertPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants.INSERT_POSITION.CURRENT;
+  const seatableRowNode = generateSeaTableRow(table_id, selectedRowID, editor);
+  if (insertPosition === _constants.INSERT_POSITION.AFTER) {
+    const path = _slate.Editor.path(editor, editor.selection);
+    const currentNode = (0, _core.getNode)(editor, [path[0]]);
+
+    // Insert into selection position if in empty paragraph nodes
+    if (currentNode.type === _constants.PARAGRAPH && (0, _helper.isEmptyNode)(currentNode)) {
+      _slate.Transforms.setNodes(editor, seatableRowNode);
+      return;
+    }
+    path && _slate.Transforms.insertNodes(editor, seatableRowNode, {
+      at: [path[0] + 1]
+    });
+    return;
+  }
+  _slate.Transforms.setNodes(editor, seatableRowNode);
+};
+exports.insertSeaTableRow = insertSeaTableRow;
+const updateSeaTableTable = (editor, props, options) => {
+  _slate.Transforms.setNodes(editor, {
+    ...props
+  }, options);
+};
+exports.updateSeaTableTable = updateSeaTableTable;
+const getAllCollaborators = () => {
+  const {
+    collaboratorManager
+  } = window.seafile || window.seafileConfig;
+  const collaborators = Object.values(collaboratorManager === null || collaboratorManager === void 0 ? void 0 : collaboratorManager.emailUserMap);
+  return collaborators;
+};
+exports.getAllCollaborators = getAllCollaborators;

package/dist/basic-sdk/extension/plugins/seatable-row/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _elementType = require("../../constants/element-type");
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = _interopRequireDefault(require("./render-elem"));
+const SeaTableRowPlugin = {
+  type: _elementType.SEATABLE_ROW,
+  nodeType: 'element',
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.default]
+};
+var _default = exports.default = SeaTableRowPlugin;

package/dist/basic-sdk/extension/plugins/seatable-row/menu/index.css

@@ -0,0 +1,3 @@
+.sdoc-insert-seatable-row-menu-popover .sdoc-seatable-selected-table-list-wrapper {
+  left: unset !important;
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _reactstrap = require("reactstrap");
+var _constants = require("../../../constants");
+var _dropdownMenuItem = _interopRequireDefault(require("../../../commons/dropdown-menu-item"));
+var _helpers = require("../helpers");
+var _seatableList = _interopRequireDefault(require("./seatable-list"));
+require("./index.css");
+const SeaTableRowMenu = _ref => {
+  let {
+    editor,
+    readonly,
+    toggle,
+    isHidden = false
+  } = _ref;
+  const disabled = (0, _helpers.isInsertSeaTableRowDisabled)(editor, readonly);
+  const menuConfig = _constants.MENUS_CONFIG_MAP[_constants.ELEMENT_TYPE.SEATABLE_ROW];
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_dropdownMenuItem.default, {
+    disabled: disabled,
+    menuConfig: menuConfig,
+    className: (0, _classnames.default)('pr-2 sdoc-dropdown-menu-item-relative', {
+      'sdoc-dropdown-menu-item-hidden': isHidden
+    })
+  }, !disabled && /*#__PURE__*/_react.default.createElement("i", {
+    className: "sdocfont sdoc-right-slide sdoc-dropdown-item-right-icon"
+  })), !disabled && /*#__PURE__*/_react.default.createElement(_reactstrap.UncontrolledPopover, {
+    target: menuConfig.id,
+    hideArrow: true,
+    trigger: "hover",
+    fade: false,
+    placement: "right-start",
+    className: "sdoc-menu-popover sdoc-dropdown-menu sdoc-sub-dropdown-menu sdoc-insert-seatable-row-menu-popover"
+  }, /*#__PURE__*/_react.default.createElement(_seatableList.default, {
+    editor: editor,
+    readonly: readonly,
+    toggle: toggle
+  })));
+};
+var _default = exports.default = SeaTableRowMenu;