@seafile/sdoc-editor 2.0.66 → 2.0.67

package/dist/plugin-module/assets/css/sdoc-viewer.css

@@ -0,0 +1,14 @@
+.sdoc-editor-container .sdoc-editor-content.no-outline .sdoc-article-container {
+  margin-left: 0 !important;
+}
+
+.sdoc-editor-container.mobile .sdoc-editor-content.readonly .sdoc-article-container {
+  padding: 0;
+  width: 100% !important;
+  min-width: 100% !important;
+}
+
+.sdoc-editor-container.mobile .sdoc-editor-content.readonly .article {
+  width: 100vw !important;
+  padding: 1rem;
+}

package/dist/plugin-module/assets/css/sdoc-wiki-viewer.css

@@ -0,0 +1,28 @@
+.sdoc-editor-container {
+  flex: 1;
+  display: flex;
+  min-height: 0;
+}
+
+.sdoc-wiki-scroll-container {
+  display: flex;
+  overflow: auto;
+}
+
+.sdoc-wiki-scroll-container .sdoc-article-container {
+  width: 100%;
+}
+
+.sdoc-wiki-scroll-container .sdoc-article-container .article .sdoc-header-2 {
+  border-bottom: 1px solid #ccc;
+}
+
+.sdoc-wiki-outline-container {
+  height: 80%;
+  overflow-y: auto;
+  padding-right: 1rem;
+  position: fixed;
+  right: 0;
+  top: 97px;
+  width: 300px;
+}

package/dist/plugin-module/constants/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SUPPORTED_SIDE_OPERATION_TYPE = exports.SEATABLE_TABLE = exports.SEATABLE_ROW = exports.SEATABLE_COLUMN = exports.MENUS_CONFIG_MAP = exports.CHART_PREVIEW_TYPE = exports.CHART = void 0;
+// extension plugins
+const CHART = exports.CHART = 'chart';
+const SEATABLE_COLUMN = exports.SEATABLE_COLUMN = 'seatable_column';
+const SEATABLE_ROW = exports.SEATABLE_ROW = 'seatable_row';
+const SEATABLE_TABLE = exports.SEATABLE_TABLE = 'seatable_table';
+const CHART_PREVIEW_TYPE = exports.CHART_PREVIEW_TYPE = {
+  VIEW: 'view',
+  EDITOR: 'editor',
+  FULL_SCREEN: 'fullScreen'
+};
+const SUPPORTED_SIDE_OPERATION_TYPE = exports.SUPPORTED_SIDE_OPERATION_TYPE = [SEATABLE_TABLE, SEATABLE_ROW];
+const MENUS_CONFIG_MAP = exports.MENUS_CONFIG_MAP = {
+  [SEATABLE_ROW]: {
+    id: `sdoc_${SEATABLE_ROW}`,
+    iconClass: 'sdocfont sdoc-seatable-row',
+    text: 'SeaTable_row'
+  },
+  [SEATABLE_COLUMN]: {
+    id: `sdoc_${SEATABLE_COLUMN}`,
+    iconClass: 'sdocfont sdoc-choose-column',
+    text: 'SeaTable_column'
+  },
+  [SEATABLE_TABLE]: {
+    id: SEATABLE_TABLE,
+    iconClass: 'sdocfont sdoc-seatable-table',
+    type: SEATABLE_TABLE,
+    text: 'SeaTable_table'
+  },
+  [CHART]: {
+    id: `sdoc_${CHART}`,
+    iconClass: 'sdocfont sdoc-chart',
+    text: 'chart'
+  }
+};

package/dist/plugin-module/editor/editable-article.js

@@ -0,0 +1,243 @@
+"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 _slate = require("@seafile/slate");
+var _slateReact = require("@seafile/slate-react");
+var _scrollIntoViewIfNeeded = _interopRequireDefault(require("scroll-into-view-if-needed"));
+var _comment = _interopRequireDefault(require("@/basic-sdk/comment"));
+var _constants = require("@/basic-sdk/constants");
+var _useCursors = require("@/basic-sdk/cursor/use-cursors");
+var _decorates = require("@/basic-sdk/decorates");
+var _extension = require("@/basic-sdk/extension");
+var _constants2 = require("@/basic-sdk/extension/constants");
+var _core = require("@/basic-sdk/extension/core");
+var _helpers = require("@/basic-sdk/extension/plugins/table/helpers");
+var _highlight = require("@/basic-sdk/highlight");
+var _useForceUpdate = _interopRequireDefault(require("@/basic-sdk/hooks/use-force-update"));
+var _useScrollContext = require("@/basic-sdk/hooks/use-scroll-context");
+var _domUtils = require("@/basic-sdk/utils/dom-utils");
+var _eventBus = _interopRequireDefault(require("@/basic-sdk/utils/event-bus"));
+var _eventHandler = _interopRequireDefault(require("@/basic-sdk/utils/event-handler"));
+var _layout = require("../layout");
+var _renderElements = _interopRequireDefault(require("../render/render-elements"));
+const EditableArticle = _ref => {
+  let {
+    showComment = true,
+    editor,
+    slateValue,
+    updateSlateValue
+  } = _ref;
+  const {
+    cursors
+  } = (0, _useCursors.useCursors)(editor);
+  const decorate = (0, _decorates.usePipDecorate)(editor);
+  const forceUpdate = (0, _useForceUpdate.default)();
+
+  // init eventHandler
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const eventProxy = (0, _react.useMemo)(() => new _eventHandler.default(editor), []);
+  const onMouseDown = (0, _react.useCallback)(event => {
+    if (event.button === 0) {
+      const isPreventReset = (0, _helpers.isPreventResetTableSelectedRange)(event);
+      if (!isPreventReset) {
+        editor.reSetTableSelectedRange();
+        const eventBus = _eventBus.default.getInstance();
+        eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+      }
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const scrollRef = (0, _useScrollContext.useScrollContext)();
+  const onReloadComment = () => {
+    forceUpdate();
+  };
+  (0, _react.useEffect)(() => {
+    const eventBus = _eventBus.default.getInstance();
+    const unsubscribeReloadComment = eventBus.subscribe(_constants.INTERNAL_EVENT.RELOAD_COMMENT, onReloadComment);
+    return () => {
+      unsubscribeReloadComment();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const onKeyDown = (0, _react.useCallback)(event => {
+    const {
+      scrollTop,
+      clientHeight
+    } = scrollRef.current;
+    eventProxy.onKeyDown(event);
+    if (event.key === 'ArrowLeft') {
+      if (!(0, _core.isSelectionAtBlockStart)(editor)) return;
+    }
+    if (event.key === 'ArrowUp' || event.key === 'ArrowLeft') {
+      if (scrollTop === 0) return;
+      let prevNode = (0, _core.getPrevNode)(editor);
+      if (!prevNode) return;
+      const domNode = _slateReact.ReactEditor.toDOMNode(editor, prevNode[0]);
+      const domHeight = (0, _domUtils.getDomHeight)(domNode);
+      const isScrollUp = true;
+      const {
+        y
+      } = (0, _domUtils.getCursorPosition)(isScrollUp);
+      if (y >= domHeight) return;
+      scrollRef.current.scroll(0, Math.max(0, scrollTop - domHeight));
+      return;
+    }
+    if (event.key === 'ArrowRight') {
+      if (!(0, _core.isSelectionAtBlockEnd)(editor)) return;
+    }
+    if (event.key === 'ArrowDown' || event.key === 'ArrowRight') {
+      let nextNode = (0, _core.getNextNode)(editor);
+      if (!nextNode) return;
+      const domNode = _slateReact.ReactEditor.toDOMNode(editor, nextNode[0]);
+      const domHeight = (0, _domUtils.getDomHeight)(domNode);
+      const isScrollUp = false;
+      const {
+        y
+      } = (0, _domUtils.getCursorPosition)(isScrollUp);
+      if (clientHeight - y >= domHeight) return;
+      scrollRef.current.scroll(0, Math.max(0, scrollTop + domHeight));
+      return;
+    }
+    if (event.key === 'Backspace') {
+      const [currentNode] = (0, _core.getCurrentNode)(editor);
+      let prevNode = null;
+      let prevPath = null;
+      if ((0, _core.getPrevNode)(editor)) {
+        [prevNode, prevPath] = (0, _core.getPrevNode)(editor);
+      }
+      // If the cursor is collapsed at the beginning, and the current line is not empty, is not a CODE_LINE, and the previous line is a CODE_LINE.
+      const isCursorCollapsed = _slate.Range.isCollapsed(editor.selection);
+      if (isCursorCollapsed && prevNode && (0, _core.isSelectionAtBlockStart)(editor) && !(0, _core.isCurrentLineEmpty)(editor) && prevNode.type === _constants2.CODE_LINE && currentNode.type !== _constants2.CODE_LINE) {
+        if (!(0, _core.isCurrentLineHasText)(currentNode)) {
+          const prevNodeText = _slate.Node.string(prevNode);
+          _slate.Transforms.removeNodes(editor, {
+            at: prevPath
+          });
+          _slate.Transforms.insertText(editor, prevNodeText);
+          event.preventDefault();
+        } else {
+          const path = prevPath;
+          path[path.length] = 0;
+          const end = prevNode.children[0].text.length;
+          const range = {
+            anchor: {
+              path,
+              offset: end
+            },
+            focus: {
+              path,
+              offset: end
+            }
+          };
+          _slate.Transforms.select(editor, range);
+          event.preventDefault();
+        }
+      }
+      const {
+        y
+      } = (0, _domUtils.getCursorPosition)();
+
+      // above viewport
+      if (y < 0) {
+        const newY = Math.abs(y);
+        if ((0, _core.isSelectionAtBlockStart)(editor)) {
+          const prevNode = (0, _core.getPrevNode)(editor);
+          if (!prevNode) return;
+          const domNode = _slateReact.ReactEditor.toDOMNode(editor, prevNode[0]);
+          const domHeight = (0, _domUtils.getDomHeight)(domNode);
+          const node = (0, _core.getAboveBlockNode)(editor);
+          if (!node) return;
+          const currentDomNode = _slateReact.ReactEditor.toDOMNode(editor, node[0]);
+          const marginTop = (0, _domUtils.getDomMarginTop)(currentDomNode);
+          scrollRef.current.scroll(0, Math.max(0, scrollTop - (newY + domHeight + marginTop)));
+        } else {
+          scrollRef.current.scroll(0, Math.max(0, scrollTop - newY));
+        }
+        return;
+      }
+
+      // insider viewport
+      if (y >= 0 && y <= clientHeight) {
+        if ((0, _core.isSelectionAtBlockStart)(editor)) {
+          const prevNode = (0, _core.getPrevNode)(editor);
+          if (!prevNode) return;
+          const domNode = _slateReact.ReactEditor.toDOMNode(editor, prevNode[0]);
+          const domHeight = (0, _domUtils.getDomHeight)(domNode);
+          if (y >= domHeight) return;
+          // Scroll up the height of the previous block
+          scrollRef.current.scroll(0, Math.max(0, scrollTop - domHeight));
+          return;
+        }
+      }
+
+      // below viewport
+      if (y > clientHeight) {
+        if ((0, _core.isSelectionAtBlockStart)(editor)) {
+          // y: text top border
+          scrollRef.current.scroll(0, Math.max(0, scrollTop + (y - clientHeight)));
+        } else {
+          const marginBottom = 11.2;
+          const {
+            y: newY
+          } = (0, _domUtils.getCursorPosition)(false);
+          const rectBottom = newY + marginBottom; // text bottom border
+          scrollRef.current.scroll(0, Math.max(0, scrollTop + (rectBottom - clientHeight)));
+        }
+        return;
+      }
+    }
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [scrollRef]);
+  const handleScrollIntoView = (0, _react.useCallback)((editor, domRange) => {
+    try {
+      const {
+        selection
+      } = editor;
+      // Do not scroll into view, when focus on image
+      const [imageNodeEntry] = _slate.Editor.nodes(editor, {
+        match: n => [_constants2.IMAGE, _constants2.IMAGE_BLOCK].includes(n.type),
+        at: selection
+      });
+      if (imageNodeEntry) return;
+      const focusedNode = _slate.Node.get(editor, selection.focus.path);
+      const domNode = _slateReact.ReactEditor.toDOMNode(editor, focusedNode);
+      if (!domNode) return;
+      (0, _scrollIntoViewIfNeeded.default)(domNode, {
+        'scrollMode': 'if-needed'
+      });
+    } catch (error) {
+      //
+    }
+  }, []);
+  return /*#__PURE__*/_react.default.createElement(_slateReact.Slate, {
+    editor: editor,
+    value: slateValue,
+    onChange: updateSlateValue
+  }, /*#__PURE__*/_react.default.createElement(_layout.ArticleContainer, {
+    editor: editor
+  }, /*#__PURE__*/_react.default.createElement(_react.Fragment, null, /*#__PURE__*/_react.default.createElement(_extension.ContextToolbar, null), /*#__PURE__*/_react.default.createElement(_highlight.SetNodeToDecorations, null), /*#__PURE__*/_react.default.createElement(_slateReact.Editable, {
+    scrollSelectionIntoView: handleScrollIntoView,
+    cursors: cursors,
+    renderElement: _renderElements.default,
+    renderLeaf: _extension.renderLeaf,
+    onKeyDown: onKeyDown,
+    onMouseDown: onMouseDown,
+    decorate: decorate,
+    onCut: eventProxy.onCut,
+    onCopy: eventProxy.onCopy,
+    onCompositionStart: eventProxy.onCompositionStart,
+    id: "sdoc-editor",
+    "aria-label": "textbox"
+  })), /*#__PURE__*/_react.default.createElement(_extension.SideToolbar, null), showComment && /*#__PURE__*/_react.default.createElement(_comment.default, {
+    editor: editor,
+    type: "editor"
+  })));
+};
+var _default = exports.default = EditableArticle;

package/dist/plugin-module/editor/plugin-editor.js

@@ -0,0 +1,213 @@
+"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 _slate = require("@seafile/slate");
+var _deepCopy = _interopRequireDefault(require("deep-copy"));
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _basicSdk = require("@/basic-sdk");
+var _constants = require("@/basic-sdk/constants");
+var _extension = require("@/basic-sdk/extension");
+var _core = require("@/basic-sdk/extension/core");
+var _helpers = require("@/basic-sdk/extension/plugins/ai/ai-module/helpers");
+var _useColorContext = require("@/basic-sdk/hooks/use-color-context");
+var _nodeId = _interopRequireDefault(require("@/basic-sdk/node-id"));
+var _socket = require("@/basic-sdk/socket");
+var _commonLoading = _interopRequireDefault(require("@/components/common-loading"));
+var _context = _interopRequireDefault(require("@/context"));
+var _constants2 = require("../../constants");
+var _insertElementDialog = _interopRequireDefault(require("../gloable-ui/insert-element-dialog"));
+var _layout = require("../layout");
+var _headerToolbar = _interopRequireDefault(require("../toolbar/header-toolbar"));
+var _editableArticle = _interopRequireDefault(require("./editable-article"));
+const PluginEditor = /*#__PURE__*/(0, _react.forwardRef)((_ref, ref) => {
+  let {
+    editor: propsEditor,
+    document,
+    isReloading,
+    showComment,
+    isShowHeaderToolbar = true,
+    showOutline = true
+  } = _ref;
+  // eslint-disable-next-line no-unused-vars
+  const [showFullScreen, setShowFullScreen] = (0, _react.useState)(false);
+  const validEditor = (0, _react.useMemo)(() => {
+    if (propsEditor) return propsEditor;
+    const defaultEditor = (0, _extension.createDefaultEditor)();
+    const editorConfig = _context.default.getEditorConfig();
+    const newEditor = (0, _nodeId.default)((0, _socket.withSocketIO)(defaultEditor, {
+      document,
+      config: editorConfig
+    }));
+    const {
+      cursors
+    } = document;
+    newEditor.cursors = cursors || {};
+    newEditor.width = _constants.PAGE_EDIT_AREA_WIDTH; // default width
+    return newEditor;
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const [slateValue, setSlateValue] = (0, _react.useState)(document.elements);
+
+  // Fix: The editor's children are not updated when the document is updated in revision
+  // In revision mode, the document is updated, but the editor's children are not updated,as onValueChange override the new document.elements. This unexpected action cause the editor to display the old content
+  (0, _react.useEffect)(() => {
+    setSlateValue(document.elements);
+  }, [document.elements]);
+  (0, _react.useEffect)(() => {
+    validEditor.readonly = false;
+    return () => {
+      validEditor.selection = null;
+    };
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  // useMount: init socket connection
+  (0, _react.useEffect)(() => {
+    if (propsEditor) return;
+    validEditor.openConnection();
+    return () => {
+      validEditor.closeConnection();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // useMount: focus editor
+  (0, _react.useEffect)(() => {
+    const timer = setTimeout(() => {
+      const [firstNode] = validEditor.children;
+      if (firstNode) {
+        const [firstNodeFirstChild] = firstNode.children;
+        if (firstNodeFirstChild) {
+          const endOfFirstNode = _slate.Editor.end(validEditor, [0, 0]);
+          const range = {
+            anchor: endOfFirstNode,
+            focus: endOfFirstNode
+          };
+          (0, _core.focusEditor)(validEditor, range);
+        }
+      }
+    }, 300);
+    return () => {
+      clearTimeout(timer);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const onRefreshDocument = (0, _react.useCallback)(() => {
+    window.location.reload();
+  }, []);
+
+  // useMount: refresh document
+  (0, _react.useEffect)(() => {
+    const eventBus = _basicSdk.EventBus.getInstance();
+    eventBus.subscribe(_constants2.EXTERNAL_EVENT.REFRESH_DOCUMENT, onRefreshDocument);
+
+    // Remove aiMarks on special conditions like unexpected exit or refresh page using AI
+    const hasAIMark = !_slate.Editor.nodes(validEditor, {
+      at: [],
+      match: n => _slate.Text.isText(n) && n.sdoc_ai === true
+    }).next().done;
+    if (hasAIMark) {
+      (0, _helpers.removeMarks)(validEditor);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [onRefreshDocument]);
+
+  // Handle presentation fullscreen mode
+  const handleFullScreenPresentation = (0, _react.useCallback)(_ref2 => {
+    let {
+      isShowFullScreen
+    } = _ref2;
+    if (isShowFullScreen) {
+      setShowFullScreen(true);
+    }
+  }, []);
+  (0, _react.useEffect)(() => {
+    const eventBus = _basicSdk.EventBus.getInstance();
+    const unsubscribePresentationFullScreen = eventBus.subscribe(_constants2.EXTERNAL_EVENT.TOGGLE_PRESENTATION_MODE, handleFullScreenPresentation);
+    return () => {
+      unsubscribePresentationFullScreen();
+    };
+  }, [handleFullScreenPresentation]);
+  (0, _react.useEffect)(() => {
+    const handleExit = e => {
+      if ((0, _isHotkey.default)('esc', e)) {
+        e.preventDefault();
+        if (window.document.fullscreenElement) {
+          window.document.exitFullscreen();
+        }
+      }
+    };
+    const onFullscreenChange = () => {
+      if (!window.document.fullscreenElement) {
+        setShowFullScreen(false);
+      }
+    };
+    window.addEventListener('keydown', handleExit);
+    window.document.addEventListener('fullscreenchange', onFullscreenChange);
+    return () => {
+      window.removeEventListener('keydown', handleExit);
+      window.document.removeEventListener('fullscreenchange', onFullscreenChange);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // The parent component can call the method of this component through ref
+  (0, _react.useImperativeHandle)(ref, () => ({
+    setSlateValue: document => {
+      // Force update of editor's child elements
+      validEditor.children = document.elements;
+      setSlateValue([...document.elements]);
+    },
+    updateDocumentVersion: document => {
+      validEditor.updateDocumentVersion(document);
+    },
+    // get value
+    getSlateValue: () => {
+      return (0, _deepCopy.default)({
+        ...document,
+        elements: slateValue
+      });
+    }
+
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }), [document, validEditor, slateValue]);
+  const onValueChange = value => {
+    const eventBus = _basicSdk.EventBus.getInstance();
+    setSlateValue(value);
+    // After the content is updated, update the search content
+    setTimeout(() => {
+      eventBus.dispatch(_constants.INTERNAL_EVENT.UPDATE_SEARCH_REPLACE_HIGHLIGHT, value);
+    }, 0);
+  };
+  if (isReloading) {
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: "h-100 w-100 d-flex align-items-center justify-content-center"
+    }, /*#__PURE__*/_react.default.createElement(_commonLoading.default, null));
+  }
+  const isShowComment = typeof showComment === 'boolean' ? showComment : true;
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_layout.EditorContainer, {
+    editor: validEditor
+  }, /*#__PURE__*/_react.default.createElement(_useColorContext.ColorProvider, null, isShowHeaderToolbar && /*#__PURE__*/_react.default.createElement(_headerToolbar.default, {
+    editor: validEditor
+  }), /*#__PURE__*/_react.default.createElement(_layout.EditorContent, {
+    docValue: slateValue,
+    showOutline: showOutline !== null && showOutline !== void 0 ? showOutline : true,
+    editor: validEditor,
+    showComment: isShowComment
+  }, /*#__PURE__*/_react.default.createElement(_editableArticle.default, {
+    editor: validEditor,
+    slateValue: slateValue,
+    updateSlateValue: onValueChange,
+    showComment: isShowComment
+  })))), /*#__PURE__*/_react.default.createElement(_insertElementDialog.default, {
+    editor: validEditor
+  }));
+});
+var _default = exports.default = PluginEditor;

package/dist/plugin-module/error-boundary/error-page.css

@@ -0,0 +1,16 @@
+.error-page {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  overflow: hidden;
+}
+
+.error-page .error-tip {
+  color: red;
+}
+
+.error-page .error-button {
+  margin-top: 20px;
+}

package/dist/plugin-module/error-boundary/error-page.js

@@ -0,0 +1,37 @@
+"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 _reactI18next = require("react-i18next");
+var _reactstrap = require("reactstrap");
+var _context = _interopRequireDefault(require("@/context"));
+require("./error-page.css");
+function ErrorPage(_ref) {
+  let {
+    t
+  } = _ref;
+  const normalizeSdoc = (0, _react.useCallback)(async () => {
+    const res = await _context.default.normalizeSdocContent();
+    const {
+      success
+    } = res.data;
+    if (success) {
+      // eslint-disable-next-line no-restricted-globals
+      location.reload(true);
+    }
+  }, []);
+  return /*#__PURE__*/_react.default.createElement("div", {
+    className: "error-page"
+  }, /*#__PURE__*/_react.default.createElement("span", {
+    className: "error-tip"
+  }, t('Sdoc_error_tip')), /*#__PURE__*/_react.default.createElement(_reactstrap.Button, {
+    className: "error-button",
+    onClick: () => normalizeSdoc()
+  }, t('Repair')));
+}
+var _default = exports.default = (0, _reactI18next.withTranslation)('sdoc-editor')(ErrorPage);

package/dist/plugin-module/error-boundary/index.js

@@ -0,0 +1,33 @@
+"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 _errorPage = _interopRequireDefault(require("./error-page"));
+class ErrorBoundary extends _react.PureComponent {
+  constructor(props) {
+    super(props);
+    this.state = {
+      hasError: false
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return {
+      hasError: true
+    };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.log(error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError) {
+      return /*#__PURE__*/_react.default.createElement(_errorPage.default, null);
+    }
+    return this.props.children;
+  }
+}
+exports.default = ErrorBoundary;