@seafile/sdoc-editor 2.0.82 → 2.0.83

package/dist/context.js

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

package/dist/cursor/helper.js

@@ -0,0 +1,43 @@
+"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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _randomcolor = _interopRequireDefault(require("randomcolor"));
+// selection: { anchor, focus }
+// cursor: { anchor, focus }
+
+var setCursor = exports.setCursor = function setCursor(editor, user, location, cursorData) {
+  var clientId = user.username;
+  if (!editor.cursors) editor.cursors = {};
+  if (location) {
+    var oldCursor = editor.cursors[clientId] ? editor.cursors[clientId] : {};
+    var newCursorData = (0, _objectSpread2["default"])((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, oldCursor), location), cursorData);
+    editor.cursors[clientId] = newCursorData;
+  } else {
+    delete editor.cursors[clientId];
+  }
+  editor.cursors = (0, _objectSpread2["default"])({}, editor.cursors);
+  return editor;
+};
+var deleteCursor = exports.deleteCursor = function deleteCursor(editor, username) {
+  delete editor.cursors[username];
+  editor.cursors = (0, _objectSpread2["default"])({}, editor.cursors);
+  return editor;
+};
+var generateCursorData = exports.generateCursorData = function generateCursorData(config) {
+  var user = config.user;
+  var options = {
+    luminosity: 'dark',
+    format: 'rgba',
+    alpha: 1
+  };
+  var color = (0, _randomcolor["default"])(options);
+  return {
+    name: user.name,
+    cursor_color: color
+  };
+};

package/dist/cursor/use-cursors.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useCursors = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _react = require("react");
+var useCursors = exports.useCursors = function useCursors(editor) {
+  var _useState = (0, _react.useState)([]),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    cursors = _useState2[0],
+    setCursors = _useState2[1];
+  (0, _react.useEffect)(function () {
+    var cursors = Object.values(editor.cursors) || [];
+    setCursors(cursors);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  (0, _react.useEffect)(function () {
+    editor.onCursor = function (editorCursors) {
+      var cursors = Object.values(editorCursors) || [];
+      setCursors(cursors);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  return {
+    cursors: cursors,
+    setCursors: setCursors
+  };
+};

package/dist/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 _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _commentDecorate = require("../comment/comment-decorate");
+var _highlight = require("../highlight");
+var _useSelectionUpdate = _interopRequireDefault(require("../hooks/use-selection-update"));
+var pluginDecorates = [_highlight.highlightDecorate, _commentDecorate.commentDecorate];
+var usePipDecorate = exports.usePipDecorate = function usePipDecorate(editor) {
+  (0, _useSelectionUpdate["default"])();
+  var decorates = pluginDecorates.map(function (decorate) {
+    return decorate(editor);
+  });
+  return function (entry) {
+    var ranges = [];
+    var addRanges = function addRanges(newRanges) {
+      if (newRanges !== null && newRanges !== void 0 && newRanges.length) ranges = [].concat((0, _toConsumableArray2["default"])(ranges), (0, _toConsumableArray2["default"])(newRanges));
+    };
+    decorates.forEach(function (decorate) {
+      addRanges(decorate(entry));
+    });
+    return ranges;
+  };
+};

package/dist/editor/comment-article.js

@@ -0,0 +1,108 @@
+"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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+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 _useCursors2 = 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"));
+var CommentArticle = function CommentArticle(_ref) {
+  var editor = _ref.editor,
+    slateValue = _ref.slateValue,
+    updateSlateValue = _ref.updateSlateValue,
+    type = _ref.type;
+  var _useCursors = (0, _useCursors2.useCursors)(editor),
+    cursors = _useCursors.cursors;
+  var decorate = (0, _decorates.usePipDecorate)(editor);
+  // init eventHandler
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  var eventProxy = (0, _react.useMemo)(function () {
+    return new _eventHandler["default"](editor);
+  }, []);
+  var onMouseDown = (0, _react.useCallback)(function (event) {
+    if (event.button === 0) {
+      // Compatible with the editor which unload table plugin
+      editor.reSetTableSelectedRange && editor.reSetTableSelectedRange();
+      var eventBus = _eventBus["default"].getInstance();
+      eventBus.dispatch(_constants.INTERNAL_EVENT.CANCEL_TABLE_SELECT_RANGE);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var handleScrollIntoView = (0, _react.useCallback)(function (editor, domRange) {
+    try {
+      var selection = editor.selection;
+      // Do not scroll into view, when focus on image
+      var _Editor$nodes = _slate.Editor.nodes(editor, {
+          match: function match(n) {
+            return [_constants2.IMAGE, _constants2.IMAGE_BLOCK].includes(n.type);
+          },
+          at: selection
+        }),
+        _Editor$nodes2 = (0, _slicedToArray2["default"])(_Editor$nodes, 1),
+        imageNodeEntry = _Editor$nodes2[0];
+      if (imageNodeEntry) return;
+      var focusedNode = _slate.Node.get(editor, selection.focus.path);
+      var domNode = _slateReact.ReactEditor.toDOMNode(editor, focusedNode);
+      if (!domNode) return;
+      (0, _scrollIntoViewIfNeeded["default"])(domNode, {
+        'scrollMode': 'if-needed'
+      });
+    } catch (error) {
+      //
+    }
+  }, []);
+  var onKeyDown = (0, _react.useCallback)(function (event) {
+    if ((0, _isHotkey["default"])('enter', event)) {
+      event.preventDefault();
+      var 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: function renderElement(props) {
+      return (0, _renderCommentEditorElement["default"])((0, _objectSpread2["default"])((0, _objectSpread2["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;