@seafile/seafile-editor 0.3.76

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

@@ -0,0 +1,394 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { Editor, Node, Range, Path } from 'slate';
+import ListUtils from '../editor-utils/block-element-utils/list-utils';
+import { isRangeCollapsed } from '../editor-utils/range-utils';
+import { SfEditor } from '../custom/custom';
+import CodeUtils from '../editor-utils/block-element-utils/code-utils';
+import TextUtils from '../editor-utils/text-utils';
+import TableUtils from '../editor-utils/block-element-utils/table-utils';
+import BlockquoteUtils from '../editor-utils/block-element-utils/blockquote-utils';
+var SHORTCUTS = {
+  '1.': 'ordered_list',
+  '*': 'unordered_list',
+  '-': 'unordered_list',
+  '>': 'blockquote',
+  '#': 'header_one',
+  '##': 'header_two',
+  '###': 'header_three',
+  '####': 'header_four',
+  '#####': 'header_five',
+  '######': 'header_six',
+  '   ': 'code_block'
+};
+
+var withMarkdownShortcut = function withMarkdownShortcut(editor) {
+  var exec = editor.exec;
+  var listUtils = new ListUtils(editor);
+  var codeUtils = new CodeUtils(editor);
+  var tableUtils = new TableUtils(editor);
+  var textUtils = new TextUtils(editor);
+  var blockquoteUtils = new BlockquoteUtils(editor);
+
+  editor.exec = function (command) {
+    var selection = editor.selection;
+
+    switch (command.type) {
+      case 'split_list_item':
+        Editor.splitNodes(editor, {
+          match: 'block',
+          always: true
+        });
+        break;
+
+      case 'insert_break':
+        if (!Range.isCollapsed(editor.selection)) {
+          var _node = Editor.node(editor, [editor.selection.anchor.path[0]]);
+
+          if (_node && _node[0].type.includes('header')) {
+            exec(command);
+            Editor.setNodes(editor, {
+              type: 'paragraph'
+            });
+            return;
+          } // if the expand selection is in table delete the selected and insert a new row when press enter
+
+
+          if (tableUtils.isInTable()) {
+            Editor.collapse(editor, {
+              edge: 'end'
+            });
+            tableUtils.insertRow();
+            return;
+          }
+
+          exec(command);
+          return;
+        }
+
+        var _Editor$nodes = Editor.nodes(editor, {
+          match: {
+            type: 'link'
+          }
+        }),
+            _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
+            link = _Editor$nodes2[0]; // when selection is at the end of link, select the text node after the link
+        // to prevent split a empty link node
+
+
+        if (link) {
+          var linkPath = link[1];
+
+          if (Editor.isEnd(editor, editor.selection.anchor, linkPath)) {
+            var nextPath = Path.next(linkPath);
+            var point = {
+              path: nextPath,
+              offset: 0
+            };
+            Editor.select(editor, point);
+          }
+        } // When a picture is selected, a blank line is inserted when press Enter
+
+
+        var _Editor$nodes3 = Editor.nodes(editor, {
+          match: {
+            type: 'image'
+          }
+        }),
+            _Editor$nodes4 = _slicedToArray(_Editor$nodes3, 1),
+            image = _Editor$nodes4[0];
+
+        if (image) {
+          var imagePath = image[1].slice();
+          var imageIndex = imagePath.pop(); // insert new table row when selection is in table
+
+          Editor.insertNodes(editor, {
+            text: ''
+          }, {
+            at: [].concat(_toConsumableArray(imagePath), [imageIndex + 1])
+          });
+
+          if (tableUtils.isInTable()) {
+            tableUtils.insertRow();
+            return;
+          }
+
+          exec(command);
+          return;
+        } // unwrap blockquote when press enter at an empty blockquote line;
+
+
+        if (blockquoteUtils.isInBlockquote()) {
+          var _Editor$nodes5 = Editor.nodes(editor, {
+            match: 'block'
+          }),
+              _Editor$nodes6 = _slicedToArray(_Editor$nodes5, 1),
+              block = _Editor$nodes6[0];
+
+          if (Node.text(block[0]).length === 0) {
+            Editor.unwrapNodes(editor, {
+              match: {
+                type: 'blockquote'
+              },
+              split: true
+            });
+            return;
+          }
+        } // if press enter in a list unwrap the list or insert a new list item
+
+
+        if (listUtils.isInlist()) {
+          var _node2 = SfEditor.getNodesByTypeAtRange(editor, 'list_item'); // unwrap list if the list item text is none
+
+
+          if (Node.text(_node2[0]).length === 0) {
+            listUtils.unwrapList();
+            return;
+          } // insert a new list item
+
+
+          if (isRangeCollapsed(editor.selection)) {
+            SfEditor.splitNodesAtPoint(editor, {
+              at: editor.selection.anchor,
+              match: {
+                type: 'list_item'
+              },
+              always: true
+            });
+            return;
+          }
+        }
+
+        if (codeUtils.isInCodeBlock()) {
+          codeUtils.splitCodeLine();
+          return;
+        }
+
+        if (tableUtils.isInTable()) {
+          tableUtils.insertRow();
+          return;
+        }
+
+        var node = Editor.node(editor, [editor.selection.anchor.path[0]]);
+
+        if (node && node[0].type.includes('header')) {
+          var header = node[0]; // get the offset of the selection
+
+          var offset = editor.selection.anchor.offset; // split the header
+
+          exec(command); // if the selection is at the end of the header
+          // set the splited header sibling to paragraph 
+
+          if (offset === Node.text(header).length) {
+            Editor.setNodes(editor, {
+              type: 'paragraph'
+            });
+          }
+
+          return;
+        }
+
+        exec(command);
+        break;
+
+      case 'insert_text':
+        // set element by markdown shortcut;
+        if (command.text === ' ' && isRangeCollapsed(selection)) {
+          // if current selection is in table or code block exec default command
+          if (tableUtils.isInTable() || codeUtils.isInCodeBlock()) {
+            exec(command);
+            return;
+          }
+
+          var _textUtils$getTextInf = textUtils.getTextInfoBeforeSelection(),
+              beforeText = _textUtils$getTextInf.beforeText,
+              range = _textUtils$getTextInf.range,
+              _block = _textUtils$getTextInf.block;
+
+          var path = _block[1];
+          var type = SHORTCUTS[beforeText]; // set block element by shortcut
+
+          if (type) {
+            Editor.select(editor, range);
+            Editor.delete(editor);
+
+            if (type === 'blockquote') {
+              if (!blockquoteUtils.isInBlockquote()) {
+                editor.exec({
+                  type: 'set_blockquote'
+                });
+              }
+            }
+
+            if (type.includes('header')) {
+              // set the outest  paragraph into header 
+              if (_block[0].type === 'paragraph' && path.length === 1) {
+                editor.exec({
+                  type: 'set_header',
+                  headerType: type
+                });
+              }
+            }
+
+            if (type === 'ordered_list') {
+              editor.exec({
+                type: 'set_ordered_list'
+              });
+            }
+
+            if (type === 'unordered_list') {
+              editor.exec({
+                type: 'set_unordered_list'
+              });
+            }
+
+            if (type === 'code_block') {
+              if (!codeUtils.isInCodeBlock()) {
+                editor.exec({
+                  type: 'set_code_block'
+                });
+                return;
+              }
+            }
+
+            return;
+          } else {
+            // set text mark by shortcut
+            textUtils.setTextMarkByShortCut(exec, command);
+            return;
+          }
+        }
+
+        if (command.text === '`' && isRangeCollapsed(editor.selection)) {
+          var _textUtils$getTextInf2 = textUtils.getTextInfoBeforeSelection(),
+              _beforeText = _textUtils$getTextInf2.beforeText,
+              _range = _textUtils$getTextInf2.range;
+
+          if (_beforeText === '``' && !codeUtils.isInCodeBlock()) {
+            Editor.select(editor, _range);
+            Editor.delete(editor);
+            editor.exec({
+              type: 'set_code_block'
+            });
+            return;
+          }
+        }
+
+        exec(command);
+        break;
+
+      case 'increase_list_item_depth':
+        listUtils.increaseListDepth();
+        break;
+
+      case 'delete_backward':
+        var anchor = selection.anchor;
+
+        if (anchor.offset === 0 && isRangeCollapsed(selection)) {
+          var _Editor$nodes7 = Editor.nodes(editor, {
+            match: 'block'
+          }),
+              _Editor$nodes8 = _slicedToArray(_Editor$nodes7, 1),
+              match = _Editor$nodes8[0];
+
+          var _block2 = match[0]; // set header to paragraph when delete at the start of header
+
+          if (_block2.type.includes('header')) {
+            editor.exec({
+              type: 'set_header',
+              headerType: 'paragraph'
+            });
+            return;
+          }
+          /**
+           * If the anchor offset is 0 but not focus the head of the block node such as
+           * an image is selected, the editor shoud delete the image first instead of
+           * execute the delete operation of list or code_block or table
+           */
+
+
+          if (_block2.children.length > 1) {
+            var blockDepth = match[1].length - 1;
+            var inlineIndex = anchor.path[blockDepth + 1]; // If the inline node is the first child of the block, execute default command
+
+            if (inlineIndex !== 0) {
+              exec(command);
+              return;
+            }
+          }
+
+          if (blockquoteUtils.isInBlockquote()) {
+            editor.exec({
+              type: 'unwrap_blockquote'
+            });
+            return;
+          }
+
+          if (listUtils.isInlist()) {
+            var _Editor$nodes9 = Editor.nodes(editor, {
+              match: [{
+                type: 'ordered_list'
+              }, {
+                type: 'unordered_list'
+              }]
+            }),
+                _Editor$nodes10 = _slicedToArray(_Editor$nodes9, 1),
+                _node3 = _Editor$nodes10[0];
+
+            var listNode = _node3[0];
+
+            if (listNode.children.length === 1 && Node.text(listNode).length === 0) {
+              listUtils.unwrapList();
+              return;
+            } // Unwrap the list item when the selection is at the first list item of the first node of document
+
+
+            if (anchor.path[0] === 0 && anchor.path[1] === 0) {
+              listUtils.unwrapList();
+              return;
+            }
+          }
+
+          if (codeUtils.isInCodeBlock()) {
+            var _node4 = Editor.match(editor, editor.selection, {
+              type: 'code_block'
+            });
+
+            var codeBlock = _node4[0];
+            var children = codeBlock.children;
+            var text = Node.text(codeBlock);
+
+            if (text.length === 0 && children.length === 1) {
+              editor.exec({
+                type: 'unwrap_code_block'
+              });
+              return;
+            }
+          }
+
+          if (tableUtils.isInTable()) {
+            var _block3 = Editor.match(editor, editor.selection, 'block');
+
+            var blockPath = _block3[1];
+            var blockNode = _block3[0];
+            var start = Editor.start(editor, blockPath);
+            var _offset = start.offset;
+
+            if (_offset === 0 && blockNode.children.length === 1) {
+              return;
+            }
+          }
+        }
+
+        exec(command);
+        break;
+
+      default:
+        exec(command);
+    }
+  };
+
+  return editor;
+};
+
+export default withMarkdownShortcut;

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

@@ -0,0 +1,12 @@
+var withVoid = function withVoid(editor) {
+  var isVoid = editor.isVoid;
+  var VOID_ELEMENTS = ['image', 'formula'];
+
+  editor.isVoid = function (element) {
+    return VOID_ELEMENTS.includes(element.type) ? true : isVoid(element);
+  };
+
+  return editor;
+};
+
+export default withVoid;

package/dist/editor/custom/custom.js

@@ -0,0 +1,17 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { Editor } from 'slate';
+import splitNodesAtPoint from './split-nodes-at-point';
+import unwrapNodesByTypeAtRange from './unwrap-node-by-type-at-range';
+import getNodesByTypeAtRange from './getNodesByTypeAtRange';
+import { insertNodes } from './insertNodes';
+import isEmptyParagraph from './is-empty-paragraph'; //due to some of the function of slate is not perfect now, add some custom fucntion to Editor and exported as SfEditor
+
+var SfEditor = _objectSpread(_objectSpread({}, Editor), {}, {
+  splitNodesAtPoint: splitNodesAtPoint,
+  getNodesByTypeAtRange: getNodesByTypeAtRange,
+  unwrapNodesByTypeAtRange: unwrapNodesByTypeAtRange,
+  insertNodes: insertNodes,
+  isEmptyParagraph: isEmptyParagraph
+});
+
+export { SfEditor };

package/dist/editor/custom/get-event-transfer.js

@@ -0,0 +1,34 @@
+var getEventTransfer = function getEventTransfer(data) {
+  var fragmentString = data.getData('application/x-slate-fragment');
+  var textContent = data.getData('text') || data.getData('text/plain') || '';
+  var fragmentContent = fragmentString ? JSON.parse(decodeURIComponent(window.atob(fragmentString))) : null;
+  var htmlContent = data.getData('text/html') || '';
+  var hasRtfContent = data.types.includes('text/rtf');
+  /**
+   *  compat old version slate: if clipboard content is old version slate fragment
+   *  return  html content
+   */
+
+  var files = data.files;
+  var type = 'text'; // Paste rtf format content which copied from PPT or Word or Excel as text to document
+
+  if (hasRtfContent) {
+    type = 'text';
+  } else if (files.length > 0) {
+    type = 'file';
+  } else if (fragmentContent && Array.isArray(fragmentContent)) {
+    type = 'fragment';
+  } else if (htmlContent) {
+    type = 'html';
+  }
+
+  return {
+    text: textContent,
+    html: htmlContent,
+    fragment: fragmentContent,
+    type: type,
+    files: files
+  };
+};
+
+export default getEventTransfer;

package/dist/editor/custom/getNodesByTypeAtRange.js

@@ -0,0 +1,69 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { Editor, Range } from 'slate'; // modified on the basic of the slate function Editor.nodes
+// todo: get the node which nearest to the selection
+
+var getNodesByTypeAtRange = function getNodesByTypeAtRange(editor, type) {
+  var match = {};
+
+  if (Array.isArray(type)) {
+    match.match = type;
+  } else {
+    match.match = {
+      type: type
+    };
+  }
+
+  var nodes = Editor.nodes(editor, match);
+
+  var _Editor$nodes = Editor.nodes(editor, {
+    match: 'block'
+  }),
+      _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
+      blockNode = _Editor$nodes2[0];
+
+  var listItemDepth = blockNode[1].length - 1;
+
+  if (Range.isCollapsed(editor.selection)) {
+    var node;
+
+    var _iterator = _createForOfIteratorHelper(nodes),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var item = _step.value;
+        node = item;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return node;
+  } else {
+    var itemsWithSameAncesstor = [];
+
+    var _iterator2 = _createForOfIteratorHelper(nodes),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _node = _step2.value;
+
+        if (listItemDepth === _node[1].length) {
+          itemsWithSameAncesstor.push(_node);
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+
+    return itemsWithSameAncesstor;
+  }
+};
+
+export default getNodesByTypeAtRange;

package/dist/editor/custom/insertNodes.js

@@ -0,0 +1,140 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { Editor, Range, Path, Node, Point, Text } from 'slate'; // modifyed function from slate
+// The goal of the modification: focus the selection to the end of the last inserted node
+
+export var insertNodes = function insertNodes(editor, nodes) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Editor.withoutNormalizing(editor, function () {
+    // eslint-disable-next-line no-unused-vars
+    var selection = editor.selection;
+    var _options$hanging = options.hanging,
+        hanging = _options$hanging === void 0 ? false : _options$hanging,
+        _options$voids = options.voids,
+        voids = _options$voids === void 0 ? false : _options$voids;
+    var at = options.at,
+        match = options.match,
+        select = options.select;
+
+    if (Node.isNode(nodes)) {
+      nodes = [nodes];
+    }
+
+    if (nodes.length === 0) {
+      return;
+    }
+
+    var _nodes = nodes,
+        _nodes2 = _slicedToArray(_nodes, 1),
+        node = _nodes2[0]; // By default, use the selection as the target location. But if there is
+    // no selection, insert at the end of the document since that is such a
+    // common use case when inserting from a non-selected state.
+
+
+    if (!at) {
+      if (editor.selection) {
+        at = editor.selection;
+      } else if (editor.children.length > 0) {
+        at = Editor.end(editor, []);
+      } else {
+        at = [0];
+      }
+
+      select = true;
+    }
+
+    if (select == null) {
+      select = false;
+    }
+
+    if (Range.isRange(at)) {
+      if (!hanging) {
+        at = Editor.unhangRange(editor, at);
+      }
+
+      if (Range.isCollapsed(at)) {
+        at = at.anchor;
+      } else {
+        var _Range$edges = Range.edges(at),
+            _Range$edges2 = _slicedToArray(_Range$edges, 2),
+            end = _Range$edges2[1];
+
+        var pointRef = Editor.pointRef(editor, end);
+        Editor.delete(editor, {
+          at: at
+        });
+        at = pointRef.unref();
+      }
+    }
+
+    if (Point.isPoint(at)) {
+      if (match == null) {
+        if (Text.isText(node)) {
+          match = 'text';
+        } else if (editor.isInline(node)) {
+          match = ['inline', 'text'];
+        } else {
+          match = 'block';
+        }
+      }
+
+      var atMatch = Editor.match(editor, at.path, match);
+
+      if (atMatch) {
+        var _atMatch = _slicedToArray(atMatch, 2),
+            matchPath = _atMatch[1];
+
+        var pathRef = Editor.pathRef(editor, matchPath);
+        var isAtEnd = Editor.isEnd(editor, at, matchPath);
+        Editor.splitNodes(editor, {
+          at: at,
+          match: match
+        });
+
+        var _path = pathRef.unref();
+
+        at = isAtEnd ? Path.next(_path) : _path;
+      } else {
+        return;
+      }
+    }
+
+    var parentPath = Path.parent(at);
+    var index = at[at.length - 1];
+
+    if (!voids && Editor.match(editor, parentPath, 'void')) {
+      return;
+    }
+
+    var path = [];
+
+    var _iterator = _createForOfIteratorHelper(nodes),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _node = _step.value;
+        path = parentPath.concat(index);
+        index++;
+        at = path;
+        editor.apply({
+          type: 'insert_node',
+          path: path,
+          node: _node
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    if (select) {
+      var point = Editor.end(editor, at);
+
+      if (point) {
+        Editor.select(editor, point);
+      }
+    }
+  });
+};

package/dist/editor/custom/is-empty-paragraph.js

@@ -0,0 +1,13 @@
+import { Node, Text } from 'slate';
+
+var isEmptyParagraph = function isEmptyParagraph(node) {
+  if (node.type !== 'paragraph') return false;
+
+  if (node.children.length === 1 && Text.isText(node.children[0]) && Node.text(node).length === 0) {
+    return true;
+  }
+
+  return false;
+};
+
+export default isEmptyParagraph;