@seafile/seafile-editor 0.3.76

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

@@ -0,0 +1,398 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+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 { SfEditor } from '../../custom/custom';
+import getEventTransfer from '../../custom/get-event-transfer';
+import { htmlDeserializer } from '../../../utils/deserialize-html';
+import { normailizeSelection } from '../selection-utils';
+
+var LitsUtils = function LitsUtils(editor) {
+  var _this = this;
+
+  _classCallCheck(this, LitsUtils);
+
+  this.unwrapList = function () {
+    normailizeSelection(_this.editor); // selected list item
+
+    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 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
+
+    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
+
+
+      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 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
+        });
+      }
+    } 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) {
+        SfEditor.unwrapNodesByTypeAtRange(_this.editor, {
+          match: {
+            type: 'list_item'
+          },
+          at: [].concat(_toConsumableArray(_listParentPath), [startIndex + index])
+        });
+      });
+    }
+  };
+
+  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
+      });
+    }
+  };
+
+  this.getCurrentListItem = function () {
+    var selection = _this.editor.selection;
+
+    if (!selection) {
+      return [];
+    }
+
+    if (Range.isCollapsed(selection)) {
+      // get the nearest ancesstor of block, judge if the ancesstor is list item to compat the possibility that
+      // a code block or blockquote in a list item
+      var block = SfEditor.match(_this.editor, _this.editor.selection, 'block');
+      var blockPath = block[1];
+      var blockParent = Node.parent(_this.editor, blockPath);
+
+      if (blockParent.type && blockParent.type.indexOf('list') < 0) {
+        return [];
+      }
+
+      var listItemNodes = SfEditor.nodes(_this.editor, {
+        match: {
+          type: 'list_item'
+        }
+      });
+      var listItemNode;
+
+      var _iterator = _createForOfIteratorHelper(listItemNodes),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var item = _step.value;
+          listItemNode = item;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      if (listItemNode) {
+        return [listItemNode];
+      }
+
+      return [];
+    }
+
+    var focusPath = selection.focus.path;
+    var anchorPath = selection.anchor.path;
+
+    var _SfEditor$nodes = SfEditor.nodes(_this.editor, {
+      match: 'block',
+      at: anchorPath
+    }),
+        _SfEditor$nodes2 = _slicedToArray(_SfEditor$nodes, 1),
+        startItem = _SfEditor$nodes2[0];
+
+    var _SfEditor$nodes3 = SfEditor.nodes(_this.editor, {
+      match: 'block',
+      at: focusPath
+    }),
+        _SfEditor$nodes4 = _slicedToArray(_SfEditor$nodes3, 1),
+        endItem = _SfEditor$nodes4[0];
+
+    var _startItem = _slicedToArray(startItem, 2),
+        startPath = _startItem[1];
+
+    var _endItem = _slicedToArray(endItem, 2),
+        endPath = _endItem[1];
+
+    if (Path.equals(startPath, endPath)) {
+      var _blockParent = Node.parent(_this.editor, startPath);
+
+      if (!_blockParent.type || _blockParent.type.indexOf('list') < 0) {
+        return [];
+      }
+
+      return [[_blockParent, startPath.slice(0, -1)]];
+    }
+
+    var commonPath = Path.common(focusPath, anchorPath);
+    var commonAncestor = Node.get(_this.editor, commonPath);
+    var nodeType = commonAncestor.type;
+
+    if (nodeType === 'ordered_list' || nodeType === 'unordered_list') {
+      var startIndex = anchorPath.slice(commonPath.length)[0];
+      var endIndex = focusPath.slice(commonPath.length)[0];
+      var selectedListItem = [];
+
+      for (var index = startIndex; index <= endIndex; index++) {
+        selectedListItem.push([commonAncestor.children[index], [].concat(_toConsumableArray(commonPath), [index])]);
+      }
+
+      return selectedListItem;
+    } else if (nodeType === 'list_item') {
+      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 [];
+  };
+
+  this.increaseListDepth = function () {
+    var listNodes = SfEditor.nodes(_this.editor, {
+      match: {
+        type: 'list_item'
+      }
+    });
+    var node; //get the nearest list_item of current selection
+
+    var _iterator3 = _createForOfIteratorHelper(listNodes),
+        _step3;
+
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var item = _step3.value;
+        node = item;
+      } // if current list item is the first child of the list return
+
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+
+    var listItemPath = _toConsumableArray(node[1]);
+
+    if (listItemPath[listItemPath.length - 1] === 0) return;
+    var listNode = Node.parent(_this.editor, listItemPath);
+    var listItemIndex = listItemPath.pop();
+    var listNodePath = listItemPath;
+    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
+    });
+  };
+
+  this.isInlist = function () {
+    var node = _this.getCurrentListItem();
+
+    if (node.length > 0) return true;
+    return false;
+  };
+
+  this.pasteContentInList = function (command) {
+    var data = command.data;
+
+    var _getEventTransfer = getEventTransfer(data),
+        fragment = _getEventTransfer.fragment,
+        text = _getEventTransfer.text,
+        type = _getEventTransfer.type,
+        html = _getEventTransfer.html;
+
+    if (type === 'text' && !fragment) {
+      var newText = text.replace(/\r\n|\n/g, ' ');
+      SfEditor.insertText(_this.editor, newText);
+      return;
+    }
+
+    if (type === 'html') {
+      fragment = htmlDeserializer(html);
+    } // insert fragment
+
+
+    if (text.length > 0) {
+      var newtext = text.replace(/\r\n|\n/g, ' ');
+      var firstBlock = fragment[0];
+      var firstBlockType = firstBlock.type;
+
+      var currentItem = _this.getCurrentListItem();
+
+      var currentItemPath = currentItem[0][1];
+      var currentItemIndex = currentItemPath[currentItemPath.length - 1];
+      var listPath = currentItemPath.slice(0, currentItemPath.length - 1);
+
+      if (firstBlockType === 'ordered_list' || firstBlockType === 'unordered_list') {
+        var listItems = firstBlock.children;
+        listItems.forEach(function (listItem, index) {
+          var itemChildren = listItem.children;
+          SfEditor.insertFragment(_this.editor, [itemChildren[0]]);
+
+          if (itemChildren.length > 1) {
+            SfEditor.insertNodes(_this.editor, itemChildren.slice(1));
+          }
+
+          if (index < listItems.length - 1) {
+            SfEditor.insertNodes(_this.editor, {
+              type: 'list_item',
+              data: {},
+              children: [{
+                type: 'paragraph',
+                children: [{
+                  text: ''
+                }]
+              }]
+            }, {
+              at: [].concat(_toConsumableArray(listPath), [currentItemIndex + index + 1])
+            });
+            SfEditor.select(_this.editor, [].concat(_toConsumableArray(listPath), [currentItemIndex + index + 1]));
+          }
+        });
+
+        if (fragment.length > 1) {
+          var outestListItem = SfEditor.match(_this.editor, _this.editor.selection, {
+            type: 'list_item'
+          });
+          var outestListItemPath = outestListItem[1];
+          var outestListPath = outestListItemPath.slice(0, outestListItemPath.length - 1);
+          var outestListIndex = outestListPath[outestListPath.length - 1];
+          var nextBlockPath = [].concat(_toConsumableArray(outestListPath.slice(0, outestListPath.length - 1)), [outestListIndex + 1]);
+          SfEditor.insertNodes(_this.editor, fragment.slice(1), {
+            at: nextBlockPath
+          });
+        }
+      } else {
+        if (fragment.length === 1 && fragment[0].type === 'paragraph') {
+          SfEditor.insertFragment(_this.editor, fragment);
+          return;
+        } // insert text directly when the first block is not a list
+
+
+        SfEditor.insertText(_this.editor, newtext);
+      }
+    } else {
+      SfEditor.insertFragment(_this.editor, fragment);
+    }
+  };
+
+  this.editor = editor;
+};
+
+export default LitsUtils;