@seafile/seafile-editor 0.3.76

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

@@ -0,0 +1,31 @@
+import { Node } from 'slate';
+var TRANSFER_TYPES = {
+  fragment: 'application/x-slate-fragment',
+  html: 'text/html',
+  text: 'text/plain'
+}; // tranfrom slate fragment and write to clipboard
+
+function setEventTransfer(event, type, content) {
+  var mime = TRANSFER_TYPES[type];
+  var transfer = event.dataTransfer || event.clipboardData;
+
+  if (type === 'fragment') {
+    // use the same encoding as slate
+    var encodedContent = window.btoa(encodeURIComponent(JSON.stringify(content)));
+    transfer.setData(mime, encodedContent);
+    var texts = '';
+    var textItem = '';
+    content.forEach(function (element) {
+      textItem = Node.text(element).replace(/\ufeff/, '');
+      texts += textItem + '\r\n';
+    });
+    transfer.setData('text', texts);
+  } else if (type === 'html') {
+    transfer.setData(mime, content);
+    transfer.setData('text', transfer.getData('text'));
+  } else {
+    transfer.setData('text', content);
+  }
+}
+
+export default setEventTransfer;

package/dist/editor/custom/split-nodes-at-point.js

@@ -0,0 +1,162 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+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 { Element, Editor, Range, Path } from 'slate'; // modified on the basic of slate function Editor.SplitNodes
+// todo: split the node which nearest to the selection
+
+var splitNodesAtPoint = function splitNodesAtPoint(editor) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  Editor.withoutNormalizing(editor, function () {
+    var match = options.match,
+        _options$at = options.at,
+        at = _options$at === void 0 ? editor.selection : _options$at,
+        _options$height = options.height,
+        height = _options$height === void 0 ? 0 : _options$height,
+        _options$always = options.always,
+        always = _options$always === void 0 ? false : _options$always,
+        _options$voids = options.voids,
+        voids = _options$voids === void 0 ? false : _options$voids;
+
+    if (match == null) {
+      match = 'block';
+    }
+
+    if (Range.isRange(at)) {
+      at = deleteRange(editor, at);
+    }
+
+    if (!at) {
+      return;
+    }
+
+    var beforeRef = Editor.pointRef(editor, at, {
+      affinity: 'backward'
+    });
+    var nodes = Editor.nodes(editor, {
+      at: at,
+      match: match,
+      voids: voids
+    });
+
+    var highest = _toConsumableArray(nodes).pop();
+
+    if (!highest) {
+      return;
+    }
+
+    var voidMatch = Editor.match(editor, at, 'void');
+    var nudge = 0;
+
+    if (!voids && voidMatch) {
+      var _voidMatch = _slicedToArray(voidMatch, 2),
+          voidNode = _voidMatch[0],
+          voidPath = _voidMatch[1];
+
+      if (Element.isElement(voidNode) && editor.isInline(voidNode)) {
+        var after = Editor.after(editor, voidPath);
+
+        if (!after) {
+          var text = {
+            text: ''
+          };
+          var afterPath = Path.next(voidPath);
+          Editor.insertNodes(editor, text, {
+            at: afterPath,
+            voids: voids
+          });
+          after = Editor.point(editor, afterPath);
+        }
+
+        at = after;
+        always = true;
+      }
+
+      var siblingHeight = at.path.length - voidPath.length;
+      height = siblingHeight + 1;
+      always = true;
+    }
+
+    var afterRef = Editor.pointRef(editor, at);
+    var depth = at.path.length - height;
+
+    var _highest = _slicedToArray(highest, 2),
+        highestPath = _highest[1];
+
+    var lowestPath = at.path.slice(0, depth);
+    var position = height === 0 ? at.offset : at.path[depth] + nudge;
+    var target = null;
+
+    var _iterator = _createForOfIteratorHelper(Editor.levels(editor, {
+      at: lowestPath,
+      reverse: true,
+      voids: voids
+    })),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 2),
+            node = _step$value[0],
+            path = _step$value[1];
+
+        var split = false;
+
+        if (path.length < highestPath.length || path.length === 0 || !voids && Element.isElement(node) && editor.isVoid(node)) {
+          break;
+        }
+
+        var _point = beforeRef.current;
+        var isEnd = Editor.isEnd(editor, _point, path);
+
+        if (always || !beforeRef || !Editor.isEdge(editor, _point, path)) {
+          split = true;
+
+          var _text = node.text,
+              children = node.children,
+              properties = _objectWithoutProperties(node, ["text", "children"]);
+
+          editor.apply({
+            type: 'split_node',
+            path: path,
+            position: position,
+            target: target,
+            properties: properties
+          });
+        }
+
+        target = position;
+        position = path[path.length - 1] + (split || isEnd ? 1 : 0);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    if (options.at == null) {
+      var point = afterRef.current || Editor.end(editor, []);
+      Editor.select(editor, point);
+    }
+
+    beforeRef.unref();
+    afterRef.unref();
+  });
+},
+    deleteRange = function deleteRange(editor, range) {
+  if (Range.isCollapsed(range)) {
+    return range.anchor;
+  } else {
+    var _Range$edges = Range.edges(range),
+        _Range$edges2 = _slicedToArray(_Range$edges, 2),
+        end = _Range$edges2[1];
+
+    var pointRef = Editor.pointRef(editor, end);
+    Editor.delete(editor, {
+      at: range
+    });
+    return pointRef.unref();
+  }
+};
+
+export default splitNodesAtPoint;

package/dist/editor/custom/unwrap-node-by-type-at-range.js

@@ -0,0 +1,81 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import { Editor, Range } from 'slate'; // modified on the basic of slate function Editor.unwrapNodes
+// todo: split the unwrap by type the node which nearest to the selection
+
+var unwrapNodesByTypeAtRange = function unwrapNodesByTypeAtRange(editor) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  Editor.withoutNormalizing(editor, function () {
+    var _options$split = options.split,
+        split = _options$split === void 0 ? false : _options$split,
+        _options$voids = options.voids,
+        voids = _options$voids === void 0 ? false : _options$voids,
+        _options$mode = options.mode,
+        mode = _options$mode === void 0 ? 'all' : _options$mode,
+        _options$at = options.at,
+        at = _options$at === void 0 ? editor.selection : _options$at;
+    var match = options.match;
+
+    if (!at) {
+      return;
+    }
+
+    var matches = Editor.nodes(editor, {
+      at: at,
+      match: match,
+      mode: mode,
+      voids: voids
+    });
+    var node;
+
+    var _iterator = _createForOfIteratorHelper(matches),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        match = _step.value;
+        node = match;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    var pathRefs = Array.from([node], function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          p = _ref2[1];
+
+      return Editor.pathRef(editor, p);
+    });
+
+    var _loop = function _loop() {
+      var pathRef = _pathRefs[_i];
+      var path = pathRef.unref();
+
+      var _Editor$node = Editor.node(editor, path),
+          _Editor$node2 = _slicedToArray(_Editor$node, 1),
+          node = _Editor$node2[0];
+
+      var range = Editor.range(editor, path);
+
+      if (split && Range.isRange(range)) {
+        range = Range.intersection(at, range);
+      }
+
+      Editor.liftNodes(editor, {
+        at: range,
+        match: function match(n) {
+          return node.children.includes(n);
+        },
+        voids: voids
+      });
+    };
+
+    for (var _i = 0, _pathRefs = pathRefs; _i < _pathRefs.length; _i++) {
+      _loop();
+    }
+  });
+};
+
+export default unwrapNodesByTypeAtRange;

package/dist/editor/editor-component/check-list-item.js

@@ -0,0 +1,64 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import React from 'react';
+import { Editor } from 'slate';
+import { ReactEditor } from '@seafile/slate-react';
+
+var CheckListItem = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(CheckListItem, _React$PureComponent);
+
+  var _super = _createSuper(CheckListItem);
+
+  function CheckListItem() {
+    var _this;
+
+    _classCallCheck(this, CheckListItem);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _this.onChange = function (event) {
+      var editor = _this.props.editor;
+      var checked = event.target.checked;
+      var path = ReactEditor.findPath(editor, _this.props.element);
+      Editor.setNodes(editor, {
+        data: {
+          checked: checked
+        }
+      }, {
+        at: path
+      });
+    };
+
+    return _this;
+  }
+
+  _createClass(CheckListItem, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          attributes = _this$props.attributes,
+          children = _this$props.children,
+          element = _this$props.element;
+      var checked = element.data.checked;
+      return /*#__PURE__*/React.createElement("li", Object.assign({}, attributes, {
+        className: 'task-list-item ' + this.props.className
+      }), /*#__PURE__*/React.createElement("div", {
+        contentEditable: false
+      }, /*#__PURE__*/React.createElement("input", {
+        type: "checkbox",
+        checked: checked,
+        onChange: this.onChange
+      })), children);
+    }
+  }]);
+
+  return CheckListItem;
+}(React.PureComponent);
+
+export default CheckListItem;

package/dist/editor/editor-component/code-block.js

@@ -0,0 +1,150 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import React from 'react';
+import { Editor } from 'slate';
+
+var CodeBlock = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(CodeBlock, _React$PureComponent);
+
+  var _super = _createSuper(CodeBlock);
+
+  function CodeBlock() {
+    var _this;
+
+    _classCallCheck(this, CodeBlock);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _this.onChange = function (event) {
+      var editor = _this.props.editor;
+      var language = event.target.value;
+      Editor.setNodes(editor, {
+        data: {
+          syntax: language
+        }
+      }, {
+        match: {
+          type: 'code_block'
+        }
+      });
+    };
+
+    return _this;
+  }
+
+  _createClass(CodeBlock, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+          attributes = _this$props.attributes,
+          children = _this$props.children,
+          node = _this$props.node,
+          isSelected = _this$props.isSelected,
+          readOnly = _this$props.readOnly;
+      var language = node.data.syntax;
+      return /*#__PURE__*/React.createElement("div", {
+        className: 'code-container'
+      }, /*#__PURE__*/React.createElement("pre", Object.assign({
+        className: 'code'
+      }, attributes), /*#__PURE__*/React.createElement("code", null, children)), isSelected ? /*#__PURE__*/React.createElement(LanguageSet, {
+        disabled: readOnly,
+        language: language,
+        onChange: this.onChange
+      }) : null);
+    }
+  }]);
+
+  return CodeBlock;
+}(React.PureComponent);
+
+var LanguageSet = /*#__PURE__*/function (_React$PureComponent2) {
+  _inherits(LanguageSet, _React$PureComponent2);
+
+  var _super2 = _createSuper(LanguageSet);
+
+  function LanguageSet() {
+    var _this2;
+
+    _classCallCheck(this, LanguageSet);
+
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    _this2 = _super2.call.apply(_super2, [this].concat(args));
+
+    _this2.stopPropagation = function (event) {
+      event.stopPropagation();
+    };
+
+    return _this2;
+  }
+
+  _createClass(LanguageSet, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      // Compat chrome browser in windows, stop propagation to prevent emit the click event added to document
+      this.selector.addEventListener('click', this.stopPropagation);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.selector.removeEventListener('click', this.stopPropagation);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this3 = this;
+
+      return /*#__PURE__*/React.createElement("div", {
+        contentEditable: false,
+        className: "language-type"
+      }, /*#__PURE__*/React.createElement("select", {
+        ref: function ref(_ref) {
+          return _this3.selector = _ref;
+        },
+        value: this.props.language,
+        disabled: this.props.disabled,
+        name: "language",
+        onInput: function onInput(event) {
+          return event.stopPropagation();
+        },
+        onChange: this.props.onChange
+      }, /*#__PURE__*/React.createElement("option", {
+        value: "none"
+      }, "Text"), /*#__PURE__*/React.createElement("option", {
+        value: "html"
+      }, "HTML"), /*#__PURE__*/React.createElement("option", {
+        value: "css"
+      }, "CSS"), /*#__PURE__*/React.createElement("option", {
+        value: "javascript"
+      }, "Javascript"), /*#__PURE__*/React.createElement("option", {
+        value: "c"
+      }, "C"), /*#__PURE__*/React.createElement("option", {
+        value: "cpp"
+      }, "C++"), /*#__PURE__*/React.createElement("option", {
+        value: "csharp"
+      }, "C#"), /*#__PURE__*/React.createElement("option", {
+        value: "java"
+      }, "Java"), /*#__PURE__*/React.createElement("option", {
+        value: "python"
+      }, "Python"), /*#__PURE__*/React.createElement("option", {
+        value: "sql"
+      }, "Sql"), /*#__PURE__*/React.createElement("option", {
+        value: "swift"
+      }, "Swift"), /*#__PURE__*/React.createElement("option", {
+        value: "json"
+      }, "JSON")));
+    }
+  }]);
+
+  return LanguageSet;
+}(React.PureComponent);
+
+export default CodeBlock;

package/dist/editor/editor-component/formula.js

@@ -0,0 +1,79 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import React from 'react';
+import '../../css/richeditor/formula.css';
+
+var Formula = /*#__PURE__*/function (_React$Component) {
+  _inherits(Formula, _React$Component);
+
+  var _super = _createSuper(Formula);
+
+  function Formula() {
+    var _this;
+
+    _classCallCheck(this, Formula);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _this.toggleFormulaEditor = function () {
+      window.richMarkdownEditor.onToggleFormulaDialog();
+    };
+
+    _this.renderFormula = function () {
+      var node = _this.props.node;
+      _this.formulaContainer.innerHTML = '';
+      var formula = node.data.formula;
+      var dom = window.MathJax.tex2svg(formula);
+
+      _this.formulaContainer.appendChild(dom);
+    };
+
+    return _this;
+  }
+
+  _createClass(Formula, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var node = this.props.node;
+      if (!node.data.formula) return;
+      this.renderFormula();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(preProps) {
+      if (preProps.node.data.formula === this.props.node.data.formula) return;
+      this.renderFormula();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      var _this$props = this.props,
+          attributes = _this$props.attributes,
+          children = _this$props.children,
+          isSelected = _this$props.isSelected;
+      return /*#__PURE__*/React.createElement("span", Object.assign({
+        onDoubleClick: this.toggleFormulaEditor,
+        className: 'block-formula ' + (isSelected ? ' selected-formula' : '')
+      }, attributes), /*#__PURE__*/React.createElement("span", {
+        contentEditable: false,
+        ref: function ref(_ref) {
+          return _this2.formulaContainer = _ref;
+        }
+      }), /*#__PURE__*/React.createElement("span", {
+        contentEditable: false
+      }, children));
+    }
+  }]);
+
+  return Formula;
+}(React.Component);
+
+export default Formula;