@seafile/sdoc-editor 0.1.0 → 0.1.1

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

@@ -1,395 +0,0 @@
-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 _createClass from "@babel/runtime/helpers/esm/createClass";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-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';
-import { normailizeSelection } from '../selection-utils';
-var LitsUtils = /*#__PURE__*/_createClass(function LitsUtils(editor) {
-  var _this = this;
-  _classCallCheck(this, LitsUtils);
-  this.unwrapList = function () {
-    // 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 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
-        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;
-        });
-        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: selectedList.type
-          }],
-          split: true,
-          mode: 'highest',
-          at: {
-            anchor: startItemRange.anchor,
-            focus: endItemRange.focus
-          }
-        });
-      }
-    });
-  };
-  this.wrapList = function (type) {
-    normailizeSelection(_this.editor);
-    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])
-          });
-        }
-      });
-    });
-  };
-  // unwrap list wrap list
-  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]];
-    }
-    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 _iterator2 = _createForOfIteratorHelper(listNodes),
-      _step2;
-    try {
-      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) {
-      _iterator2.e(err);
-    } finally {
-      _iterator2.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]);
-    // 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
-      });
-    });
-  };
-  this.isInlist = function () {
-    var node = _this.getCurrentListItem();
-    if (node.length > 0) return true;
-    return false;
-  };
-  /**
-   * When copying a sublist, the list item in the list returned by slate contains only one sublis,
-   * pasting the list item directly into the list will produce an incorrect list structure,
-   * the list item that contains only one list need to flatten
-   * Input: {type: 'list', children: [{type: 'list_item', children: [{type: 'list', children[{type: 'list_item'}, ...]}]}]}
-   * Output: [{type: 'list_item'},....]
-  */
-  this.getNormalizedListItems = function (list) {
-    var listItems = [];
-    list.children.forEach(function (listItem) {
-      var children = listItem.children || [];
-      var child = children[0];
-      if (child && child.type.includes('_list') && children.length === 1) {
-        listItems.push.apply(listItems, _toConsumableArray(_this.getNormalizedListItems(child)));
-      } else {
-        listItems.push(listItem);
-      }
-    });
-    return listItems;
-  };
-  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 = _this.getNormalizedListItems(firstBlock);
-        listItems.forEach(function (listItem, index) {
-          var itemChildren = listItem.children;
-          if (itemChildren[0].type.includes('list')) {
-            SfEditor.insertNodes(_this.editor, [itemChildren[0]]);
-          } else {
-            SfEditor.insertFragment(_this.editor, [itemChildren[0]]);
-          }
-          if (itemChildren.length > 1) {
-            var currentListItem = Node.get(_this.editor, [].concat(_toConsumableArray(listPath), [currentItemIndex + index]));
-            SfEditor.insertNodes(_this.editor, itemChildren.slice(1), {
-              at: [].concat(_toConsumableArray(listPath), [currentItemIndex + index, currentListItem.children.length])
-            });
-          }
-          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;