@seafile/seafile-editor 0.3.76

package/dist/editor/editor-plugin.js

@@ -0,0 +1,249 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import isHotKey from 'is-hotkey';
+import { Range, Editor, Path, Node } from 'slate';
+import ListUtils from './editor-utils/block-element-utils/list-utils';
+import CodeUtils from './editor-utils/block-element-utils/code-utils';
+import TableUtils from './editor-utils/block-element-utils/table-utils';
+import setEventTransfer from './custom/set-event-transfer';
+import { SfEditor } from '../editor/custom/custom';
+
+var Plugin = function Plugin(_editor) {
+  var _this = this;
+
+  _classCallCheck(this, Plugin);
+
+  this.onKeyDown = function (event) {
+    if (event.nativeEvent.keyCode === 13) {
+      event.preventDefault();
+
+      if (isHotKey('shift+enter', event)) {
+        if (_this.listUtils.isInlist()) {
+          _this.editor.exec({
+            type: 'split_list_item'
+          });
+        }
+      } else if (isHotKey('mod+enter', event)) {
+        if (_this.codeUtils.isInCodeBlock()) {
+          _this.editor.exec({
+            type: 'exit_code_block'
+          });
+        }
+
+        if (_this.tableUtils.isInTable()) {
+          _this.editor.exec({
+            type: 'exit_table'
+          });
+        }
+      } else {
+        _this.editor.exec({
+          type: 'insert_break'
+        });
+      }
+    }
+
+    if (isHotKey('shift+tab', event)) {
+      event.preventDefault();
+
+      if (_this.listUtils.isInlist()) {
+        var _Editor$nodes = Editor.nodes(_this.editor, {
+          match: [{
+            type: 'unordered_list'
+          }, {
+            type: 'ordered_list'
+          }],
+          at: _this.editor.selection,
+          mode: 'highest'
+        }),
+            _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
+            listNode = _Editor$nodes2[0];
+
+        if (!listNode) return;
+        var type = listNode[0].type;
+
+        _this.editor.exec({
+          type: "unwrap_".concat(type)
+        });
+      }
+    }
+
+    if (isHotKey('mod+s', event)) {
+      event.preventDefault();
+      _this.editor.onSave && _this.editor.onSave();
+    }
+
+    if (isHotKey('tab', event) && Range.isCollapsed(_this.editor.selection)) {
+      event.preventDefault();
+
+      if (_this.codeUtils.isInCodeBlock()) {
+        _this.editor.exec({
+          type: 'increase_code_block_indent'
+        });
+      }
+
+      if (_this.listUtils.isInlist()) {
+        _this.editor.exec({
+          type: 'increase_list_item_depth'
+        });
+      }
+    }
+
+    if (isHotKey('mod+b', event)) {
+      event.preventDefault();
+
+      if (!_this.codeUtils.isInCodeBlock()) {
+        _this.editor.exec({
+          type: 'format_text',
+          properties: {
+            BOLD: true
+          }
+        });
+      }
+    }
+
+    if (isHotKey('mod+i', event)) {
+      event.preventDefault();
+
+      if (!_this.codeUtils.isInCodeBlock()) {
+        _this.editor.exec({
+          type: 'format_text',
+          properties: {
+            ITALIC: true
+          }
+        });
+      }
+    }
+
+    if (isHotKey('mod+/', event)) {
+      event.preventDefault();
+
+      if (!_this.codeUtils.isInCodeBlock()) {
+        _this.editor.exec({
+          type: 'format_text',
+          properties: {
+            CODE: true
+          }
+        });
+      }
+    }
+
+    if (isHotKey('mod+4', {
+      byKey: true
+    })(event)) {
+      event.preventDefault();
+      window.richMarkdownEditor.onToggleFormulaDialog();
+      return;
+    } // compate chrome: in chrome press backspace would not exec delete_backward command
+
+
+    if (isHotKey('backspace', event)) {
+      var voidNode = SfEditor.match(_this.editor, _this.editor.selection, 'void');
+
+      if (voidNode && (voidNode[0].type === 'image' || voidNode[0].type === 'formula')) {
+        event.preventDefault();
+
+        _this.editor.exec({
+          type: 'delete_backward',
+          unit: 'character'
+        });
+
+        return;
+      }
+    }
+
+    if (isHotKey('mod+a', event)) {
+      if (_this.codeUtils.isInCodeBlock()) {
+        var anchorPoint = _this.editor.selection.anchor;
+        var focusPoint = _this.editor.selection.focus;
+        var anchorCodeBlock = Editor.match(_this.editor, anchorPoint, {
+          type: 'code_block'
+        });
+        var focusCodeBlock = Editor.match(_this.editor, focusPoint, {
+          type: 'code_block'
+        });
+
+        if (anchorCodeBlock && focusCodeBlock && Path.equals(focusCodeBlock[1], anchorCodeBlock[1])) {
+          event.preventDefault();
+          Editor.select(_this.editor, focusCodeBlock[1]);
+          return;
+        }
+      }
+    }
+  };
+
+  this.onCut = function (event, editor) {
+    var image = SfEditor.match(_this.editor, _this.editor.selection, {
+      type: 'image'
+    });
+
+    if (image) {
+      // write the image element to clipboard
+      setEventTransfer(event, 'fragment', [{
+        type: 'paragraph',
+        children: [image[0]]
+      }]); // remove the image element when cut an image due to slate did not has the action when cut a image
+
+      _this.editor.exec({
+        type: 'delete_backward',
+        unit: 'character'
+      });
+
+      return;
+    }
+  };
+
+  this.onCopy = function (event, editor) {
+    if (_this.tableUtils.isInTable()) {
+      event.preventDefault();
+
+      var table = _this.tableUtils.getSelectedTableCells();
+
+      if (!table) {
+        setEventTransfer(event, 'text', SfEditor.text(editor, editor.selection));
+        return;
+      }
+
+      setEventTransfer(event, 'fragment', table);
+      return;
+    }
+
+    if (_this.codeUtils.isInCodeBlock() && !Range.isCollapsed(editor.selection)) {
+      var anchorPoint = editor.selection.anchor;
+      var focusPoint = editor.selection.focus;
+      var anchorCodeBlock = Editor.match(_this.editor, anchorPoint, {
+        type: 'code_block'
+      });
+      var focusCodeBlock = Editor.match(_this.editor, focusPoint, {
+        type: 'code_block'
+      });
+      /* 
+        If the selection is within the range of the selected code block 
+        copy the selected code line as paragraph
+      */
+
+      if (anchorCodeBlock && focusCodeBlock && Path.equals(focusCodeBlock[1], anchorCodeBlock[1])) {
+        event.preventDefault();
+        var fragment = Node.fragment(editor, editor.selection);
+        fragment = fragment[0].children.map(function (codeLine) {
+          var text = Node.text(codeLine);
+          return {
+            type: 'paragraph',
+            children: [{
+              text: text
+            }]
+          };
+        });
+        setEventTransfer(event, 'fragment', fragment);
+        return;
+      }
+    }
+  };
+
+  this.editor = _editor;
+  this.listUtils = new ListUtils(_editor);
+  this.codeUtils = new CodeUtils(_editor);
+  this.tableUtils = new TableUtils(_editor);
+  this.onSave = _editor.onSave;
+};
+
+export default Plugin;

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

@@ -0,0 +1,96 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import { SfEditor } from '../../custom/custom';
+import { Node } from 'slate';
+import generateBlockquote from '../../element-model/blockquote';
+import getEventTransfer from '../../custom/get-event-transfer';
+import { htmlDeserializer } from '../../../utils/deserialize-html';
+import { normailizeSelection } from '../selection-utils';
+
+var BlockquoteUtils = function BlockquoteUtils(editor) {
+  var _this = this;
+
+  _classCallCheck(this, BlockquoteUtils);
+
+  this.getCurrentBlockquote = function () {
+    var block = SfEditor.match(_this.editor, _this.editor.selection.anchor, 'block');
+    var blockPath = block[1];
+    var parent = Node.parent(_this.editor, blockPath);
+
+    if (parent && parent.type === 'blockquote') {
+      return parent;
+    }
+
+    return null;
+  };
+
+  this.isInBlockquote = function () {
+    return Boolean(_this.getCurrentBlockquote());
+  };
+
+  this.wrapBlockquote = function () {
+    normailizeSelection(_this.editor);
+    var selection = _this.editor.selection;
+    var currentPath = SfEditor.path(_this.editor, selection);
+    var outestElementAtPath = _this.editor.children[currentPath[0]];
+    var blockquote = generateBlockquote({
+      children: [outestElementAtPath]
+    });
+    SfEditor.wrapNodes(_this.editor, blockquote);
+  };
+
+  this.unwrapBlockquote = function () {
+    normailizeSelection(_this.editor);
+    SfEditor.unwrapNodes(_this.editor, {
+      split: true,
+      match: {
+        type: 'blockquote'
+      }
+    });
+  };
+
+  this.pasteContentInBlockquote = 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') {
+      var textArray = text.split(/\r\n|\n/g);
+      textArray.forEach(function (text, index) {
+        if (index === 0) {
+          SfEditor.insertText(_this.editor, text);
+        } else {
+          SfEditor.insertNodes(_this.editor, {
+            type: 'paragraph',
+            children: [{
+              text: text
+            }]
+          });
+        }
+      });
+      return;
+    }
+
+    if (type === 'html') {
+      fragment = htmlDeserializer(html);
+    }
+
+    var block = SfEditor.match(_this.editor, _this.editor.selection, 'block');
+
+    if (Node.text(block[0]).length === 0) {
+      SfEditor.removeNodes(_this.editor, {
+        match: 'block'
+      });
+    }
+
+    SfEditor.insertNodes(_this.editor, fragment);
+    return;
+  };
+
+  this.editor = editor;
+};
+
+export default BlockquoteUtils;

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

@@ -0,0 +1,162 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import { SfEditor } from '../../custom/custom';
+import { Node } from 'slate';
+import detectIndent from 'detect-indent';
+import getEventTransfer from '../../custom/get-event-transfer';
+import { normailizeSelection } from '../selection-utils';
+
+var CodeUtils = /*#__PURE__*/function () {
+  function CodeUtils(editor) {
+    var _this = this;
+
+    _classCallCheck(this, CodeUtils);
+
+    this.isInCodeBlock = function () {
+      var block = SfEditor.match(_this.editor, _this.editor.selection.anchor, 'block');
+      var blockParent = Node.parent(_this.editor, block[1]);
+      if (blockParent.type === 'code_block') return true;
+      return false;
+    };
+
+    this.getIndent = function (text) {
+      return detectIndent(text).indent;
+    };
+
+    this.insertIndent = function (indent) {
+      SfEditor.insertText(_this.editor, indent, {
+        at: _this.editor.selection
+      });
+    };
+
+    this.wrapCodeBlock = function () {
+      normailizeSelection(_this.editor);
+      SfEditor.setNodes(_this.editor, {
+        type: 'code_line'
+      }, {
+        match: 'block',
+        at: _this.editor.selection
+      });
+      SfEditor.wrapNodes(_this.editor, {
+        type: 'code_block',
+        children: [],
+        data: {}
+      });
+      SfEditor.collapse(_this.editor, {
+        edge: 'end'
+      });
+    };
+
+    this.splitCodeLine = function () {
+      var block = SfEditor.match(_this.editor, _this.editor.selection, 'block');
+
+      var indent = _this.getIndent(Node.text(block[0]));
+
+      SfEditor.splitNodes(_this.editor, {
+        split: true,
+        always: true,
+        at: _this.editor.selection
+      });
+
+      _this.insertIndent(indent);
+    };
+
+    this.unwrapCodeBlock = function () {
+      var split = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var codeBlock = SfEditor.match(_this.editor, _this.editor.selection, {
+        type: 'code_block'
+      });
+      var codeBlockPath = codeBlock[1]; // unwrap whole code block 
+
+      if (!split) {
+        codeBlock[0].children.forEach(function (codeLine, index) {
+          var path = [].concat(_toConsumableArray(codeBlockPath), [index]);
+          SfEditor.setNodes(_this.editor, {
+            type: 'paragraph'
+          }, {
+            at: path
+          });
+        });
+      } else {
+        // unwrap a code line
+        SfEditor.setNodes(_this.editor, {
+          type: 'paragraph'
+        }, {
+          at: _this.editor.selection,
+          match: 'block'
+        });
+      }
+
+      SfEditor.unwrapNodesByTypeAtRange(_this.editor, {
+        at: _this.editor.selection,
+        split: split,
+        match: {
+          type: 'code_block'
+        }
+      });
+    };
+
+    this.editor = editor;
+  }
+
+  _createClass(CodeUtils, [{
+    key: "pasteContentInCodeBlock",
+    value: function pasteContentInCodeBlock(command) {
+      var _this2 = this;
+
+      var data = command.data;
+
+      var _getEventTransfer = getEventTransfer(data),
+          text = _getEventTransfer.text,
+          fragment = _getEventTransfer.fragment,
+          type = _getEventTransfer.type;
+
+      if (text.length === 0) return;
+
+      if (type === 'text' || type === 'html') {
+        var codeLineFragment = text.split(/\r\n|\n/).map(function (textLine) {
+          return {
+            type: 'code_line',
+            children: [{
+              text: textLine
+            }]
+          };
+        });
+        SfEditor.insertFragment(this.editor, codeLineFragment);
+        return;
+      }
+
+      fragment.map(function (node, index) {
+        if (node.type === 'code_block') {
+          node.children.forEach(function (codeLine, index1) {
+            if (index1 === 0) {
+              SfEditor.insertText(_this2.editor, Node.text(codeLine));
+              return;
+            }
+
+            SfEditor.insertNodes(_this2.editor, codeLine);
+          });
+          return true;
+        }
+
+        if (index === 0) {
+          SfEditor.insertText(_this2.editor, Node.text(node));
+        } else {
+          SfEditor.insertNodes(_this2.editor, {
+            type: 'code_line',
+            children: [{
+              text: Node.text(node)
+            }]
+          });
+        }
+
+        return true;
+      });
+    }
+  }]);
+
+  return CodeUtils;
+}();
+
+export default CodeUtils;

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

@@ -0,0 +1,58 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import { SfEditor } from '../../custom/custom';
+
+var FormulaUtils = /*#__PURE__*/function () {
+  function FormulaUtils(editor) {
+    _classCallCheck(this, FormulaUtils);
+
+    this.editor = editor;
+  }
+
+  _createClass(FormulaUtils, [{
+    key: "isFormulaActive",
+    value: function isFormulaActive() {
+      var nodes = SfEditor.match(this.editor, this.editor.selection, {
+        type: 'formula'
+      });
+
+      if (nodes) {
+        return true;
+      }
+
+      return false;
+    }
+  }, {
+    key: "insertFormula",
+    value: function insertFormula(data) {
+      SfEditor.insertNodes(this.editor, {
+        type: 'formula',
+        children: [{
+          text: ''
+        }],
+        data: data
+      }, {
+        at: data.at,
+        void: true
+      });
+    }
+  }, {
+    key: "setFormula",
+    value: function setFormula(data) {
+      var formula = data.formula,
+          at = data.at;
+      SfEditor.setNodes(this.editor, {
+        data: {
+          formula: formula
+        }
+      }, {
+        at: at,
+        void: true
+      });
+    }
+  }]);
+
+  return FormulaUtils;
+}();
+
+export default FormulaUtils;

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

@@ -0,0 +1,38 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import { Editor } from 'slate';
+
+var BlockElementUtils = function BlockElementUtils(editor) {
+  var _this = this;
+
+  _classCallCheck(this, BlockElementUtils);
+
+  this.getActiveHeader = function (types) {
+    var selection = _this.editor.selection;
+    if (!selection) return false;
+    var match = Editor.match(_this.editor, selection, types);
+    if (!match) return [{
+      type: 'paragraph'
+    }];
+    return match;
+  };
+
+  this.isBlockActive = function (type) {
+    var selection = _this.editor.selection;
+    if (!selection) return false;
+
+    var _Editor$nodes = Editor.nodes(_this.editor, {
+      match: {
+        type: type
+      }
+    }),
+        _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
+        match = _Editor$nodes2[0];
+
+    return !!match;
+  };
+
+  this.editor = editor;
+};
+
+export default BlockElementUtils;