@seafile/seafile-editor 0.3.76

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

@@ -0,0 +1,376 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { Editor } from 'slate';
+import ListUtils from '../editor-utils/block-element-utils/list-utils';
+import CodeUtils from '../editor-utils/block-element-utils/code-utils';
+import { isRangeCollapsed } from '../editor-utils/range-utils';
+import TableUtils from '../editor-utils/block-element-utils/table-utils';
+import getEventTransfer from '../custom/get-event-transfer';
+import BlockquoteUtils from '../editor-utils/block-element-utils/blockquote-utils';
+import FormulaUtils from '../editor-utils/block-element-utils/formula-utils';
+import { htmlDeserializer } from '../../utils/deserialize-html';
+import generateLinkElement from '../element-model/link';
+import generateImageElement from '../element-model/image';
+import isUrl from 'is-url';
+import { SfEditor } from '../custom/custom';
+
+var withBlock = function withBlock(editor) {
+  var exec = editor.exec;
+  var listUtils = new ListUtils(editor);
+  var codeUtils = new CodeUtils(editor);
+  var tableUtils = new TableUtils(editor);
+  var blockquoteUtils = new BlockquoteUtils(editor);
+  var formulaUtils = new FormulaUtils(editor);
+
+  editor.exec = function (command) {
+    var data = command.data;
+    var selection = editor.selection;
+
+    switch (command.type) {
+      case 'set_header':
+        Editor.setNodes(editor, {
+          type: command.headerType
+        });
+        break;
+
+      case 'insert_data':
+        var _getEventTransfer = getEventTransfer(data),
+            fragment = _getEventTransfer.fragment,
+            type = _getEventTransfer.type,
+            html = _getEventTransfer.html,
+            text = _getEventTransfer.text;
+
+        if (type === 'file') {
+          exec(command);
+          return;
+        } // insert a link if text content is a url
+
+
+        if (isUrl(text) && !codeUtils.isInCodeBlock()) {
+          if (text.endsWith('png') || text.endsWith('PNG') || text.endsWith('jpg') || text.endsWith('JPG') || text.endsWith('gif') || text.endsWith('GIF')) {
+            var img = generateImageElement({
+              data: {
+                src: text
+              }
+            });
+            Editor.insertNodes(editor, img);
+            return;
+          }
+
+          if (window.editor.editorApi.isInternalFileLink(text)) {
+            var index = text.lastIndexOf('/');
+
+            if (index > 0) {
+              var name = text.substring(index + 1);
+              var fileName = decodeURIComponent(name);
+              SfEditor.insertNodes(editor, [generateLinkElement({
+                data: {
+                  href: text
+                },
+                children: [{
+                  text: fileName
+                }]
+              }), {
+                text: ' '
+              }]);
+              return;
+            }
+          }
+
+          if (window.editor.editorApi.isInternalDirLink(text)) {
+            var _index = text.lastIndexOf('/');
+
+            if (_index > 0) {
+              var name = text.substring(_index + 1);
+              var dirName = decodeURIComponent(name);
+              SfEditor.insertNodes(editor, [generateLinkElement({
+                data: {
+                  href: text
+                },
+                children: [{
+                  text: dirName
+                }]
+              }), {
+                text: ' '
+              }]);
+              return;
+            }
+          }
+
+          SfEditor.insertNodes(editor, [generateLinkElement({
+            data: {
+              href: text
+            },
+            children: [{
+              text: text
+            }]
+          }), {
+            text: ' '
+          }]);
+          return;
+        }
+
+        try {
+          if (tableUtils.isInTable()) {
+            tableUtils.pasteContentInTable(command);
+            return;
+          }
+
+          if (listUtils.isInlist()) {
+            listUtils.pasteContentInList(command);
+            return;
+          }
+
+          if (codeUtils.isInCodeBlock()) {
+            codeUtils.pasteContentInCodeBlock(command);
+            return;
+          }
+
+          if (blockquoteUtils.isInBlockquote()) {
+            blockquoteUtils.pasteContentInBlockquote(command);
+            return;
+          }
+        } catch (error) {
+          Editor.insertText(editor, text);
+        }
+
+        if (type === 'fragment') {
+          var _Editor$match = Editor.match(editor, editor.selection, 'block'),
+              _Editor$match2 = _slicedToArray(_Editor$match, 2),
+              currentBlock = _Editor$match2[0],
+              path = _Editor$match2[1];
+
+          var firstFragmentNode = fragment[0]; // if first fragment node is paragraph insert the content of it into previous sibling
+          // and insert other node
+
+          if (firstFragmentNode.type === 'paragraph') {
+            Editor.insertFragment(editor, fragment);
+            return;
+          } // if current node is an empty paragraph, insert the fragment and
+          // delete the empty paragraph
+
+
+          if (SfEditor.isEmptyParagraph(currentBlock)) {
+            Editor.insertNodes(editor, fragment);
+            Editor.delete(editor, {
+              at: path
+            });
+            return;
+          } // insert the fragment below the current selection node
+
+
+          Editor.insertNodes(editor, fragment);
+          return;
+        }
+
+        if (type === 'html') {
+          try {
+            var _fragment = htmlDeserializer(html);
+
+            Editor.insertFragment(editor, _fragment);
+          } catch (error) {
+            var newText = text.replace(/\n|\r\n/g, ' ');
+            Editor.insertText(editor, newText);
+          }
+
+          return;
+        } // remove text line break and insert text
+
+
+        if (type === 'text') {
+          var textArray = text.split(/\r\n|\n/g);
+          textArray.forEach(function (text, index) {
+            if (index === 0) {
+              Editor.insertText(editor, text);
+            } else {
+              Editor.insertNodes(editor, {
+                type: 'paragraph',
+                children: [{
+                  text: text
+                }]
+              });
+            }
+          });
+          return;
+        }
+
+        exec(command);
+        break;
+
+      case 'set_blockquote':
+        if (!selection) {
+          return;
+        }
+
+        blockquoteUtils.wrapBlockquote();
+        break;
+
+      case 'unwrap_blockquote':
+        blockquoteUtils.unwrapBlockquote();
+        break;
+
+      case 'set_ordered_list':
+        if (!selection) {
+          return;
+        }
+
+        listUtils.wrapList('ordered_list');
+        break;
+
+      case 'set_unordered_list':
+        if (!selection) {
+          return;
+        }
+
+        listUtils.wrapList('unordered_list');
+        break;
+
+      case 'unwrap_unordered_list':
+      case 'unwrap_ordered_list':
+        listUtils.unwrapList();
+        break;
+
+      case 'wrap_check_list_item':
+        var listItem = listUtils.getCurrentListItem();
+
+        if (listItem.length === 0) {
+          // not in list, add list
+          listUtils.wrapList('unordered_list');
+          Editor.setNodes(editor, {
+            data: {
+              checked: false
+            }
+          }, {
+            match: {
+              type: 'list_item'
+            }
+          });
+        } else {
+          var listItems = Editor.nodes(editor, {
+            at: editor.selection,
+            match: {
+              type: 'list_item'
+            }
+          });
+          var nearestItem;
+
+          var _iterator = _createForOfIteratorHelper(listItems),
+              _step;
+
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var _listItem = _step.value;
+              nearestItem = _listItem;
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+
+          Editor.setNodes(editor, {
+            data: {
+              checked: false
+            }
+          }, {
+            at: nearestItem[1]
+          });
+        }
+
+        break;
+
+      case 'unwrap_check_list_item':
+        var item = listUtils.getCurrentListItem();
+        Editor.setNodes(editor, {
+          data: {}
+        }, {
+          at: item[0][1]
+        });
+        break;
+
+      case 'set_code_block':
+        codeUtils.wrapCodeBlock();
+        break;
+
+      case 'unwrap_code_block':
+        codeUtils.unwrapCodeBlock();
+        break;
+
+      case 'exit_code_block':
+        Editor.splitNodes(editor, {
+          match: 'block',
+          always: true
+        });
+        codeUtils.unwrapCodeBlock(true);
+        break;
+
+      case 'increase_code_block_indent':
+        if (isRangeCollapsed(editor.selection)) {
+          var block = Editor.match(editor, editor.selection, 'block');
+          Editor.insertText(editor, '\t', {
+            at: {
+              anchor: {
+                path: [].concat(_toConsumableArray(block[1]), [0]),
+                offset: 0
+              },
+              focus: {
+                path: [].concat(_toConsumableArray(block[1]), [0]),
+                offset: 0
+              }
+            }
+          });
+        }
+
+        break;
+
+      case 'insert_table':
+        tableUtils.insertTable();
+        break;
+
+      case 'remove_table':
+        tableUtils.removeTable();
+        break;
+
+      case 'insert_row':
+        tableUtils.insertRow();
+        break;
+
+      case 'insert_column':
+        tableUtils.insertColumn();
+        break;
+
+      case 'remove_row':
+        tableUtils.removeRow();
+        break;
+
+      case 'remove_column':
+        tableUtils.removeColumn();
+        break;
+
+      case 'set_table_cell_align':
+        tableUtils.setAlign(command.align);
+        break;
+
+      case 'exit_table':
+        tableUtils.exitTable();
+        break;
+
+      case 'insert_formula':
+        formulaUtils.insertFormula(command.data);
+        break;
+
+      case 'set_formula':
+        formulaUtils.setFormula(command.data);
+        break;
+
+      default:
+        exec(command);
+        break;
+    }
+  };
+
+  return editor;
+};
+
+export default withBlock;

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

@@ -0,0 +1,129 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { Editor, Range } from 'slate';
+import generateLinkElement from '../element-model/link';
+import generateImageElement from '../element-model/image';
+
+var withInline = function withInline(editor) {
+  var exec = editor.exec,
+      isInline = editor.isInline;
+
+  editor.isInline = function (element) {
+    return element.type === 'link' || element.type === 'image' ? true : isInline(element);
+  };
+
+  editor.exec = function (command) {
+    var data = command.data;
+    var selection = editor.selection;
+
+    switch (command.type) {
+      case 'insert_link_at_selection':
+        selection = command.elementData.selection;
+        var isCollapsed = selection && Range.isCollapsed(selection);
+        var link = generateLinkElement({
+          type: 'link',
+          children: [{
+            text: command.elementData.text
+          }],
+          data: {
+            href: command.elementData.url
+          }
+        });
+
+        if (isCollapsed) {
+          Editor.insertNodes(editor, link, {
+            at: selection
+          });
+        } else {
+          Editor.wrapNodes(editor, link, {
+            split: true,
+            at: selection
+          });
+          Editor.select(editor, selection);
+          Editor.collapse(editor, {
+            edge: 'end'
+          });
+        }
+
+        break;
+
+      case 'unwrap_link':
+        Editor.unwrapNodes(editor, {
+          match: {
+            type: 'link'
+          }
+        });
+        break;
+
+      case 'set_link':
+        selection = command.elementData.selection;
+        Editor.removeNodes(editor, {
+          match: {
+            type: 'link'
+          },
+          at: selection
+        });
+        var newNodeLink = generateLinkElement({
+          type: 'link',
+          data: {
+            href: command.elementData.url
+          },
+          children: [{
+            text: command.elementData.text
+          }]
+        }); // Insert a new link at previous link path
+
+        var linkPath = _toConsumableArray(selection.anchor.path);
+
+        linkPath.pop();
+        Editor.insertNodes(editor, newNodeLink, {
+          at: linkPath
+        });
+        break;
+
+      case 'insert_image_at_selection':
+        var img = generateImageElement({
+          data: command.data
+        });
+        Editor.insertNodes(editor, img, {
+          at: command.at
+        });
+        break;
+
+      case 'set_image':
+        Editor.setNodes(editor, {
+          data: data
+        }, {
+          match: {
+            type: 'image'
+          },
+          at: editor.selection,
+          voids: true
+        });
+        break;
+
+      case 'insert_data':
+        if (data.types.includes('Files') && data.files[0].type.includes('image') && window.editor.editorApi.uploadLocalImage) {
+          window.editor.editorApi.uploadLocalImage(command.data.files[0]).then(function (res) {
+            var img = generateImageElement({
+              data: {
+                src: res
+              }
+            });
+            Editor.insertNodes(editor, img);
+          });
+          return;
+        }
+
+        exec(command);
+        break;
+
+      default:
+        exec(command);
+        break;
+    }
+  };
+
+  return editor;
+};
+
+export default withInline;

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

@@ -0,0 +1,107 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { SfEditor } from '../custom/custom';
+import { Node, Text, Path } from 'slate';
+
+var normalizeNode = function normalizeNode(editor) {
+  var normalizeNode = editor.normalizeNode;
+
+  editor.normalizeNode = function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+        node = _ref2[0],
+        path = _ref2[1];
+
+    // if current node is a list node
+    var type = node.type; // wrap the outest list item into unoreded list
+
+    if (path.length === 1 && type === 'list_item') {
+      SfEditor.wrapNodes(editor, {
+        type: 'unordered_list',
+        children: [node]
+      }, {
+        at: path
+      });
+    }
+
+    if (type === 'ordered_list' || type === 'unordered_list') {
+      var currentNodeIndex = path.slice(-1)[0];
+      var previousSibling;
+
+      if (currentNodeIndex !== 0) {
+        previousSibling = Node.get(editor, Path.previous(path));
+      }
+
+      if (previousSibling && previousSibling.type === type) {
+        // merge previous same type list node
+        SfEditor.mergeNodes(editor, {
+          at: path
+        });
+      }
+
+      var parentNode = Node.parent(editor, path);
+      var nextIndex = currentNodeIndex + 1;
+      var nextSiblings = parentNode.children[nextIndex];
+
+      if (nextSiblings && nextSiblings.type === type) {
+        // merge next same type list node
+        SfEditor.mergeNodes(editor, {
+          at: Path.next(path)
+        });
+      }
+    } // trailing a paragrph at the end of the document
+
+
+    if (path.length === 1 && path[0] === editor.children.length - 1) {
+      if (node.type !== 'paragraph' || !SfEditor.isEmptyParagraph(node)) {
+        SfEditor.insertNodes(editor, {
+          type: 'paragraph',
+          children: [{
+            text: ''
+          }]
+        }, {
+          at: [path[0] + 1]
+        });
+      }
+    }
+
+    if (type === 'blockquote') {
+      node.children.forEach(function (child, index) {
+        var childPath = [].concat(_toConsumableArray(path), [index]);
+
+        if (child.type === 'blockquote') {
+          SfEditor.unwrapNodes(editor, {
+            at: childPath
+          });
+        }
+      });
+    } // remove empty link
+
+
+    if (type === 'link') {
+      if (Node.text(node) === '' && node.children.length > 0) {
+        SfEditor.removeNodes(editor, {
+          at: path
+        });
+      }
+    } // remove mark when the text node is empty
+
+
+    if (Text.isText(node) && node.text.length === 0) {
+      if (Object.keys(node).length > 1) {
+        SfEditor.setNodes(editor, {
+          CODE: false,
+          BOLD: false,
+          ITALIC: false
+        }, {
+          at: path
+        });
+      }
+    }
+
+    return normalizeNode([node, path]);
+  };
+
+  return editor;
+};
+
+export default normalizeNode;