@seafile/sdoc-editor 0.1.2 → 0.1.4

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);
+  };
+}();

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

@@ -0,0 +1,14 @@
+import { LINK } from '../../constants';
+import LinkMenu from './menu';
+import Link from './model';
+import withLink from './plugin';
+import renderLink from './render-elem';
+var LinkPlugin = {
+  type: LINK,
+  nodeType: 'element',
+  model: Link,
+  editorMenus: [LinkMenu],
+  editorPlugin: withLink,
+  renderElements: [renderLink]
+};
+export default LinkPlugin;

package/dist/extension/plugins/link/menu/add-link-dialog.js

@@ -0,0 +1,146 @@
+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, { Fragment } from 'react';
+import { Button, Modal, ModalHeader, ModalBody, ModalFooter, Alert } from 'reactstrap';
+import { withTranslation } from 'react-i18next';
+import { insertLink, updateLink, checkLink } from '../helpers';
+var AddLinkDialog = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(AddLinkDialog, _React$PureComponent);
+  var _super = _createSuper(AddLinkDialog);
+  function AddLinkDialog(props) {
+    var _this;
+    _classCallCheck(this, AddLinkDialog);
+    _this = _super.call(this, props);
+    _this.handleUrlChange = function (event) {
+      _this.setState({
+        url: event.target.value.trim()
+      });
+    };
+    _this.handleTitleChange = function (event) {
+      _this.setState({
+        title: event.target.value.trim()
+      });
+    };
+    _this.handleSubmit = function (event) {
+      event.preventDefault();
+      _this.setState({
+        linkErrorMessage: '',
+        titleErrorMessage: ''
+      });
+      var t = _this.props.t;
+      var _this$state = _this.state,
+        _this$state$title = _this$state.title,
+        title = _this$state$title === void 0 ? '' : _this$state$title,
+        _this$state$url = _this$state.url,
+        url = _this$state$url === void 0 ? '' : _this$state$url;
+      if (url.length === 0) {
+        _this.setState({
+          linkErrorMessage: t('The_link_address_is_required')
+        });
+        return;
+      }
+      if (title.length === 0) {
+        _this.setState({
+          titleErrorMessage: t('The_link_title_is_required')
+        });
+        return;
+      }
+      if (checkLink(url)) {
+        _this.setState({
+          linkErrorMessage: t('The_link_address_is_invalid')
+        });
+        return;
+      }
+      var _this$props = _this.props,
+        editor = _this$props.editor,
+        propsUrl = _this$props.url,
+        propsTitle = _this$props.title;
+      var isEdit = propsUrl && propsTitle;
+      if (isEdit) {
+        updateLink(editor, title, url);
+      } else {
+        insertLink(editor, title, url);
+      }
+      _this.props.onLinkDialogToggle();
+    };
+    _this.onKeyDown = function (e) {
+      if (e.keyCode === 13) {
+        _this.handleSubmit(e);
+      }
+    };
+    _this.state = {
+      url: props.url,
+      title: props.title,
+      linkErrorMessage: '',
+      titleErrorMessage: ''
+    };
+    return _this;
+  }
+  _createClass(AddLinkDialog, [{
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+        className = _this$props2.className,
+        t = _this$props2.t;
+      var _this$state2 = this.state,
+        _this$state2$url = _this$state2.url,
+        url = _this$state2$url === void 0 ? '' : _this$state2$url,
+        _this$state2$title = _this$state2.title,
+        title = _this$state2$title === void 0 ? '' : _this$state2$title,
+        linkErrorMessage = _this$state2.linkErrorMessage,
+        titleErrorMessage = _this$state2.titleErrorMessage;
+      return /*#__PURE__*/React.createElement(Modal, {
+        isOpen: true,
+        autoFocus: false,
+        toggle: this.props.onLinkDialogToggle,
+        className: className,
+        zIndex: 1071,
+        returnFocusAfterClose: false
+      }, /*#__PURE__*/React.createElement(ModalHeader, {
+        toggle: this.props.onLinkDialogToggle
+      }, t('insert_link')), /*#__PURE__*/React.createElement(ModalBody, null, /*#__PURE__*/React.createElement(Fragment, null, /*#__PURE__*/React.createElement("div", {
+        className: "form-group"
+      }, /*#__PURE__*/React.createElement("label", {
+        className: "form-check-label",
+        htmlFor: "addLink"
+      }, t('link_address')), /*#__PURE__*/React.createElement("input", {
+        onKeyDown: this.onKeyDown,
+        autoFocus: true,
+        type: "url",
+        className: "form-control",
+        id: "addLink",
+        value: url,
+        onChange: this.handleUrlChange
+      }), linkErrorMessage && /*#__PURE__*/React.createElement(Alert, {
+        color: "danger",
+        className: "mt-2"
+      }, t(linkErrorMessage))), /*#__PURE__*/React.createElement("div", {
+        className: "form-group"
+      }, /*#__PURE__*/React.createElement("label", {
+        className: "form-check-label",
+        htmlFor: "addTitle"
+      }, t('link_title')), /*#__PURE__*/React.createElement("input", {
+        onKeyDown: this.onKeyDown,
+        type: "text",
+        className: "form-control",
+        id: "addTitle",
+        value: title,
+        onChange: this.handleTitleChange
+      }), titleErrorMessage && /*#__PURE__*/React.createElement(Alert, {
+        color: "danger",
+        className: "mt-2"
+      }, t(titleErrorMessage))))), /*#__PURE__*/React.createElement(ModalFooter, null, /*#__PURE__*/React.createElement(Button, {
+        color: "secondary",
+        onClick: this.props.onLinkDialogToggle
+      }, t('cancel')), /*#__PURE__*/React.createElement(Button, {
+        color: "primary",
+        disabled: false,
+        onClick: this.handleSubmit
+      }, t('add_link'))));
+    }
+  }]);
+  return AddLinkDialog;
+}(React.PureComponent);
+export default withTranslation('seafile-editor')(AddLinkDialog);

package/dist/extension/plugins/link/menu/hover-link-dialog.js

@@ -0,0 +1,49 @@
+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 { createPortal } from 'react-dom';
+import '../../../../assets/css/textlink-hovermenu.css';
+var LinkHoverComponent = /*#__PURE__*/function (_React$Component) {
+  _inherits(LinkHoverComponent, _React$Component);
+  var _super = _createSuper(LinkHoverComponent);
+  function LinkHoverComponent() {
+    _classCallCheck(this, LinkHoverComponent);
+    return _super.apply(this, arguments);
+  }
+  _createClass(LinkHoverComponent, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        menuPosition = _this$props.menuPosition,
+        href = _this$props.href;
+      return /*#__PURE__*/React.createElement(React.Fragment, null, createPortal( /*#__PURE__*/React.createElement("div", {
+        id: "loading",
+        className: "seafile-ed-hovermenu",
+        style: menuPosition
+      }, /*#__PURE__*/React.createElement("a", {
+        href: href,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        className: "seafile-ed-hovermenu-link"
+      }, href), /*#__PURE__*/React.createElement("button", {
+        color: "",
+        className: "seafile-ed-hovermenu-btn",
+        onClick: this.props.onDeleteLink
+      }, /*#__PURE__*/React.createElement("i", {
+        className: "iconfont icon-delete"
+      })), /*#__PURE__*/React.createElement("button", {
+        color: "",
+        className: "seafile-ed-hovermenu-btn",
+        onClick: this.props.onEditLink
+      }, /*#__PURE__*/React.createElement("i", {
+        className: "iconfont icon-edit"
+      })), /*#__PURE__*/React.createElement("span", {
+        className: "seafile-ed-hovermenu-triangle"
+      })), document.body));
+    }
+  }]);
+  return LinkHoverComponent;
+}(React.Component);
+export default LinkHoverComponent;

package/dist/extension/plugins/link/menu/index.js

@@ -0,0 +1,67 @@
+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 { LINK, MENUS_CONFIG_MAP } from '../../../constants';
+import { getEditorString } from '../../../core';
+import { MenuItem } from '../../../menu';
+import { getLinkType, isMenuDisabled } from '../helpers';
+import AddLinkDialog from './add-link-dialog';
+var LinkMenu = /*#__PURE__*/function (_React$Component) {
+  _inherits(LinkMenu, _React$Component);
+  var _super = _createSuper(LinkMenu);
+  function LinkMenu(props) {
+    var _this;
+    _classCallCheck(this, LinkMenu);
+    _this = _super.call(this, props);
+    _this.isActive = function () {
+      var editor = _this.props.editor;
+      return getLinkType(editor) === LINK;
+    };
+    _this.isDisabled = function () {
+      var editor = _this.props.editor;
+      return isMenuDisabled(editor);
+    };
+    _this.onLinkDialogToggle = function () {
+      _this.setState({
+        isShowLinkDialog: !_this.state.isShowLinkDialog
+      });
+    };
+    _this.onMouseDown = function () {
+      _this.onLinkDialogToggle();
+    };
+    _this.state = {
+      isShowLinkDialog: false
+    };
+    return _this;
+  }
+  _createClass(LinkMenu, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        isRichEditor = _this$props.isRichEditor,
+        className = _this$props.className,
+        editor = _this$props.editor;
+      var isShowLinkDialog = this.state.isShowLinkDialog;
+      var menuConfig = MENUS_CONFIG_MAP[LINK];
+      var props = _objectSpread(_objectSpread({
+        isRichEditor: isRichEditor,
+        className: className
+      }, menuConfig), {}, {
+        disabled: this.isDisabled(),
+        isActive: this.isActive(),
+        onMouseDown: this.onMouseDown
+      });
+      var selectedText = getEditorString(editor, editor.selection);
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(MenuItem, props), isShowLinkDialog && /*#__PURE__*/React.createElement(AddLinkDialog, {
+        editor: editor,
+        title: selectedText,
+        onLinkDialogToggle: this.onLinkDialogToggle
+      }));
+    }
+  }]);
+  return LinkMenu;
+}(React.Component);
+export default LinkMenu;

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

@@ -0,0 +1,13 @@
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import { LINK as LINKTRENAME } from '../../constants';
+var Link = /*#__PURE__*/_createClass(function Link(options) {
+  _classCallCheck(this, Link);
+  this.type = options.type || LINKTRENAME;
+  this.children = options.children || [{
+    text: ''
+  }];
+  this.href = options.href || '';
+  this.title = options.title || '';
+});
+export default Link;

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

@@ -0,0 +1,60 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { Editor, Transforms, Node } from '@seafile/slate';
+import isUrl from 'is-url';
+import { isMenuDisabled, insertLink } from './helpers';
+import { getNodeType } from '../../core';
+var withLink = function withLink(editor) {
+  var normalizeNode = editor.normalizeNode,
+    isInline = editor.isInline,
+    insertData = editor.insertData;
+  var newEditor = editor;
+
+  // Rewrite isInline
+  newEditor.isInline = function (elem) {
+    var type = elem.type;
+    if (type === 'link') {
+      return true;
+    }
+    return isInline(elem);
+  };
+
+  // Rewrite insertData, Paste insert link
+  newEditor.insertData = function (data) {
+    var text = data.getData('text/plain');
+    if (!isUrl(text)) {
+      // unlinked
+      insertData(data);
+      return;
+    }
+
+    // Insert link
+    if (isMenuDisabled(newEditor)) return; // disabled
+    var selection = newEditor.selection;
+    if (selection == null) return;
+    var selectedText = Editor.string(newEditor, selection); // Gets the selected text
+    insertLink(newEditor, selectedText, text);
+  };
+
+  // Rewrite normalizeNode
+  newEditor.normalizeNode = function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      node = _ref2[0],
+      path = _ref2[1];
+    var type = getNodeType(node);
+    if (type !== 'link') {
+      // If the type is not link, perform default normalizeNode
+      return normalizeNode([node, path]);
+    }
+
+    // If the link is empty, delete it
+    var str = Node.string(node);
+    if (str === '') {
+      return Transforms.removeNodes(newEditor, {
+        at: path
+      });
+    }
+    return normalizeNode([node, path]);
+  };
+  return newEditor;
+};
+export default withLink;

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

@@ -0,0 +1,114 @@
+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 { unWrapLinkNode } from './helpers';
+import AddLinkDialog from './menu/add-link-dialog';
+import LinkHoverComponent from './menu/hover-link-dialog';
+var LinkHoverMenuComponent = /*#__PURE__*/function (_React$Component) {
+  _inherits(LinkHoverMenuComponent, _React$Component);
+  var _super = _createSuper(LinkHoverMenuComponent);
+  function LinkHoverMenuComponent(props) {
+    var _this;
+    _classCallCheck(this, LinkHoverMenuComponent);
+    _this = _super.call(this, props);
+    _this.registerEventHandle = function () {
+      document.addEventListener('click', _this.onHideLinkMenu);
+    };
+    _this.unregisterEventHandle = function () {
+      document.removeEventListener('click', _this.onHideLinkMenu);
+    };
+    _this.onHideLinkMenu = function () {
+      _this.setState({
+        isShowLinkMenu: false
+      }, function () {
+        _this.unregisterEventHandle();
+      });
+    };
+    _this.onLinkClick = function (e) {
+      var _e$target$getBounding = e.target.getBoundingClientRect(),
+        top = _e$target$getBounding.top,
+        left = _e$target$getBounding.left,
+        width = _e$target$getBounding.width;
+      // top = top distance - menu height
+      var menuTop = top - 50;
+      // left = left distance - (menu width / 2) + (link with / 2)
+      var menuLeft = left - 250 / 2 + width / 2;
+      _this.setState({
+        isShowLinkMenu: true,
+        menuPosition: {
+          top: menuTop,
+          left: menuLeft
+        }
+      }, function () {
+        _this.registerEventHandle();
+      });
+    };
+    _this.onLinkDialogToggle = function () {
+      _this.setState({
+        isShowLinkDialog: !_this.state.isShowLinkDialog
+      });
+    };
+    _this.onEditToggle = function () {
+      _this.setState({
+        isShowLinkDialog: true
+      });
+    };
+    _this.deleteLink = function () {
+      var editor = _this.props.editor;
+      unWrapLinkNode(editor);
+    };
+    _this.state = {
+      isShowLinkMenu: false,
+      isShowLinkDialog: false
+    };
+    return _this;
+  }
+  _createClass(LinkHoverMenuComponent, [{
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.unregisterEventHandle();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        attributes = _this$props.attributes,
+        children = _this$props.children,
+        element = _this$props.element,
+        editor = _this$props.editor;
+      var _this$state = this.state,
+        isShowLinkDialog = _this$state.isShowLinkDialog,
+        isShowLinkMenu = _this$state.isShowLinkMenu,
+        menuPosition = _this$state.menuPosition;
+      var className = isShowLinkMenu ? 'seafile-ed-hovermenu-mouseclick' : null;
+      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("span", Object.assign({
+        className: className
+      }, attributes, {
+        onClick: this.onLinkClick
+      }), /*#__PURE__*/React.createElement("a", {
+        href: element.href,
+        title: element.title
+      }, children)), isShowLinkDialog && /*#__PURE__*/React.createElement(AddLinkDialog, {
+        editor: editor,
+        url: element.href,
+        title: element.title,
+        onLinkDialogToggle: this.onLinkDialogToggle
+      }), isShowLinkMenu && /*#__PURE__*/React.createElement(LinkHoverComponent, {
+        menuPosition: menuPosition,
+        editor: editor,
+        href: element.href,
+        onEditLink: this.onEditToggle,
+        onDeleteLink: this.deleteLink
+      }));
+    }
+  }]);
+  return LinkHoverMenuComponent;
+}(React.Component);
+var renderLink = function renderLink(props, editor) {
+  return /*#__PURE__*/React.createElement(LinkHoverMenuComponent, Object.assign({}, props, {
+    editor: editor
+  }));
+};
+export default renderLink;

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

@@ -1,6 +1,6 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import { Editor, Element } from 'slate';
+import { Editor, Element } from '@seafile/slate';
 import { PARAGRAPH } from '../../constants';
 import { getSelectedNodeByType } from '../../core';
 import { toggleList } from './transforms';

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

@@ -6,7 +6,7 @@ import _createSuper from "@babel/runtime/helpers/esm/createSuper";
 import React from 'react';
 import { MENUS_CONFIG_MAP, ORDERED_LIST, UNORDERED_LIST } from '../../../constants';
 import { focusEditor } from '../../../core';
-import { MenuItem } from '../../../menu/';
+import { MenuItem } from '../../../menu';
 import { getListType, isMenuDisabled, setListType } from '../helpers';
 var ListMenu = /*#__PURE__*/function (_React$Component) {
   _inherits(ListMenu, _React$Component);

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

@@ -1,5 +1,5 @@
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import { Node, Element, Transforms, Path } from 'slate';
+import { Node, Element, Transforms, Path } from '@seafile/slate';
 import { LIST_ITEM, LIST_LIC, PARAGRAPH } from '../../../constants';
 import { getChildren, getNode, getPreviousPath, match } from '../../../core';
 import { getListTypes } from '../queries';