@seafile/seafile-editor 0.3.76 → 0.3.80

package/dist/editor/controller/block-element-controller.js

@@ -1,5 +1,5 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import { Editor } from 'slate';
 import ListUtils from '../editor-utils/block-element-utils/list-utils';
@@ -146,6 +146,27 @@ var withBlock = function withBlock(editor) {
 
           if (firstFragmentNode.type === 'paragraph') {
             Editor.insertFragment(editor, fragment);
+            return;
+          }
+          /** 
+           * if the first fragment element is a list, get normalized list items with function getNormalizedListItems and insert
+           */
+
+
+          if (firstFragmentNode.type.includes('_list')) {
+            var listItems = listUtils.getNormalizedListItems(firstFragmentNode);
+            var newFragment = fragment.slice(1);
+            Editor.insertNodes(editor, [{
+              type: firstFragmentNode.type,
+              children: listItems
+            }].concat(_toConsumableArray(newFragment)));
+
+            if (SfEditor.isEmptyParagraph(currentBlock)) {
+              Editor.delete(editor, {
+                at: path
+              });
+            }
+
             return;
           } // if current node is an empty paragraph, insert the fragment and
           // delete the empty paragraph
@@ -247,15 +268,16 @@ var withBlock = function withBlock(editor) {
             }
           });
         } else {
-          var listItems = Editor.nodes(editor, {
+          var _listItems = Editor.nodes(editor, {
             at: editor.selection,
             match: {
               type: 'list_item'
             }
           });
+
           var nearestItem;
 
-          var _iterator = _createForOfIteratorHelper(listItems),
+          var _iterator = _createForOfIteratorHelper(_listItems),
               _step;
 
           try {

package/dist/editor/controller/shortcut-controller.js

@@ -327,34 +327,54 @@ var withMarkdownShortcut = function withMarkdownShortcut(editor) {
           if (listUtils.isInlist()) {
             var _Editor$nodes9 = Editor.nodes(editor, {
               match: [{
-                type: 'ordered_list'
-              }, {
-                type: 'unordered_list'
+                type: 'list_item'
               }]
             }),
                 _Editor$nodes10 = _slicedToArray(_Editor$nodes9, 1),
                 _node3 = _Editor$nodes10[0];
 
-            var listNode = _node3[0];
+            var listItemPath = _node3[1];
+            var listNode = Node.parent(editor, listItemPath); // Unwrap the list item when the selection is at the first list item of the first node of document
 
-            if (listNode.children.length === 1 && Node.text(listNode).length === 0) {
+            if (anchor.path[0] === 0 && anchor.path[1] === 0) {
               listUtils.unwrapList();
               return;
-            } // Unwrap the list item when the selection is at the first list item of the first node of document
+            } // unwrap an empty list
 
 
-            if (anchor.path[0] === 0 && anchor.path[1] === 0) {
+            if (listNode.children.length === 1 && Node.text(listNode).length === 0) {
               listUtils.unwrapList();
               return;
+            } // list items with mutiple chidren
+
+
+            var currentChildBlockIndex = anchor.path[anchor.path.length - 2];
+            var currentListItem;
+
+            for (var i = anchor.path.length - 1; i > 0; i--) {
+              var _node4 = Node.get(editor, anchor.path.slice(0, i));
+
+              if (_node4.type === 'list_item') {
+                currentListItem = _node4;
+                break;
+              }
+            }
+
+            if (currentChildBlockIndex === 0 && currentListItem.children.length > 1) {
+              Editor.withoutNormalizing(editor, function (editor) {
+                listUtils.unwrapList();
+                exec(command);
+              });
+              return;
             }
           }
 
           if (codeUtils.isInCodeBlock()) {
-            var _node4 = Editor.match(editor, editor.selection, {
+            var _node5 = Editor.match(editor, editor.selection, {
               type: 'code_block'
             });
 
-            var codeBlock = _node4[0];
+            var codeBlock = _node5[0];
             var children = codeBlock.children;
             var text = Node.text(codeBlock);
 

package/dist/editor/editor-utils/block-element-utils/list-utils.js

@@ -2,7 +2,7 @@ import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIt
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import { Node, Range, Path } from 'slate';
+import { Node, Range, Path, Editor } from 'slate';
 import { SfEditor } from '../../custom/custom';
 import getEventTransfer from '../../custom/get-event-transfer';
 import { htmlDeserializer } from '../../../utils/deserialize-html';
@@ -14,116 +14,153 @@ var LitsUtils = function LitsUtils(editor) {
   _classCallCheck(this, LitsUtils);
 
   this.unwrapList = function () {
-    normailizeSelection(_this.editor); // selected list item
+    // defer normalization util the unwrap operartions completed
+    SfEditor.withoutNormalizing(_this.editor, function () {
+      normailizeSelection(_this.editor); // selected list item
 
-    var selectedListItem = _this.getCurrentListItem(); // first selected item path and node
+      var selectedListItem = _this.getCurrentListItem(); // first selected item path and node
 
 
-    var firstSelectedItem = selectedListItem[0];
-    var firstSelectedItemPath = firstSelectedItem[1]; // get selected list and the path of the list
+      var firstSelectedItem = selectedListItem[0];
+      var firstSelectedItemPath = firstSelectedItem[1]; // get selected list and the path of the list
 
-    var selectedListPath = firstSelectedItemPath.slice(0, firstSelectedItemPath.length - 1);
-    var selectedList = Node.get(_this.editor, selectedListPath); // get the node and path of parent of selected list
+      var selectedListPath = firstSelectedItemPath.slice(0, firstSelectedItemPath.length - 1);
+      var selectedList = Node.get(_this.editor, selectedListPath); // get the node and path of parent of selected list
 
-    var listParent = Node.parent(_this.editor, selectedListPath);
-    var listParentPath = selectedListPath.slice(0, selectedListPath.length - 1); // unwrap list of selected list item
-    // if the type of parent of selected list is a list and it should be a list item
+      var listParent = Node.parent(_this.editor, selectedListPath);
+      var listParentPath = selectedListPath.slice(0, selectedListPath.length - 1); // unwrap list of selected list item
+      // if the type of parent of selected list is a list and it should be a list item
 
-    if (listParent.type && listParent.type.includes('list')) {
-      // get the path of parent of listParent
-      var ancesstorPath = listParentPath.slice(0, listParentPath.length - 1);
-      var lastSelectedListItem = selectedListItem.slice(-1)[0];
-      var lastSelectedListItemPath = lastSelectedListItem[1];
-      var lastSelectedListItemIndex = lastSelectedListItemPath.slice(-1)[0];
-      var unSelectedListItem = selectedList.children.slice(selectedListItem.slice(-1)[0][1].slice(-1)[0] + 1); // insert a new list to the last selected list item
+      if (listParent.type && listParent.type.includes('list')) {
+        // get the path of parent of listParent
+        var ancesstorPath = listParentPath.slice(0, listParentPath.length - 1);
+        var lastSelectedListItem = selectedListItem.slice(-1)[0];
+        var lastSelectedListItemPath = lastSelectedListItem[1];
+        var lastSelectedListItemIndex = lastSelectedListItemPath.slice(-1)[0];
+        var unSelectedListItem = selectedList.children.slice(selectedListItem.slice(-1)[0][1].slice(-1)[0] + 1); // insert a new list to the last selected list item
 
-      if (!(lastSelectedListItemIndex === selectedList.children.length - 1)) {
-        SfEditor.insertNodes(_this.editor, {
-          type: selectedList.type,
-          children: []
-        }, {
-          at: [].concat(_toConsumableArray(lastSelectedListItemPath), [lastSelectedListItem[0].children.length])
-        });
-      } // move the unselected list item to the new created list
+        if (!(lastSelectedListItemIndex === selectedList.children.length - 1)) {
+          SfEditor.insertNodes(_this.editor, {
+            type: selectedList.type,
+            children: []
+          }, {
+            at: [].concat(_toConsumableArray(lastSelectedListItemPath), [lastSelectedListItem[0].children.length])
+          });
+        } // move the unselected list item to the new created list
 
 
-      unSelectedListItem.forEach(function (item, index) {
-        SfEditor.moveNodes(_this.editor, {
-          at: [].concat(_toConsumableArray(lastSelectedListItemPath.slice(0, -1)), [lastSelectedListItemIndex + 1]),
-          to: [].concat(_toConsumableArray(lastSelectedListItemPath), [lastSelectedListItem[0].children.length, index])
+        unSelectedListItem.forEach(function (item, index) {
+          SfEditor.moveNodes(_this.editor, {
+            at: [].concat(_toConsumableArray(lastSelectedListItemPath.slice(0, -1)), [lastSelectedListItemIndex + 1]),
+            to: [].concat(_toConsumableArray(lastSelectedListItemPath), [lastSelectedListItem[0].children.length, index])
+          });
         });
-      });
-      var currentItemPath = firstSelectedItemPath;
-      var startIndexOfItemInNewList = listParentPath[listParentPath.length - 1] + 1; // move item to outer list by path
-
-      selectedListItem.forEach(function (item, index) {
-        var itemTargetPath = [].concat(_toConsumableArray(ancesstorPath), [index + startIndexOfItemInNewList]);
-        SfEditor.moveNodes(_this.editor, {
-          at: currentItemPath,
-          to: itemTargetPath
+        var currentItemPath = firstSelectedItemPath;
+        var startIndexOfItemInNewList = listParentPath[listParentPath.length - 1] + 1; // move item to outer list by path
+
+        selectedListItem.forEach(function (item, index) {
+          var itemTargetPath = [].concat(_toConsumableArray(ancesstorPath), [index + startIndexOfItemInNewList]);
+          SfEditor.moveNodes(_this.editor, {
+            at: currentItemPath,
+            to: itemTargetPath
+          });
         });
-      });
-      var currentList = Node.get(_this.editor, selectedListPath); // delete empty list
+        var currentList = Node.get(_this.editor, selectedListPath); // delete empty list
 
-      if (!currentList.children[0] || currentList.children[0].type !== 'list_item') {
-        SfEditor.removeNodes(_this.editor, {
-          at: selectedListPath
+        if (!currentList.children[0] || currentList.children[0].type !== 'list_item') {
+          SfEditor.removeNodes(_this.editor, {
+            at: selectedListPath
+          });
+        }
+      } else {
+        // unwrap list item if the selected list is the outest of the root
+        var firstListItemIndex = firstSelectedItem[1].slice(-1)[0];
+        var restCount = 0;
+        selectedListItem.forEach(function (item) {
+          SfEditor.unwrapNodesByTypeAtRange(_this.editor, {
+            match: {
+              type: 'list_item'
+            },
+            mode: 'highest',
+            at: [].concat(_toConsumableArray(selectedListPath), [firstListItemIndex + restCount])
+          });
+          restCount += item[0].children.length;
         });
-      }
-    } else {
-      // unwrap list item if the selected list is the outest of the root
-      SfEditor.unwrapNodesByTypeAtRange(_this.editor, {
-        match: [{
-          type: selectedList.type
-        }],
-        split: true,
-        mode: 'highest'
-      });
-      var firstListItemIndex = firstSelectedItem[1].slice(-1)[0];
-
-      var _listParentPath = Path.parent(selectedListPath);
-
-      var selectedListIndex = selectedListPath.slice(-1)[0];
-      var startIndex = firstListItemIndex === 0 ? selectedListIndex : selectedListIndex + 1;
-      selectedListItem.forEach(function (item, index) {
+        var startItemRange = Editor.range(_this.editor, [].concat(_toConsumableArray(selectedListPath), [firstListItemIndex]));
+        var endItemRange = Editor.range(_this.editor, [].concat(_toConsumableArray(selectedListPath), [firstListItemIndex + restCount - 1]));
         SfEditor.unwrapNodesByTypeAtRange(_this.editor, {
-          match: {
-            type: 'list_item'
-          },
-          at: [].concat(_toConsumableArray(_listParentPath), [startIndex + index])
+          match: [{
+            type: selectedList.type
+          }],
+          split: true,
+          mode: 'highest',
+          at: {
+            anchor: startItemRange.anchor,
+            focus: endItemRange.focus
+          }
         });
-      });
-    }
+      }
+    });
   };
 
   this.wrapList = function (type) {
     normailizeSelection(_this.editor);
-    var nodes = SfEditor.nodes(_this.editor, {
-      match: 'block'
-    });
-    SfEditor.wrapNodes(_this.editor, {
-      type: type,
-      children: []
-    }, {
-      split: false
-    }); // Get selected block node from an iterator.
-    // Modified according to the function *nodes from slate/src/interface/node.ts
-
-    var items = Array.from(nodes); // wrap selected nodes into list_item
-
-    for (var _i = 0, _items = items; _i < _items.length; _i++) {
-      var _items$_i = _slicedToArray(_items[_i], 2),
-          node = _items$_i[0],
-          path = _items$_i[1];
-
-      SfEditor.wrapNodes(_this.editor, {
-        type: 'list_item',
-        children: [node],
-        data: {}
-      }, {
-        at: path
+    var selection = _this.editor.selection;
+    var focusPath = selection.focus.path;
+    var anchorPath = selection.anchor.path;
+
+    if (Path.equals(focusPath, anchorPath)) {
+      var _SfEditor$match = SfEditor.match(_this.editor, _this.editor.selection, 'block'),
+          _SfEditor$match2 = _slicedToArray(_SfEditor$match, 2),
+          block = _SfEditor$match2[0],
+          path = _SfEditor$match2[1];
+
+      Editor.withoutNormalizing(_this.editor, function (editor) {
+        SfEditor.wrapNodes(_this.editor, {
+          type: 'list_item',
+          children: [block],
+          data: {}
+        }, {
+          at: path
+        });
+        SfEditor.wrapNodes(_this.editor, {
+          type: type,
+          children: []
+        }, {
+          split: false,
+          at: path
+        });
       });
+      return;
     }
+
+    var commonPath = Path.common(focusPath, anchorPath);
+    var commonAncestor = Node.get(_this.editor, commonPath);
+    var startIndex = anchorPath[commonPath.length];
+    var endIndex = focusPath[commonPath.length]; // get hightest selected commonAncestor block items
+
+    var selectedBlock = commonAncestor.children.slice(startIndex, endIndex + 1);
+    Editor.withoutNormalizing(_this.editor, function (editor) {
+      selectedBlock.forEach(function (blockItem, index) {
+        // wrap block into list
+        if (!blockItem.type.includes('list')) {
+          SfEditor.wrapNodes(_this.editor, {
+            type: 'list_item',
+            children: [blockItem],
+            data: {}
+          }, {
+            at: [].concat(_toConsumableArray(commonPath), [startIndex + index])
+          });
+          SfEditor.wrapNodes(_this.editor, {
+            type: type,
+            children: []
+          }, {
+            split: false,
+            at: [].concat(_toConsumableArray(commonPath), [startIndex + index])
+          });
+        }
+      });
+    });
   };
 
   this.getCurrentListItem = function () {
@@ -223,34 +260,6 @@ var LitsUtils = function LitsUtils(editor) {
       return [[commonAncestor, commonPath]];
     }
 
-    if (commonPath.length === 0) {
-      var listNodes = SfEditor.nodes(_this.editor, {
-        match: [{
-          type: 'list_item'
-        }, {
-          type: 'list_item'
-        }],
-        mode: 'highest'
-      });
-      var list = [];
-
-      var _iterator2 = _createForOfIteratorHelper(listNodes),
-          _step2;
-
-      try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var iterator = _step2.value;
-          list.push(iterator);
-        }
-      } catch (err) {
-        _iterator2.e(err);
-      } finally {
-        _iterator2.f();
-      }
-
-      return list;
-    }
-
     return [];
   };
 
@@ -262,19 +271,19 @@ var LitsUtils = function LitsUtils(editor) {
     });
     var node; //get the nearest list_item of current selection
 
-    var _iterator3 = _createForOfIteratorHelper(listNodes),
-        _step3;
+    var _iterator2 = _createForOfIteratorHelper(listNodes),
+        _step2;
 
     try {
-      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-        var item = _step3.value;
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var item = _step2.value;
         node = item;
       } // if current list item is the first child of the list return
 
     } catch (err) {
-      _iterator3.e(err);
+      _iterator2.e(err);
     } finally {
-      _iterator3.f();
+      _iterator2.f();
     }
 
     var listItemPath = _toConsumableArray(node[1]);
@@ -286,18 +295,21 @@ var LitsUtils = function LitsUtils(editor) {
     var previousListItem = listNode.children[listItemIndex - 1];
     var previousListItemPath = [].concat(_toConsumableArray(listNodePath), [listItemIndex - 1]);
     var lastIndex = previousListItem.children.length;
-    var newListPath = [].concat(_toConsumableArray(previousListItemPath), [lastIndex]);
-    SfEditor.insertNodes(_this.editor, {
-      type: listNode.type,
-      children: []
-    }, {
-      at: newListPath,
-      split: true
-    });
-    var newListItemPath = [].concat(_toConsumableArray(newListPath), [0]);
-    SfEditor.moveNodes(_this.editor, {
-      at: node[1],
-      to: newListItemPath
+    var newListPath = [].concat(_toConsumableArray(previousListItemPath), [lastIndex]); // Deferring normalization list untils after operations completes.
+
+    SfEditor.withoutNormalizing(_this.editor, function () {
+      SfEditor.insertNodes(_this.editor, {
+        type: listNode.type,
+        children: []
+      }, {
+        at: newListPath,
+        split: true
+      });
+      var newListItemPath = [].concat(_toConsumableArray(newListPath), [0]);
+      SfEditor.moveNodes(_this.editor, {
+        at: node[1],
+        to: newListItemPath
+      });
     });
   };
 
@@ -308,6 +320,21 @@ var LitsUtils = function LitsUtils(editor) {
     return false;
   };
 
+  this.getNormalizedListItems = function (list) {
+    var listItems = [];
+    list.children.forEach(function (listItem) {
+      var children = listItem.children || [];
+      var firstChild = children[0];
+
+      if (firstChild && firstChild.type.includes('_list')) {
+        listItems.push.apply(listItems, _toConsumableArray(_this.getNormalizedListItems(firstChild)));
+      } else {
+        listItems.push(listItem);
+      }
+    });
+    return listItems;
+  };
+
   this.pasteContentInList = function (command) {
     var data = command.data;
 
@@ -340,7 +367,8 @@ var LitsUtils = function LitsUtils(editor) {
       var listPath = currentItemPath.slice(0, currentItemPath.length - 1);
 
       if (firstBlockType === 'ordered_list' || firstBlockType === 'unordered_list') {
-        var listItems = firstBlock.children;
+        var listItems = _this.getNormalizedListItems(firstBlock);
+
         listItems.forEach(function (listItem, index) {
           var itemChildren = listItem.children;
           SfEditor.insertFragment(_this.editor, [itemChildren[0]]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seafile/seafile-editor",
-  "version": "0.3.76",
+  "version": "0.3.80",
   "private": false,
   "dependencies": {
     "@seafile/slate-react": "^0.54.13",