@seafile/sdoc-editor 2.0.115 → 2.0.116

package/dist/extension/plugins/ai/ai-module/helpers.js

@@ -4,7 +4,11 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.removeMarks = exports.markdownTableRenderer = exports.insertHtmlTransferredNodes = void 0;
+exports.validateNestedStructure = exports.removeMarks = exports.markdownTableRenderer = exports.isRangeOverlapping = exports.insertHtmlTransferredNodes = exports.handleSelectElements = exports.getSelectedChildren = exports.findValidLists = exports.findInsertableLists = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createForOfIteratorHelper"));
 var _react = _interopRequireDefault(require("react"));
 var _slate = require("@seafile/slate");
 var _constants = require("../../../constants");
@@ -38,6 +42,204 @@ var markdownTableRenderer = exports.markdownTableRenderer = function markdownTab
     }
   });
 };
+var isRangeOverlapping = exports.isRangeOverlapping = function isRangeOverlapping(rangeA, rangeB) {
+  var aStart = _slate.Range.start(rangeA);
+  var aEnd = _slate.Range.end(rangeA);
+  var bStart = _slate.Range.start(rangeB);
+  var bEnd = _slate.Range.end(rangeB);
+
+  // The starting or ending point of A is within the range of B
+  var aStartInB = (_slate.Path.isBefore(bStart.path, aStart.path) || _slate.Path.equals(bStart.path, aStart.path)) && (_slate.Path.isBefore(aStart.path, bEnd.path) || _slate.Path.equals(aStart.path, bEnd.path));
+  var aEndInB = (_slate.Path.isBefore(bStart.path, aEnd.path) || _slate.Path.equals(bStart.path, aEnd.path)) && (_slate.Path.isBefore(aEnd.path, bEnd.path) || _slate.Path.equals(aEnd.path, bEnd.path));
+
+  // B is included by A
+  var bWithinA = (_slate.Path.isBefore(aStart.path, bStart.path) || _slate.Path.equals(aStart.path, bStart.path)) && (_slate.Path.isBefore(bEnd.path, aEnd.path) || _slate.Path.equals(bEnd.path, aEnd.path));
+  return aStartInB || aEndInB || bWithinA;
+};
+var _validateNestedStructure = exports.validateNestedStructure = function validateNestedStructure(nodes) {
+  var validateNode = function validateNode(node) {
+    if (!Array.isArray(node.children) || node.children.length !== 1) {
+      return false;
+    }
+    return _validateNestedStructure(node.children);
+  };
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(nodes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var node = _step.value;
+      if (!node.type) continue;
+      if ([_constants.UNORDERED_LIST, _constants.ORDERED_LIST, _constants.BLOCKQUOTE, _constants.LIST_ITEM].includes(node.type)) {
+        if (!validateNode(node)) {
+          return false;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return true;
+};
+var _getSelectedChildren = exports.getSelectedChildren = function getSelectedChildren(editor, parentNode, parentPath) {
+  var selection = editor.selection;
+  var selectedItems = [];
+  parentNode.children.forEach(function (childNode, index) {
+    var childPath = [].concat((0, _toConsumableArray2["default"])(parentPath), [index]);
+    var childRange = {
+      anchor: _slate.Editor.start(editor, childPath),
+      focus: _slate.Editor.end(editor, childPath)
+    };
+
+    // Determine whether a child node has been selected
+    if (isRangeOverlapping(selection, childRange)) {
+      // If it is a list node, recursively process its nested sub lists
+      var newChildNode = (0, _objectSpread2["default"])({}, childNode);
+      if (childNode.type === _constants.LIST_ITEM || childNode.type === _constants.ORDERED_LIST || childNode.type === _constants.UNORDERED_LIST) {
+        var nestedSelectedItems = _getSelectedChildren(editor, childNode, childPath);
+        // If there are selected items in the nested list, keep the current list structure
+        // Keep only selected nested sub items
+        if (nestedSelectedItems.length > 0) {
+          selectedItems.push((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, newChildNode), {}, {
+            children: nestedSelectedItems
+          }));
+        }
+      } else {
+        // non list nodes
+        if (childNode.children) {
+          var _nestedSelectedItems = _getSelectedChildren(editor, childNode, childPath);
+          if (_nestedSelectedItems.length > 0) {
+            selectedItems.push((0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, newChildNode), {}, {
+              children: _nestedSelectedItems
+            }));
+          }
+          return;
+        }
+        // Add non children nodes directly
+        selectedItems.push(childNode);
+      }
+    }
+  });
+  return selectedItems;
+};
+var handleSelectElements = exports.handleSelectElements = function handleSelectElements(editor) {
+  var selection = editor.selection;
+  var selectedElements = [];
+  var blockNodes = _slate.Editor.nodes(editor, {
+    at: selection,
+    match: function match(n) {
+      return _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n);
+    },
+    mode: 'highest'
+  });
+  var _iterator2 = (0, _createForOfIteratorHelper2["default"])(blockNodes),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = (0, _slicedToArray2["default"])(_step2.value, 2),
+        node = _step2$value[0],
+        path = _step2$value[1];
+      var selectedItems = _getSelectedChildren(editor, node, path);
+      // Keep only selected items
+      if (selectedItems.length > 0) {
+        selectedElements.push([(0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, node), {}, {
+          children: selectedItems
+        }), path]);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  selectedElements[0].forEach(function (childNode, index) {
+    if (childNode.type === _constants.UNORDERED_LIST || childNode.type === _constants.ORDERED_LIST) {
+      selectedElements[0][index] = findValidLists(childNode)[0];
+    }
+  });
+  return selectedElements;
+};
+var hasValidListItem = function hasValidListItem(list) {
+  if (![_constants.UNORDERED_LIST, _constants.ORDERED_LIST].includes(list.type)) return false;
+  return list.children.some(function (item) {
+    if (item.type !== _constants.LIST_ITEM) return false;
+    var paragraph = item.children.find(function (child) {
+      return child.type === _constants.PARAGRAPH;
+    });
+    if (!paragraph) return false;
+    var textNode = paragraph.children.find(function (child) {
+      return 'text' in child;
+    });
+    return textNode !== undefined;
+  });
+};
+var isListCompletelyValid = function isListCompletelyValid(list) {
+  if (![_constants.UNORDERED_LIST, _constants.ORDERED_LIST].includes(list.type)) return false;
+  return list.children.every(function (item) {
+    if (item.type !== _constants.LIST_ITEM) return false;
+    var paragraph = item.children.find(function (child) {
+      return child.type === _constants.PARAGRAPH;
+    });
+    if (!paragraph) return false;
+    var textNode = paragraph.children.find(function (child) {
+      return 'text' in child;
+    });
+    return textNode !== undefined;
+  });
+};
+var findValidLists = exports.findValidLists = function findValidLists(node) {
+  var result = [];
+  var _traverse = function traverse(currentNode) {
+    if (!currentNode) return;
+    // Check if the current node meets the criteria
+    if ([_constants.UNORDERED_LIST, _constants.ORDERED_LIST].includes(currentNode.type) && hasValidListItem(currentNode)) {
+      result.push(currentNode);
+      return;
+    }
+    // Recursive traversal of child nodes
+    if (currentNode.children && Array.isArray(currentNode.children)) {
+      currentNode.children.forEach(_traverse);
+    }
+  };
+  _traverse(node);
+  return result;
+};
+var findInsertableLists = exports.findInsertableLists = function findInsertableLists(node) {
+  var result = [];
+  if ([_constants.UNORDERED_LIST, _constants.ORDERED_LIST].includes(node.type) && isListCompletelyValid(node)) {
+    result.push(node);
+    return result;
+  }
+  var isValidListItem = function isValidListItem(item) {
+    if (item.type !== _constants.LIST_ITEM) return false;
+    var paragraph = item.children.find(function (child) {
+      return child.type === _constants.PARAGRAPH;
+    });
+    if (!paragraph) return false;
+    var textNode = paragraph.children.find(function (child) {
+      return 'text' in child;
+    });
+    return !!textNode;
+  };
+  var _traverse2 = function traverse(currentNode) {
+    if (!currentNode) return;
+    if ([_constants.UNORDERED_LIST, _constants.ORDERED_LIST].includes(currentNode.type)) {
+      var validChildren = currentNode.children.filter(isValidListItem);
+      if (validChildren.length > 0) {
+        var newList = (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, currentNode), {}, {
+          children: validChildren
+        });
+        result.push(newList);
+      }
+    }
+    if (currentNode.children && Array.isArray(currentNode.children)) {
+      currentNode.children.forEach(_traverse2);
+    }
+  };
+  _traverse2(node);
+  return result;
+};
 var insertHtmlTransferredNodes = exports.insertHtmlTransferredNodes = function insertHtmlTransferredNodes(slateNodeList, nextPath, editor) {
   slateNodeList.forEach(function (childNode) {
     // Insert paragraph nodes
@@ -62,9 +264,17 @@ var insertHtmlTransferredNodes = exports.insertHtmlTransferredNodes = function i
 
     // Insert non-paragraph nodes
     if (childNode.type !== _constants.PARAGRAPH) {
-      _slate.Transforms.insertNodes(editor, childNode, {
-        at: nextPath
-      });
+      // unordered_list or ordered_list
+      if (childNode.type === _constants.UNORDERED_LIST || childNode.type === _constants.ORDERED_LIST) {
+        var insertSlateElement = findInsertableLists(childNode);
+        _slate.Transforms.insertNodes(editor, insertSlateElement, {
+          at: nextPath
+        });
+      } else {
+        _slate.Transforms.insertNodes(editor, childNode, {
+          at: nextPath
+        });
+      }
       nextPath = _slate.Path.next(nextPath);
     }
   });

package/dist/extension/plugins/ai/ai-module/index.js

@@ -19,6 +19,7 @@ var _toast = _interopRequireDefault(require("../../../../components/toast"));
 var _context2 = _interopRequireDefault(require("../../../../context"));
 var _mdToHtml = _interopRequireDefault(require("../../../../slate-convert/md-to-html"));
 var _mdToSlate = _interopRequireDefault(require("../../../../slate-convert/md-to-slate"));
+var _slateToMd = _interopRequireDefault(require("../../../../slate-convert/slate-to-md"));
 var _commons = require("../../../commons");
 var _dropdownMenuItem = _interopRequireDefault(require("../../../commons/dropdown-menu-item"));
 var _constants = require("../../../constants");
@@ -83,8 +84,17 @@ function AIModule(_ref) {
       scrollTop = _scrollRef$current.scrollTop,
       scrollHeight = _scrollRef$current.scrollHeight;
     if (!element) {
-      var _content = window.getSelection().toString();
-      if (_content) {
+      var selectElements = (0, _helpers.handleSelectElements)(editor);
+      var _content = '';
+      if (selectElements) {
+        if ((0, _helpers.validateNestedStructure)(selectElements[0])) {
+          // list.length === 1
+          _content = window.getSelection().toString();
+        } else {
+          selectElements.forEach(function (item) {
+            _content += (0, _slateToMd["default"])(item);
+          });
+        }
         setSelectedValue(_content);
       }
       var domSelection = window.getSelection();

package/dist/index.js

@@ -112,6 +112,12 @@ Object.defineProperty(exports, "SDocWikiViewer", {
     return _views.SDocWikiViewer;
   }
 });
+Object.defineProperty(exports, "SocketManager", {
+  enumerable: true,
+  get: function get() {
+    return _socket.SocketManager;
+  }
+});
 Object.defineProperty(exports, "Tooltip", {
   enumerable: true,
   get: function get() {

package/dist/socket/socket-client.js

@@ -81,6 +81,18 @@ var SocketClient = /*#__PURE__*/(0, _createClass2["default"])(function SocketCli
       callback && callback(result);
     });
   });
+  (0, _defineProperty2["default"])(this, "sendUserUpdated", function (name) {
+    (0, _debug.clientDebug)('send user change event: %s', name);
+    var _this$config2 = _this.config,
+      user = _this$config2.user,
+      docUuid = _this$config2.docUuid;
+    _this.socket.emit('user-updated', {
+      user: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, user), {}, {
+        name: name
+      }),
+      doc_uuid: docUuid
+    });
+  });
   (0, _defineProperty2["default"])(this, "onJoinRoom", function (userInfo) {
     (0, _debug.serverDebug)('%s joined room success.', userInfo.username);
     var socketManager = _socketManager["default"].getInstance();
@@ -91,6 +103,11 @@ var SocketClient = /*#__PURE__*/(0, _createClass2["default"])(function SocketCli
     var socketManager = _socketManager["default"].getInstance();
     socketManager.dispatchConnectState('leave-room', username);
   });
+  (0, _defineProperty2["default"])(this, "onUserUpdated", function (userInfo) {
+    (0, _debug.serverDebug)('%s name updated: %s', userInfo.username, userInfo.name);
+    var socketManager = _socketManager["default"].getInstance();
+    socketManager.dispatchConnectState('user-updated', userInfo);
+  });
   /**
    * receive remote broadcast operations
    * @param {*} params {operations, version}
@@ -179,6 +196,7 @@ var SocketClient = /*#__PURE__*/(0, _createClass2["default"])(function SocketCli
   this.socket.on('connect_error', this.onConnectError);
   this.socket.on('join-room', this.onJoinRoom);
   this.socket.on('leave-room', this.onLeaveRoom);
+  this.socket.on('user-updated', this.onUserUpdated);
   this.socket.on('update-document', this.onReceiveRemoteOperations);
 
   // doc replaced

package/dist/socket/socket-manager.js

@@ -58,6 +58,9 @@ var SocketManager = /*#__PURE__*/(0, _createClass2["default"])(function SocketMa
   (0, _defineProperty2["default"])(this, "receiveNewNotification", function (notification) {
     _this.eventBus.dispatch(_constants.INTERNAL_EVENT.NEW_NOTIFICATION, notification);
   });
+  (0, _defineProperty2["default"])(this, "sendUserUpdated", function (name) {
+    _this.socketClient.sendUserUpdated(name);
+  });
   (0, _defineProperty2["default"])(this, "onReceiveLocalOperations", function (operations) {
     if (_this.editor.readonly) return;
     _this.pendingOperationList.push(operations);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seafile/sdoc-editor",
-  "version": "2.0.115",
+  "version": "2.0.116",
   "main": "dist/index.js",
   "scripts": {
     "test": "jest",
@@ -70,5 +70,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "90b92ce7a4734fb67256a9b67aa78596f6160f70"
+  "gitHead": "d5d10d54c29fa8ba70624108d8f26462597f6485"
 }