@seafile/comment-editor 0.0.1-alpha.0

package/dist/basic-sdk/context.js

@@ -0,0 +1,275 @@
+"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 _urlParse = _interopRequireDefault(require("url-parse"));
+var _sdocServerApi = _interopRequireDefault(require("./api/sdoc-server-api"));
+var _seafileApi = _interopRequireDefault(require("./api/seafile-api"));
+class Context {
+  constructor() {
+    (0, _defineProperty2.default)(this, "initSettings", () => {
+      this.settings = window.seafile ? window.seafile : window.seafileConfig;
+      const {
+        name,
+        username,
+        avatarURL
+      } = this.settings;
+      const userInfo = {
+        name,
+        username,
+        avatar_url: avatarURL
+      };
+      this.user = userInfo;
+      if (this.settings['isSdocRevision']) {
+        const repoID = this.getSetting('repoID');
+        const siteRoot = this.getSetting('siteRoot');
+        const originFilePath = this.getSetting('originFilePath');
+        const originFileURL = `${siteRoot}lib/${repoID}/file${originFilePath}`;
+        this.settings['originFileURL'] = originFileURL;
+      }
+    });
+    (0, _defineProperty2.default)(this, "uploadLocalImage", imageFiles => {
+      const docUuid = this.getSetting('docUuid');
+      return this.api.uploadSdocImage(docUuid, imageFiles).then(res => {
+        const {
+          relative_path
+        } = res.data;
+        return relative_path;
+      });
+    });
+    (0, _defineProperty2.default)(this, "uploadLocalVideo", videoFiles => {
+      const docUuid = this.getSetting('docUuid');
+      return this.api.uploadSdocVideo(docUuid, videoFiles).then(res => {
+        const {
+          relative_path
+        } = res.data;
+        return relative_path;
+      });
+    });
+    this.settings = null;
+    this.sdocServerApi = null;
+    this.api = null;
+    this.config = null;
+  }
+  initApi() {
+    this.initSettings(); // lazy init context class
+    const server = this.getSetting('serviceUrl');
+    const token = this.getSetting('accessToken');
+    this.api = new _seafileApi.default(server, token);
+    const isOpenSocket = this.getSetting('isOpenSocket');
+    if (isOpenSocket) {
+      this.sdocServerApi = new _sdocServerApi.default(this.settings);
+    }
+  }
+  getSettings() {
+    return this.settings;
+  }
+  getSetting(key) {
+    if (this.settings[key] === false) return this.settings[key];
+    return this.settings[key] || '';
+  }
+  getPrintCss() {
+    const server = this.getSetting('serviceUrl');
+    const mediaUrl = this.getSetting('mediaUrl');
+    // const commonCss = `${server}${mediaUrl}css/seafile-ui.css`;
+    const fontCss = `${server}${mediaUrl}/sdoc-editor/sdoc-editor-font.css`;
+    return [fontCss];
+  }
+  updateSettings(update) {
+    for (let key in update) {
+      this.settings[key] = update[key];
+    }
+  }
+  getEditorConfig() {
+    // When you need to execute this function, make sure to get the latest configuration items
+    const {
+      docUuid,
+      accessToken,
+      sdocServer
+    } = this.getSettings();
+    this.config = {
+      docUuid,
+      accessToken,
+      sdocServer: new _urlParse.default(sdocServer).origin,
+      user: this.getUserInfo()
+    };
+    return this.config;
+  }
+  getFileContent() {
+    return this.sdocServerApi.getDocContent().then(res => {
+      this.settings['last_modify_user'] = res.data.last_modify_user;
+      return res;
+    });
+  }
+  normalizeSdocContent() {
+    return this.sdocServerApi.normalizeSdocContent();
+  }
+  saveContent(content) {
+    return this.sdocServerApi.saveDocContent(content);
+  }
+
+  /**
+   * @private Get DocUuid
+   */
+  getDocUuid() {
+    return this.getSetting('docUuid');
+  }
+  getCollaborators() {
+    return this.sdocServerApi.getCollaborators();
+  }
+  getUserInfo() {
+    return this.user;
+  }
+
+  // comments
+  listComments() {
+    return this.sdocServerApi.listComments();
+  }
+  insertComment(comment) {
+    return this.sdocServerApi.insertComment(comment);
+  }
+  deleteComment(commentId) {
+    return this.sdocServerApi.deleteComment(commentId);
+  }
+  updateComment(commentId, newComment) {
+    return this.sdocServerApi.updateComment(commentId, newComment);
+  }
+  insertReply(commentId, reply) {
+    return this.sdocServerApi.insertReply(commentId, reply);
+  }
+  deleteReply(commentId, replyId) {
+    return this.sdocServerApi.deleteReply(commentId, replyId);
+  }
+  updateReply(commentId, replyId, newReply) {
+    return this.sdocServerApi.updateReply(commentId, replyId, newReply);
+  }
+
+  // revision
+  startRevise() {
+    const repoID = this.getSetting('repoID');
+    const filePath = this.getSetting('docPath');
+    const fileUuid = this.getSetting('docUuid');
+    return this.api.startRevise(repoID, fileUuid, filePath);
+  }
+  getSeadocOriginFileContent() {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.getSeadocOriginFileContent(docUuid);
+  }
+  getSdocRevisionsCount() {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.getSdocRevisionsCount(docUuid);
+  }
+  getSdocRevisions(page, perPage) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.getSdocRevisions(docUuid, page, perPage);
+  }
+  publishRevision() {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.publishRevision(docUuid);
+  }
+  updateSdocRevision(sdocContent) {
+    const docUuid = this.getSetting('docUuid');
+    const docName = this.getSetting('docName');
+    return this.api.updateSdocRevision(docUuid, docName, sdocContent);
+  }
+  deleteSdocRevision() {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.deleteSdocRevision(docUuid);
+  }
+  deleteSdocOtherRevision(revisionId) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.deleteSdocOtherRevision(docUuid, revisionId);
+  }
+  getRevisionBaseVersionContent() {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.getRevisionBaseVersionContent(docUuid);
+  }
+  getPublishedRevisionContent() {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.getPublishedRevisionContent(docUuid);
+  }
+
+  // local files
+  getSdocLocalFiles(p, type) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.getSdocFiles(docUuid, p, type);
+  }
+  getSdocLocalFileId(p) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.getSdocFileId(docUuid, p);
+  }
+  getSdocLocalFileUrl(docUuid) {
+    const sdocServer = this.getSetting('serviceUrl');
+    return sdocServer + '/api/v2.1/seadoc/file/' + docUuid + '/?doc_uuid=' + docUuid;
+  }
+  copyImage(originDocUuid, imageList) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.asyncCopyImages(docUuid, originDocUuid, imageList);
+  }
+  getLinkFilesInfo(filesUrl) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.getLinkFilesInfo(docUuid, filesUrl);
+  }
+  getCopyMoveProgressView(taskId) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.getCopyMoveProgressView(docUuid, taskId);
+  }
+  searchSdocFiles(query, page, per_page) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.searchSdocFiles(docUuid, query, page, per_page);
+  }
+  getSearchFilesByFilename(query, page, per_page, search_type) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.searchFilesByFilename(docUuid, query, page, per_page, search_type);
+  }
+
+  // participants
+  listParticipants() {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.listParticipants(docUuid);
+  }
+  addParticipants(emails) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.addParticipants(docUuid, emails);
+  }
+  deleteParticipants(emails) {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.deleteParticipants(docUuid, emails);
+  }
+  listRelatedUsers() {
+    const docUuid = this.getSetting('docUuid');
+    return this.api.listRelatedUsers(docUuid);
+  }
+
+  // notification
+  listUnseenNotifications() {
+    const docUuid = this.getDocUuid();
+    return this.api.listUnseenNotifications(docUuid);
+  }
+  deleteUnseenNotifications(notificationIds) {
+    const docUuid = this.getDocUuid();
+    return this.api.deleteUnseenNotifications(docUuid, notificationIds);
+  }
+  readAllNotifications() {
+    const docUuid = this.getDocUuid();
+    return this.api.readAllNotifications(docUuid);
+  }
+  aiTranslate(text, lang) {
+    const docUuid = this.getDocUuid();
+    return this.api.aiTranslate(docUuid, text, lang);
+  }
+  writingAssistant(text, type, custom_prompt) {
+    const docUuid = this.getDocUuid();
+    return this.api.writingAssistant(docUuid, text, type, custom_prompt);
+  }
+  updateConfigUuid(docUuid) {
+    if (!this.config) return;
+    this.config['docUuid'] = docUuid;
+  }
+}
+const context = new Context();
+var _default = exports.default = context;

package/dist/basic-sdk/cursor/helper.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setCursor = exports.generateCursorData = exports.deleteCursor = void 0;
+var _randomcolor = _interopRequireDefault(require("randomcolor"));
+// selection: { anchor, focus }
+// cursor: { anchor, focus }
+
+const setCursor = (editor, user, location, cursorData) => {
+  const {
+    username: clientId
+  } = user;
+  if (!editor.cursors) editor.cursors = {};
+  if (location) {
+    const oldCursor = editor.cursors[clientId] ? editor.cursors[clientId] : {};
+    const newCursorData = {
+      ...oldCursor,
+      ...location,
+      ...cursorData
+    };
+    editor.cursors[clientId] = newCursorData;
+  } else {
+    delete editor.cursors[clientId];
+  }
+  editor.cursors = {
+    ...editor.cursors
+  };
+  return editor;
+};
+exports.setCursor = setCursor;
+const deleteCursor = (editor, username) => {
+  delete editor.cursors[username];
+  editor.cursors = {
+    ...editor.cursors
+  };
+  return editor;
+};
+exports.deleteCursor = deleteCursor;
+const generateCursorData = config => {
+  const {
+    user
+  } = config;
+  const options = {
+    luminosity: 'dark',
+    format: 'rgba',
+    alpha: 1
+  };
+  const color = (0, _randomcolor.default)(options);
+  return {
+    name: user.name,
+    cursor_color: color
+  };
+};
+exports.generateCursorData = generateCursorData;

package/dist/basic-sdk/cursor/use-cursors.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCursors = void 0;
+var _react = require("react");
+const useCursors = editor => {
+  const [cursors, setCursors] = (0, _react.useState)([]);
+  (0, _react.useEffect)(() => {
+    const cursors = Object.values(editor.cursors) || [];
+    setCursors(cursors);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  (0, _react.useEffect)(() => {
+    editor.onCursor = editorCursors => {
+      const cursors = Object.values(editorCursors) || [];
+      setCursors(cursors);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  return {
+    cursors,
+    setCursors
+  };
+};
+exports.useCursors = useCursors;

package/dist/basic-sdk/decorates/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePipDecorate = void 0;
+var _commentDecorate = require("../comment/comment-decorate");
+var _highlight = require("../highlight");
+var _useSelectionUpdate = _interopRequireDefault(require("../hooks/use-selection-update"));
+const pluginDecorates = [_highlight.highlightDecorate, _commentDecorate.commentDecorate];
+const usePipDecorate = editor => {
+  (0, _useSelectionUpdate.default)();
+  const decorates = pluginDecorates.map(decorate => {
+    return decorate(editor);
+  });
+  return entry => {
+    let ranges = [];
+    const addRanges = newRanges => {
+      if (newRanges !== null && newRanges !== void 0 && newRanges.length) ranges = [...ranges, ...newRanges];
+    };
+    decorates.forEach(decorate => {
+      addRanges(decorate(entry));
+    });
+    return ranges;
+  };
+};
+exports.usePipDecorate = usePipDecorate;

package/dist/basic-sdk/editor/comment-article.js

@@ -0,0 +1,104 @@
+"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 _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _scrollIntoViewIfNeeded = _interopRequireDefault(require("scroll-into-view-if-needed"));
+var _constants = require("../constants");
+var _useCursors = require("../cursor/use-cursors");
+var _decorates = require("../decorates");
+var _extension = require("../extension");
+var _constants2 = require("../extension/constants");
+var _renderCommentEditorElement = _interopRequireDefault(require("../extension/render/render-comment-editor-element"));
+var _eventBus = _interopRequireDefault(require("../utils/event-bus"));
+var _eventHandler = _interopRequireDefault(require("../utils/event-handler"));
+const CommentArticle = _ref => {
+  let {
+    editor,
+    slateValue,
+    updateSlateValue,
+    type
+  } = _ref;
+  const {
+    cursors
+  } = (0, _useCursors.useCursors)(editor);
+  const decorate = (0, _decorates.usePipDecorate)(editor);
+  // 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) {
+      // Compatible with the editor which unload table plugin
+      editor.reSetTableSelectedRange && 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 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) {
+      //
+    }
+  }, []);
+  const onKeyDown = (0, _react.useCallback)(event => {
+    if ((0, _isHotkey.default)('enter', event)) {
+      event.preventDefault();
+      const eventBus = _eventBus.default.getInstance();
+      eventBus.dispatch(_constants.INTERNAL_EVENT.COMMENT_EDITOR_POST_COMMENT, event);
+      return;
+    }
+    if ((0, _isHotkey.default)('shift+enter', event)) {
+      event.preventDefault();
+      _slate.Editor.insertBreak(editor);
+      return;
+    }
+    eventProxy.onKeyDown(event);
+  }, [eventProxy, editor]);
+  return /*#__PURE__*/_react.default.createElement(_slateReact.Slate, {
+    editor: editor,
+    value: slateValue,
+    onChange: updateSlateValue
+  }, /*#__PURE__*/_react.default.createElement(_slateReact.Editable, {
+    id: "sdoc-editor",
+    scrollSelectionIntoView: handleScrollIntoView,
+    cursors: cursors,
+    renderElement: props => (0, _renderCommentEditorElement.default)({
+      ...props,
+      commentType: type
+    }),
+    renderLeaf: _extension.renderLeaf,
+    onMouseDown: onMouseDown,
+    decorate: decorate,
+    onCut: eventProxy.onCut,
+    onCopy: eventProxy.onCopy,
+    onCompositionStart: eventProxy.onCompositionStart,
+    onCompositionUpdate: eventProxy.onCompositionUpdate,
+    onCompositionEnd: eventProxy.onCompositionEnd,
+    onKeyDown: onKeyDown,
+    onBeforeInput: eventProxy.onBeforeInput
+  }));
+};
+var _default = exports.default = CommentArticle;

package/dist/basic-sdk/editor/sdoc-comment-editor.js

@@ -0,0 +1,128 @@
+"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 _fileLoading = _interopRequireDefault(require("../components/file-loading"));
+var _constants = require("../constants");
+var _context = _interopRequireDefault(require("../context"));
+var _extension = require("../extension");
+var _core = require("../extension/core");
+var _commentEditorToolbar = _interopRequireDefault(require("../extension/toolbar/comment-editor-toolbar"));
+var _useCollaborators = require("../hooks/use-collaborators");
+var _useScrollContext = require("../hooks/use-scroll-context");
+var _layout = require("../layout");
+var _nodeId = _interopRequireDefault(require("../node-id"));
+var _socket = require("../socket");
+var _commentArticle = _interopRequireDefault(require("./comment-article"));
+const SdocCommentEditor = /*#__PURE__*/(0, _react.forwardRef)((_ref, ref) => {
+  let {
+    editor: propsEditor,
+    document,
+    isReloading,
+    type,
+    onSubmit,
+    submitBtnText,
+    onCancel
+  } = _ref;
+  const [slateValue, setSlateValue] = (0, _react.useState)(document.elements);
+  const commentEditorContainerRef = (0, _react.useRef)(null);
+  const validEditor = (0, _react.useMemo)(() => {
+    if (propsEditor) return propsEditor;
+    const defaultEditor = (0, _extension.createCommentEditor)();
+    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.COMMENT_EDITOR_EDIT_AREA_WIDTH; // default width
+
+    return newEditor;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // useMount: focus editor
+  (0, _react.useEffect)(() => {
+    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);
+      }
+      // Force refresh to fix comment list
+      setSlateValue([...validEditor.children]);
+    }
+    // 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]);
+  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(_fileLoading.default, null));
+  }
+  const handleFocusEditor = e => {
+    if (e.target === commentEditorContainerRef.current) {
+      const focusPoint = _slate.Editor.end(validEditor, []);
+      (0, _core.focusEditor)(validEditor, focusPoint);
+    }
+  };
+  return /*#__PURE__*/_react.default.createElement(_layout.EditorContainer, {
+    editor: validEditor
+  }, /*#__PURE__*/_react.default.createElement(_useCollaborators.CollaboratorsProvider, null, /*#__PURE__*/_react.default.createElement("div", {
+    className: "sdoc-comment-editor-wrapper"
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    ref: commentEditorContainerRef,
+    className: "article sdoc-comment-editor",
+    onClick: handleFocusEditor
+  }, /*#__PURE__*/_react.default.createElement(_useScrollContext.ScrollContext.Provider, {
+    value: {
+      scrollRef: commentEditorContainerRef
+    }
+  }, /*#__PURE__*/_react.default.createElement(_commentArticle.default, {
+    type: type,
+    editor: validEditor,
+    slateValue: slateValue,
+    updateSlateValue: setSlateValue
+  }))), /*#__PURE__*/_react.default.createElement(_commentEditorToolbar.default, {
+    editor: validEditor,
+    onSubmit: onSubmit,
+    submitBtnText: submitBtnText,
+    onCancel: onCancel
+  }))));
+});
+var _default = exports.default = SdocCommentEditor;

package/dist/basic-sdk/editor/sdoc-editor.js

@@ -0,0 +1,50 @@
+"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 _provider = _interopRequireDefault(require("../comment/provider"));
+var _constants = require("../constants");
+var _context = _interopRequireDefault(require("../context"));
+var _extension = require("../extension");
+var _nodeId = _interopRequireDefault(require("../node-id"));
+var _rightPanel = _interopRequireDefault(require("../right-panel"));
+var _socket = require("../socket");
+const SdocEditor = /*#__PURE__*/(0, _react.forwardRef)((_ref, ref) => {
+  let {
+    editor: propsEditor,
+    document,
+    isReloading,
+    showComment,
+    isShowHeaderToolbar = true,
+    showOutline = true
+  } = _ref;
+  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
+  }, []);
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_provider.default, {
+    children: _rightPanel.default,
+    editor: validEditor
+  }, /*#__PURE__*/_react.default.createElement(_rightPanel.default, {
+    editor: validEditor
+  })));
+});
+var _default = exports.default = SdocEditor;

package/dist/basic-sdk/extension/commons/Inline-bug-fix-wrapper/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 _react = _interopRequireDefault(require("react"));
+const InlineBugFixer = () => {
+  return /*#__PURE__*/_react.default.createElement("span", {
+    contentEditable: false,
+    style: {
+      fontSize: 0
+    }
+  }, String.fromCodePoint(160) /* Non-breaking space */);
+};
+var _default = exports.default = InlineBugFixer;