@seafile/sdoc-editor 0.1.2 → 0.1.3

package/dist/assets/css/textlink-hovermenu.css

@@ -0,0 +1,51 @@
+.seafile-ed-hovermenu {
+  width: 250px;
+  height: 40px;
+  display: flex;
+  position: absolute;
+  background-color: #fff;
+  border: 1px solid rgba(0, 40, 100, 0.12);
+  box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+  z-index: 1000;
+}
+
+.seafile-ed-hovermenu .seafile-ed-hovermenu-triangle {
+  width: 8px;
+  height: 8px;
+  transform: rotate(45deg);
+  background: #fff;
+  border-right: 1px solid rgba(0, 40, 100, 0.12);
+  border-bottom: 1px solid rgba(0, 40, 100, 0.12);
+  position: absolute;
+  top: 34px;
+  right: 50%;
+  z-index: 1001;
+}
+
+.seafile-ed-hovermenu .seafile-ed-hovermenu-link {
+  height: 38px;
+  max-width: 170px;
+  padding: 6px 12px;
+  display: inline-block;
+  line-height: 28px;
+  overflow: hidden;
+  cursor: pointer;
+}
+
+.seafile-ed-hovermenu .seafile-ed-hovermenu-btn {
+  background-color: #fff;
+  width: 35px;
+  font-weight: normal;
+  color: #999999;
+  line-height: 26px;
+  font-size: 16px;
+}
+
+.seafile-ed-hovermenu .seafile-ed-hovermenu-btn, .seafile-ed-hovermenu .seafile-ed-hovermenu-btn:focus {
+  border: 0;
+  box-shadow: 0;
+}
+
+.seafile-ed-hovermenu-mouseclick {
+  background-color: #ddd;
+}

package/dist/editor.js

@@ -1,13 +1,13 @@
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 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 { Editable, Slate } from 'slate-react';
+import { Editable, Slate } from '@seafile/slate-react';
 import isHotkey from 'is-hotkey';
-import editor, { renderLeaf as _renderLeaf, renderElement as _renderElement, Toolbar } from './slate-extension';
-import SocketManager from './slate-extension/socket/socket-manager';
+import editor, { renderLeaf as _renderLeaf, renderElement as _renderElement, Toolbar } from './extension';
+import { SocketManager, withSocketIO } from './socket';
+import withNodeId from './node-id';
 import './assets/css/sdoc-editor.css';
 var SDocEditor = /*#__PURE__*/function (_React$Component) {
   _inherits(SDocEditor, _React$Component);
@@ -16,12 +16,6 @@ var SDocEditor = /*#__PURE__*/function (_React$Component) {
     var _this;
     _classCallCheck(this, SDocEditor);
     _this = _super.call(this, props);
-    _this.updateWithRemoteOperation = function (params) {
-      var operation = params.operation;
-      _this.editor.apply(_objectSpread(_objectSpread({}, operation), {}, {
-        is_remote: true
-      }));
-    };
     _this.onChange = function (slateValue) {
       var onValueChanged = _this.props.onValueChanged;
       _this.setState({
@@ -34,8 +28,12 @@ var SDocEditor = /*#__PURE__*/function (_React$Component) {
       slateValue: children,
       isLoading: true
     };
-    _this.editor = editor;
     _this.socketManager = null;
+    if (!props.isOpenSocket) {
+      _this.editor = withNodeId(editor);
+    } else {
+      _this.editor = withSocketIO(withNodeId(editor));
+    }
     return _this;
   }
   _createClass(SDocEditor, [{
@@ -46,21 +44,16 @@ var SDocEditor = /*#__PURE__*/function (_React$Component) {
         document = _this$props.document,
         config = _this$props.config;
       if (isOpenSocket) {
-        this.socketManager = SocketManager.getInstance(document, config);
-        var eventBus = this.socketManager.eventBus;
-        this.unsubscribeReceiveOption = eventBus.subscribe('receive-operation', this.updateWithRemoteOperation);
+        this.socketManager = SocketManager.getInstance(this.editor, document, config);
       }
     }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      this.unsubscribeReceiveOption();
-    }
   }, {
     key: "render",
     value: function render() {
       var _this2 = this;
-      var slateValue = this.state.slateValue;
+      var _this$state = this.state,
+        slateValue = _this$state.slateValue,
+        isEditorBlur = _this$state.isEditorBlur;
       return /*#__PURE__*/React.createElement("div", {
         className: "sf-editor-container"
       }, /*#__PURE__*/React.createElement(Toolbar, {

package/dist/{slate-extension → extension}/constants/index.js

@@ -45,5 +45,9 @@ export var MENUS_CONFIG_MAP = (_MENUS_CONFIG_MAP = {}, _defineProperty(_MENUS_CO
   id: CHECK_LIST,
   iconClass: 'iconfont icon-check-square',
   text: 'check_list_item'
+}), _defineProperty(_MENUS_CONFIG_MAP, LINK, {
+  id: LINK,
+  iconClass: 'iconfont icon-link',
+  text: 'link'
 }), _MENUS_CONFIG_MAP);
 export var HEADER_TITLE_MAP = (_HEADER_TITLE_MAP = {}, _defineProperty(_HEADER_TITLE_MAP, HEADER1, 'header_1'), _defineProperty(_HEADER_TITLE_MAP, HEADER2, 'header_2'), _defineProperty(_HEADER_TITLE_MAP, HEADER3, 'header_3'), _defineProperty(_HEADER_TITLE_MAP, HEADER4, 'header_4'), _defineProperty(_HEADER_TITLE_MAP, HEADER5, 'header_5'), _defineProperty(_HEADER_TITLE_MAP, HEADER6, 'header_6'), _defineProperty(_HEADER_TITLE_MAP, PARAGRAPH, 'pargraph'), _HEADER_TITLE_MAP);

package/dist/{slate-extension → extension}/core/queries/index.js

@@ -4,7 +4,7 @@ import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIt
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 var _excluded = ["at"];
-import { Editor, Text, Path, Span, Element, Node, Range } from 'slate';
+import { Editor, Text, Path, Span, Element, Node, Range } from '@seafile/slate';
 import { match } from '../utils';
 
 // options
@@ -62,6 +62,14 @@ export var getSelectedNodeEntryByType = function getSelectedNodeEntryByType(edit
 export var getNodeEntries = function getNodeEntries(editor, options) {
   return Editor.nodes(editor, getQueryOptions(editor, options));
 };
+export var getEditorString = function getEditorString(editor, at, options) {
+  if (!at) return '';
+  try {
+    return Editor.string(editor, at, options);
+  } catch (error) {
+    return '';
+  }
+};
 
 // children & child
 export var getChildren = function getChildren(nodeEntry) {
@@ -124,6 +132,27 @@ export var isLastChild = function isLastChild(nodeEntry, childPath) {
   var lastChildPath = getLastChildPath(nodeEntry);
   return Path.equals(lastChildPath, childPath);
 };
+export var getSelectedElems = function getSelectedElems(editor) {
+  var elems = [];
+  var nodeEntries = Editor.nodes(editor, {
+    universal: true
+  });
+  var _iterator2 = _createForOfIteratorHelper(nodeEntries),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var nodeEntry = _step2.value;
+      var _nodeEntry3 = _slicedToArray(nodeEntry, 1),
+        node = _nodeEntry3[0];
+      if (Element.isElement(node)) elems.push(node);
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return elems;
+};
 
 // siblings
 export var getNextSiblingNodes = function getNextSiblingNodes(ancestorEntry, path) {
@@ -197,21 +226,21 @@ export var findDescendant = function findDescendant(editor, options) {
       return voids ? false : Editor.isVoid(editor, n);
     }
   });
-  var _iterator2 = _createForOfIteratorHelper(nodeEntries),
-    _step2;
+  var _iterator3 = _createForOfIteratorHelper(nodeEntries),
+    _step3;
   try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var _step2$value = _slicedToArray(_step2.value, 2),
-        node = _step2$value[0],
-        path = _step2$value[1];
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _step3$value = _slicedToArray(_step3.value, 2),
+        node = _step3$value[0],
+        path = _step3$value[1];
       if (match(node, path, _match)) {
         return [node, at.concat(path)];
       }
     }
   } catch (err) {
-    _iterator2.e(err);
+    _iterator3.e(err);
   } finally {
-    _iterator2.f();
+    _iterator3.f();
   }
   return undefined;
 };
@@ -238,19 +267,19 @@ export var isBlockTextEmptyAfterSelection = function isBlockTextEmptyAfterSelect
   var siblingNodes = getNextSiblingNodes(blockAbove, cursor.path);
   if (siblingNodes.length) {
     // 子节点包含 文本节点
-    var _iterator3 = _createForOfIteratorHelper(siblingNodes),
-      _step3;
+    var _iterator4 = _createForOfIteratorHelper(siblingNodes),
+      _step4;
     try {
-      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-        var siblingNode = _step3.value;
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var siblingNode = _step4.value;
         if (Text.isText(siblingNode) && siblingNode.text) {
           return false;
         }
       }
     } catch (err) {
-      _iterator3.e(err);
+      _iterator4.e(err);
     } finally {
-      _iterator3.f();
+      _iterator4.f();
     }
   } else {
     return isEndPoint(editor, cursor, blockAbove[1]);

package/dist/{slate-extension → extension}/core/transforms/focus-editor.js

@@ -1,5 +1,5 @@
-import { Editor, Transforms } from 'slate';
-import { ReactEditor } from 'slate-react';
+import { Editor, Transforms } from '@seafile/slate';
+import { ReactEditor } from '@seafile/slate-react';
 export var focusEditor = function focusEditor(editor, target) {
   if (target) {
     Editor.withoutNormalizing(editor, function () {

package/dist/extension/core/transforms/index.js

@@ -0,0 +1,3 @@
+export * from './move-children';
+export * from './remove-node-children';
+export * from './focus-editor';

package/dist/{slate-extension → extension}/core/transforms/move-children.js

@@ -1,5 +1,5 @@
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import { Editor, Path, Transforms } from 'slate';
+import { Editor, Path, Transforms } from '@seafile/slate';
 import { getNode } from '../queries';
 export var moveChildren = function moveChildren(editor, _ref) {
   var at = _ref.at,

package/dist/extension/core/transforms/remove-node-children.js

@@ -0,0 +1,24 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import { Transforms, Node } from '@seafile/slate';
+export var removeNodeChildren = function removeNodeChildren(editor, path, options) {
+  var nodeChildren = Node.children(editor, path, {
+    reverse: true
+  });
+  var _iterator = _createForOfIteratorHelper(nodeChildren),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+        childPath = _step$value[1];
+      Transforms.removeNodes(editor, _objectSpread(_objectSpread({}, options), {}, {
+        at: childPath
+      }));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+};

package/dist/{slate-extension → extension}/core/utils/index.js

@@ -1,4 +1,5 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import slugid from 'slugid';
 export var match = function match(node, path, predicate) {
   if (!predicate) return true;
   if (typeof predicate === 'object') {
@@ -14,4 +15,13 @@ export var match = function match(node, path, predicate) {
     });
   }
   return predicate(node, path);
+};
+export var generateEmptyElement = function generateEmptyElement(type) {
+  return {
+    type: type,
+    children: [{
+      id: slugid.nice(),
+      text: ''
+    }]
+  };
 };

package/dist/{slate-extension → extension}/index.js

@@ -1,5 +1,5 @@
-import { createEditor } from 'slate';
-import { withReact } from 'slate-react';
+import { createEditor } from '@seafile/slate';
+import { withReact } from '@seafile/slate-react';
 import Plugins from './plugins';
 import renderElement from './render/render-element';
 import renderLeaf from './render/render-leaf';

package/dist/{slate-extension → extension}/plugins/blockquote/helpers.js

@@ -1,5 +1,5 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import { Editor, Transforms } from 'slate';
+import { Editor, Transforms } from '@seafile/slate';
 import { BLOCKQUOTE } from '../../constants';
 import { getNodeType } from '../../core';
 export var isMenuDisabled = function isMenuDisabled(editor) {

package/dist/{slate-extension → extension}/plugins/blockquote/menu/index.js

@@ -5,7 +5,7 @@ import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React from 'react';
 import { BLOCKQUOTE, MENUS_CONFIG_MAP, PARAGRAPH } from '../../../constants';
-import { MenuItem } from '../../../menu/';
+import { MenuItem } from '../../../menu';
 import { getBlockQuoteType, isMenuDisabled, setBlockQuoteType } from '../helpers';
 var QuoteMenu = /*#__PURE__*/function (_React$Component) {
   _inherits(QuoteMenu, _React$Component);
@@ -29,7 +29,6 @@ var QuoteMenu = /*#__PURE__*/function (_React$Component) {
       var editor = _this.props.editor;
       var active = _this.isActive(editor);
       var newType = active ? PARAGRAPH : BLOCKQUOTE;
-      console.log(newType);
       setBlockQuoteType(editor, newType);
     };
     return _this;

package/dist/{slate-extension → extension}/plugins/blockquote/plugin.js

@@ -1,7 +1,8 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import { Editor, Element, Point, Transforms, Node } from 'slate';
-import { ReactEditor } from 'slate-react';
-import { BLOCKQUOTE } from '../../constants';
+import { Editor, Element, Point, Transforms, Node } from '@seafile/slate';
+import { ReactEditor } from '@seafile/slate-react';
+import { generateEmptyElement } from '../../core';
+import { BLOCKQUOTE, PARAGRAPH } from '../../constants';
 var withBlockquote = function withBlockquote(editor) {
   var insertBreak = editor.insertBreak,
     insertText = editor.insertText;
@@ -29,12 +30,7 @@ var withBlockquote = function withBlockquote(editor) {
         // 第一步：删除最后一个 \n
         editor.deleteBackward('character');
         // 第二步：插入一个 paragraph
-        var p = {
-          type: 'paragraph',
-          children: [{
-            text: ''
-          }]
-        };
+        var p = generateEmptyElement(PARAGRAPH);
         Transforms.insertNodes(newEditor, p, {
           mode: 'highest'
         });

package/dist/extension/plugins/blockquote/render-elem.js

@@ -0,0 +1,10 @@
+import React from 'react';
+var renderBlockquote = function renderBlockquote(props, editor) {
+  var attributes = props.attributes,
+    children = props.children,
+    element = props.element;
+  return /*#__PURE__*/React.createElement("blockquote", Object.assign({
+    "data-id": element.id
+  }, attributes), children);
+};
+export default renderBlockquote;

package/dist/{slate-extension → extension}/plugins/check-list/helpers.js

@@ -1,6 +1,6 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import { Transforms, Editor, Element } from 'slate';
+import { Transforms, Editor, Element } from '@seafile/slate';
 import { CHECK_LIST_ITEM, PARAGRAPH } from '../../constants';
 import { getSelectedNodeByType } from '../../core';
 export var isMenuDisabled = function isMenuDisabled(editor) {

package/dist/{slate-extension → extension}/plugins/check-list/plugin.js

@@ -1,4 +1,4 @@
-import { Node, Range, Transforms } from 'slate';
+import { Node, Range, Transforms } from '@seafile/slate';
 import { CHECK_LIST_ITEM, PARAGRAPH } from '../../constants';
 import { getSelectedNodeByType } from '../../core';
 var withCheckList = function withCheckList(editor) {

package/dist/{slate-extension → extension}/plugins/check-list/render-elem.js

@@ -3,8 +3,8 @@ 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 { Transforms } from 'slate';
-import { ReactEditor } from 'slate-react';
+import { Transforms } from '@seafile/slate';
+import { ReactEditor } from '@seafile/slate-react';
 var renderCheckList = function renderCheckList(props, editor) {
   var attributes = props.attributes,
     children = props.children,
@@ -48,7 +48,9 @@ var CheckListItem = /*#__PURE__*/function (_React$PureComponent) {
       var _ref = node || {},
         _ref$checked = _ref.checked,
         checked = _ref$checked === void 0 ? false : _ref$checked;
-      return /*#__PURE__*/React.createElement("div", Object.assign({}, attributes, {
+      return /*#__PURE__*/React.createElement("div", Object.assign({
+        "data-id": node.id
+      }, attributes, {
         style: style
       }), /*#__PURE__*/React.createElement("span", {
         contentEditable: false,

package/dist/{slate-extension → extension}/plugins/header/helpers.js

@@ -1,5 +1,5 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import { Editor, Transforms } from "slate";
+import { Editor, Transforms } from "@seafile/slate";
 import { getNodeType } from "../../core";
 export var isMenuDisabled = function isMenuDisabled(editor) {
   if (!editor.selection) return true;

package/dist/{slate-extension → extension}/plugins/header/plugin.js

@@ -1,5 +1,7 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import { Editor, Element, Transforms } from 'slate';
+import { Editor, Element, Transforms } from '@seafile/slate';
+import { PARAGRAPH } from '../../constants';
+import { generateEmptyElement } from '../../core';
 var isSelectionAtLineEnd = function isSelectionAtLineEnd(editor, path) {
   var selection = editor.selection;
   if (!selection) return false;
@@ -31,12 +33,7 @@ var withHeader = function withHeader(editor) {
 
     // 如果在行末插入一个空 p，否则正常换行
     if (isAtLineEnd) {
-      var p = {
-        type: 'paragraph',
-        children: [{
-          text: ''
-        }]
-      };
+      var p = generateEmptyElement(PARAGRAPH);
       Transforms.insertNodes(newEditor, p, {
         mode: 'highest'
       });

package/dist/{slate-extension → extension}/plugins/header/render-elem.js

@@ -6,6 +6,8 @@ var renderHeader = function renderHeader(props, editor) {
   var type = element.type;
   var level = type.split('header')[1];
   var Tag = "h".concat(level);
-  return /*#__PURE__*/React.createElement(Tag, attributes, children);
+  return /*#__PURE__*/React.createElement(Tag, Object.assign({
+    "data-id": element.id
+  }, attributes), children);
 };
 export default renderHeader;

package/dist/extension/plugins/index.js

@@ -0,0 +1,9 @@
+import HeaderPlugin from './header';
+import LinkPlugin from './link';
+import BlockquotePlugin from './blockquote';
+import ListPlugin from './list';
+import CheckListPlugin from './check-list';
+import TextPlugin from './text-style';
+var Plugins = [HeaderPlugin, LinkPlugin, BlockquotePlugin, ListPlugin, CheckListPlugin, TextPlugin];
+export default Plugins;
+export { HeaderPlugin, LinkPlugin, BlockquotePlugin, ListPlugin, CheckListPlugin, TextPlugin };

package/dist/extension/plugins/link/helpers.js

@@ -0,0 +1,152 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; }, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) }), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; defineProperty(this, "_invoke", { value: function value(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; } function maybeInvokeDelegate(delegate, context) { var methodName = context.method, method = delegate.iterator[methodName]; if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel; var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), defineProperty(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (val) { var object = Object(val), keys = []; for (var key in object) keys.push(key); return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, catch: function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
+import { Editor, Transforms, Range } from '@seafile/slate';
+import { LINK } from '../../constants';
+import { getNodeType, getSelectedElems, removeNodeChildren, getAboveNode, getEditorString } from '../../core';
+export var isMenuDisabled = function isMenuDisabled(editor) {
+  if (editor.selection == null) return true;
+  var selectedElems = getSelectedElems(editor);
+  var notMatch = selectedElems.some(function (elem) {
+    var type = elem.type;
+    if (editor.isVoid(elem)) return true;
+    if (['pre', 'code', 'link'].includes(type)) return true;
+    return false;
+  });
+  if (notMatch) return true; // disabled
+  return false; // enable
+};
+
+export var checkLink = function checkLink(url) {
+  if (url.indexOf('http') !== 0) {
+    return true;
+  }
+  return false;
+};
+export var genLinkNode = function genLinkNode(url, text) {
+  var linkNode = {
+    type: 'link',
+    href: url,
+    title: text,
+    children: text ? [{
+      text: text
+    }] : []
+  };
+  return linkNode;
+};
+export var getLinkType = function getLinkType(editor) {
+  var _Editor$nodes = Editor.nodes(editor, {
+      match: function match(n) {
+        return getNodeType(n) === LINK;
+      },
+      universal: true
+    }),
+    _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),
+    match = _Editor$nodes2[0];
+  if (!match) return 'paragraph';
+  var _match = _slicedToArray(match, 1),
+    n = _match[0];
+  return getNodeType(n);
+};
+export var insertLink = function insertLink(editor, text, url) {
+  if (isMenuDisabled(editor)) return;
+
+  // Selection folded or not
+  var selection = editor.selection;
+  if (selection == null) return;
+  var isCollapsed = Range.isCollapsed(selection);
+  if (isCollapsed) {
+    // Insert Spaces before and after links for easy operation
+    editor.insertText(' ');
+    var linkNode = genLinkNode(url, text);
+    Transforms.insertNodes(editor, linkNode);
+
+    // Not being able to use insertText directly causes the added Spaces to be added to the linked text, as in the issue above, replaced by insertFragment
+    editor.insertFragment([{
+      text: ' '
+    }]);
+  } else {
+    var selectedText = Editor.string(editor, selection); // Selected text
+    if (selectedText !== text) {
+      // If the selected text is different from the typed text, delete the text and insert the link
+      editor.deleteFragment();
+      var _linkNode = genLinkNode(url, text);
+      Transforms.insertNodes(editor, _linkNode);
+    } else {
+      // If the selected text is the same as the entered text, only the link can be wrapped
+      var _linkNode2 = genLinkNode(url, text);
+      Transforms.wrapNodes(editor, _linkNode2, {
+        split: true
+      });
+      Transforms.collapse(editor, {
+        edge: 'end'
+      });
+    }
+  }
+};
+export var updateLink = function updateLink(editor, newText, newUrl) {
+  // Update children
+  var oldLink = getAboveNode(editor, {
+    match: {
+      type: 'link'
+    }
+  });
+  if (oldLink) {
+    var _oldLink = _slicedToArray(oldLink, 2),
+      oldLinkNode = _oldLink[0],
+      oldLinkPath = _oldLink[1];
+    var oldUrl = oldLinkNode.href;
+    if (newText !== getEditorString(editor, oldLinkPath) || newUrl !== oldUrl) {
+      // Remove link children
+      removeNodeChildren(editor, oldLinkPath, {
+        select: true
+      });
+
+      // insert link node
+      var linkNode = genLinkNode(newUrl, newText);
+      Transforms.insertNodes(editor, linkNode, {
+        select: true
+      });
+    }
+  }
+};
+export var unWrapLinkNode = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(editor) {
+    var _Editor$nodes3, _Editor$nodes4, nodeEntry;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (!(editor.selection == null)) {
+            _context.next = 2;
+            break;
+          }
+          return _context.abrupt("return");
+        case 2:
+          _Editor$nodes3 = Editor.nodes(editor, {
+            match: function match(n) {
+              return getNodeType(n) === 'link';
+            },
+            universal: true
+          }), _Editor$nodes4 = _slicedToArray(_Editor$nodes3, 1), nodeEntry = _Editor$nodes4[0]; // If the selection is not in a link node, it is disabled
+          if (!(nodeEntry == null || nodeEntry[0] == null)) {
+            _context.next = 5;
+            break;
+          }
+          return _context.abrupt("return");
+        case 5:
+          // unlink
+          Transforms.unwrapNodes(editor, {
+            match: function match(n) {
+              return getNodeType(n) === 'link';
+            }
+          });
+        case 6:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function unWrapLinkNode(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();