@seafile/seafile-editor 1.0.0 → 1.0.2

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

@@ -0,0 +1,235 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.upsertLinkText = exports.updateLink = exports.unWrapLinkNode = exports.isMenuDisabled = exports.isLinkType = exports.insertLink = exports.getLinkInfo = exports.generateLinkNode = void 0;
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/regeneratorRuntime"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/asyncToGenerator"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _queries = require("../../core/queries");
+var _focusEditor = require("../../core/transforms/focus-editor");
+var _constants = require("../../constants");
+var _utils = require("../../core/utils");
+var _replaceNodeChildren = require("../../core/transforms/replace-node-children");
+var _ref3;
+var isMenuDisabled = exports.isMenuDisabled = function isMenuDisabled(editor) {
+  var readonly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (readonly) return true;
+  var selection = editor.selection;
+  if (!selection) return false;
+  var selectedElems = (0, _queries.getSelectedElems)(editor);
+  // Check if the selected element is illegal
+  var isSelectedIllegalElement = selectedElems.some(function (elem) {
+    var type = elem.type;
+    if (editor.isVoid(elem)) return true;
+    if ([_constants.ELementTypes.CODE_BLOCK, _constants.ELementTypes.CODE_LINE].includes(type)) return true;
+    return false;
+  });
+  if (isSelectedIllegalElement) return true;
+  return false;
+};
+var isLinkType = exports.isLinkType = function isLinkType(editor) {
+  var _Editor$nodes = _slate.Editor.nodes(editor, {
+      match: function match(n) {
+        return (0, _queries.getNodeType)(n) === _constants.ELementTypes.LINK;
+      },
+      universal: true
+    }),
+    _Editor$nodes2 = (0, _slicedToArray2.default)(_Editor$nodes, 1),
+    match = _Editor$nodes2[0];
+  return !!match;
+};
+var generateLinkNode = exports.generateLinkNode = function generateLinkNode(url, title) {
+  var linkNode = {
+    type: _constants.ELementTypes.LINK,
+    url: url,
+    title: title,
+    id: _slugid.default.nice(),
+    children: [{
+      id: _slugid.default.nice(),
+      text: title || ''
+    }]
+  };
+  return linkNode;
+};
+
+/**
+ * @param {Object} props
+ * @param {Object} props.editor
+ * @param {String} props.url
+ * @param {String} props.title
+ * @param {InsertPosition} props.insertPosition
+ * @param {Object | undefined} props.slateNode
+ */
+var insertLink = exports.insertLink = function insertLink(props) {
+  var editor = props.editor,
+    url = props.url,
+    title = props.title,
+    _props$insertPosition = props.insertPosition,
+    insertPosition = _props$insertPosition === void 0 ? _constants.INSERT_POSITION.CURRENT : _props$insertPosition,
+    slateNode = props.slateNode;
+  var selection = editor.selection;
+  if (insertPosition === _constants.INSERT_POSITION.CURRENT && isMenuDisabled(editor)) return;
+  // We had validated in modal,here we do it again for safety
+  if (!title || !url) return;
+  if (!selection) return;
+  var linkNode = generateLinkNode(url, title);
+  if (insertPosition === _constants.INSERT_POSITION.AFTER) {
+    var path = _slate.Editor.path(editor, selection);
+    if (slateNode && (slateNode === null || slateNode === void 0 ? void 0 : slateNode.type) === _constants.ELementTypes.LIST_ITEM) {
+      path = (0, _queries.findPath)(editor, slateNode, []);
+      var nextPath = _slate.Path.next(path);
+      _slate.Editor.insertNodes(editor, linkNode, {
+        at: nextPath
+      });
+      return;
+    }
+    var linkNodeWrapper = (0, _utils.generateEmptyElement)(_constants.ELementTypes.PARAGRAPH);
+    // LinkNode should be wrapped by p and within text nodes in order to be editable
+    linkNodeWrapper.children.push(linkNode, (0, _utils.generateDefaultText)());
+    _slate.Transforms.insertNodes(editor, linkNodeWrapper, {
+      at: [path[0] + 1]
+    });
+    (0, _focusEditor.focusEditor)(editor);
+    return;
+  }
+  var isCollapsed = _slate.Range.isCollapsed(selection);
+  if (isCollapsed) {
+    // If selection is collapsed, we insert a space and then insert link node that help operation easier
+    editor.insertText(' ');
+    _slate.Editor.insertFragment(editor, [linkNode]);
+    // Using insertText directly causes the added Spaces to be added to the linked text, as in the issue above, so replaced by insertFragment
+    _slate.Editor.insertFragment(editor, [{
+      id: _slugid.default.nice(),
+      text: ' '
+    }]);
+    (0, _focusEditor.focusEditor)(editor);
+    return;
+  } else {
+    var selectedText = _slate.Editor.string(editor, selection); // Selected text
+    if (selectedText !== title) {
+      // Replace the selected text with the link node if the selected text is different from the entered text
+      editor.deleteFragment();
+      _slate.Transforms.insertNodes(editor, linkNode);
+    } else {
+      // Wrap the selected text with the link node if the selected text is the same as the entered text
+      _slate.Transforms.wrapNodes(editor, linkNode, {
+        split: true,
+        at: selection
+      });
+      _slate.Transforms.collapse(editor, {
+        edge: 'end'
+      });
+    }
+  }
+  (0, _focusEditor.focusEditor)(editor);
+};
+var getLinkInfo = exports.getLinkInfo = function getLinkInfo(editor) {
+  var isLinkNode = isLinkType(editor);
+  if (!isLinkNode) return null;
+  var _Editor$nodes3 = _slate.Editor.nodes(editor, {
+      match: function match(n) {
+        return (0, _queries.getNodeType)(n) === _constants.ELementTypes.LINK;
+      },
+      universal: true
+    }),
+    _Editor$nodes4 = (0, _slicedToArray2.default)(_Editor$nodes3, 1),
+    match = _Editor$nodes4[0];
+  if (!match) return null;
+  var _match = (0, _slicedToArray2.default)(match, 2),
+    node = _match[0],
+    path = _match[1];
+  var showedText = (0, _queries.getEditorString)(editor, path);
+  return {
+    linkUrl: node.url,
+    linkTitle: showedText || node.title,
+    path: path
+  };
+};
+var updateLink = exports.updateLink = function updateLink(editor, newUrl, newText) {
+  var linkAbove = (0, _queries.getAboveNode)(editor, {
+    match: {
+      type: _constants.ELementTypes.LINK
+    }
+  });
+  if (!linkAbove) return;
+  var _ref = linkAbove[0] || {},
+    oldUrl = _ref.href,
+    oldText = _ref.title;
+  if (oldUrl !== newUrl || oldText !== newText) {
+    _slate.Transforms.setNodes(editor, {
+      url: newUrl,
+      title: newText
+    }, {
+      at: linkAbove[1]
+    });
+  }
+  upsertLinkText(editor, {
+    text: newText
+  });
+};
+var upsertLinkText = exports.upsertLinkText = function upsertLinkText(editor, _ref2) {
+  var text = _ref2.text;
+  var newLink = (0, _queries.getAboveNode)(editor, {
+    match: {
+      type: _constants.ELementTypes.LINK
+    }
+  });
+  if (!newLink) return;
+  var _newLink = (0, _slicedToArray2.default)(newLink, 2),
+    newLInkNode = _newLink[0],
+    newLinkPath = _newLink[1];
+  if (text && text.length && text !== (0, _queries.getEditorString)(editor, newLinkPath)) {
+    var firstText = newLInkNode.children[0];
+    (0, _replaceNodeChildren.replaceNodeChildren)(editor, {
+      at: newLinkPath,
+      nodes: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, firstText), {}, {
+        text: text
+      }),
+      insertOptions: {
+        select: true
+      }
+    });
+  }
+};
+var unWrapLinkNode = exports.unWrapLinkNode = function unWrapLinkNode(_x) {
+  return (_ref3 = _ref3 || (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee(editor) {
+    var _Editor$nodes5, _Editor$nodes6, linkNode;
+    return (0, _regeneratorRuntime2.default)().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$nodes5 = _slate.Editor.nodes(editor, {
+            match: function match(n) {
+              return (0, _queries.getNodeType)(n) === _constants.ELementTypes.LINK;
+            },
+            universal: true
+          }), _Editor$nodes6 = (0, _slicedToArray2.default)(_Editor$nodes5, 1), linkNode = _Editor$nodes6[0]; // Check selection is link node
+          if (!(!linkNode || !linkNode[0])) {
+            _context.next = 5;
+            break;
+          }
+          return _context.abrupt("return");
+        case 5:
+          _slate.Transforms.unwrapNodes(editor, {
+            match: function match(n) {
+              return (0, _queries.getNodeType)(n) === _constants.ELementTypes.LINK;
+            }
+          });
+        case 6:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }))).apply(this, arguments);
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _elementTypes = require("../../constants/element-types");
+var _menu = _interopRequireDefault(require("./menu"));
+var _plugin = _interopRequireDefault(require("./plugin"));
+var _renderElem = _interopRequireDefault(require("./render-elem"));
+var LinkPlugin = {
+  type: _elementTypes.LINK,
+  nodeType: 'element',
+  editorMenus: [_menu.default],
+  editorPlugin: _plugin.default,
+  renderElements: [_renderElem.default]
+};
+var _default = exports.default = LinkPlugin;

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

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _react = _interopRequireWildcard(require("react"));
+var _slate = require("slate");
+var _menuItem = _interopRequireDefault(require("../../../commons/menu/menu-item"));
+var _menusConfig = require("../../../constants/menus-config");
+var _elementTypes = require("../../../constants/element-types");
+var _helper = require("../helper");
+var _eventBus = _interopRequireDefault(require("../../../../utils/event-bus"));
+var _linkModal = _interopRequireDefault(require("./link-modal"));
+var _eventTypes = require("../../../../constants/event-types");
+var menuConfig = _menusConfig.MENUS_CONFIG_MAP[_elementTypes.LINK];
+var LinkMenu = function LinkMenu(_ref) {
+  var isRichEditor = _ref.isRichEditor,
+    className = _ref.className,
+    readonly = _ref.readonly,
+    editor = _ref.editor;
+  var _useState = (0, _react.useState)(false),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    isOpenLinkModal = _useState2[0],
+    setIsOpenLinkModal = _useState2[1];
+  var _useState3 = (0, _react.useState)({
+      linkTitle: '',
+      linkUrl: ''
+    }),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    linkInfo = _useState4[0],
+    setLinkInfo = _useState4[1];
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  var isLinkActive = (0, _react.useMemo)(function () {
+    return (0, _helper.isLinkType)(editor);
+  }, [editor.selection]);
+  (0, _react.useEffect)(function () {
+    var eventBus = _eventBus.default.getInstance();
+    var unsubscribe = eventBus.subscribe(_eventTypes.INTERNAL_EVENTS.ON_OPEN_LINK_POPOVER, handleOpenLinkModal);
+    return function () {
+      return unsubscribe();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  (0, _react.useEffect)(function () {
+    if ((0, _helper.isLinkType)(editor)) {
+      var newTitle = editor.selection && _slate.Editor.string(editor, editor.selection);
+      newTitle && setLinkInfo((0, _objectSpread2.default)((0, _objectSpread2.default)({}, linkInfo), {}, {
+        linkTitle: newTitle
+      }));
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [editor.selection]);
+  var handleOpenLinkModal = (0, _react.useCallback)(function (linkInfo) {
+    Reflect.ownKeys.length && setLinkInfo(linkInfo);
+    setIsOpenLinkModal(true);
+  }, [setIsOpenLinkModal, setLinkInfo]);
+  var onMouseDown = (0, _react.useCallback)(function (event) {
+    event.preventDefault();
+    event.stopPropagation();
+    if (isLinkActive) {
+      isLinkActive && (0, _helper.unWrapLinkNode)(editor);
+      return;
+    }
+    if (editor.selection) {
+      var selectedText = _slate.Editor.string(editor, editor.selection);
+      setLinkInfo((0, _objectSpread2.default)((0, _objectSpread2.default)({}, linkInfo), {}, {
+        linkTitle: selectedText
+      }));
+    }
+    setIsOpenLinkModal(true);
+    document.getElementById("seafile_".concat(_elementTypes.LINK)).blur();
+  }, [editor, isLinkActive, linkInfo]);
+  var onCloseModal = (0, _react.useCallback)(function () {
+    setIsOpenLinkModal(false);
+    setLinkInfo({
+      linkTitle: '',
+      linkUrl: ''
+    });
+  }, []);
+  return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_menuItem.default, Object.assign({
+    isRichEditor: isRichEditor,
+    className: className,
+    disabled: (0, _helper.isMenuDisabled)(editor, readonly),
+    isActive: isLinkActive,
+    onMouseDown: onMouseDown
+  }, menuConfig)), isOpenLinkModal && /*#__PURE__*/_react.default.createElement(_linkModal.default, {
+    onCloseModal: onCloseModal,
+    editor: editor,
+    linkTitle: linkInfo.linkTitle,
+    linkUrl: linkInfo.linkUrl
+  }));
+};
+var _default = exports.default = LinkMenu;

package/dist/extension/plugins/link/menu/link-modal.js

@@ -0,0 +1,163 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/defineProperty"));
+var _objectSpread6 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _react = _interopRequireWildcard(require("react"));
+var _reactstrap = require("reactstrap");
+var _reactI18next = require("react-i18next");
+var _helper = require("../helper");
+var _common = require("../../../../utils/common");
+var LinkModal = function LinkModal(_ref) {
+  var editor = _ref.editor,
+    onCloseModal = _ref.onCloseModal,
+    linkTitle = _ref.linkTitle,
+    linkUrl = _ref.linkUrl;
+  var _useState = (0, _react.useState)({
+      linkUrl: linkUrl !== null && linkUrl !== void 0 ? linkUrl : '',
+      linkTitle: linkTitle !== null && linkTitle !== void 0 ? linkTitle : ''
+    }),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    formData = _useState2[0],
+    setFormData = _useState2[1];
+  var _useState3 = (0, _react.useState)({
+      linkUrl: '',
+      linkTitle: ''
+    }),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    validatorErrorMessage = _useState4[0],
+    setValidatorErrorMessage = _useState4[1];
+  var linkAddressRef = (0, _react.useRef)(null);
+  var _useTranslation = (0, _reactI18next.useTranslation)(),
+    t = _useTranslation.t;
+  var isSubmitDisabled = (0, _react.useMemo)(function () {
+    var isFormDataEmpty = Object.values(formData).some(function (value) {
+      return value.length === 0;
+    });
+    if (isFormDataEmpty) return true;
+    var isValidatorErrorMessage = Object.values(validatorErrorMessage).some(function (value) {
+      return value.length > 0;
+    });
+    if (isValidatorErrorMessage) return true;
+    return false;
+  }, [formData, validatorErrorMessage]);
+  var onOpened = (0, _react.useCallback)(function () {
+    var _linkAddressRef$curre;
+    (_linkAddressRef$curre = linkAddressRef.current) === null || _linkAddressRef$curre === void 0 ? void 0 : _linkAddressRef$curre.focus();
+  }, []);
+
+  /**
+   * @param {String} formItemName  form item name
+   * @param {String} formItemValue form item value
+   * @returns if validate passed, return Promise.resolve(); else return Promise.reject(error message);
+   */
+  var validateFormData = (0, _react.useCallback)(function (formItemName, formItemValue) {
+    if (formItemName === 'linkUrl') {
+      if (formItemValue.length === 0) return Promise.reject('Link_address_required');
+      if (!(0, _common.isUrl)(formItemValue)) return Promise.reject('Link_address_invalid');
+    }
+    if (formItemName === 'linkTitle') {
+      if (!formItemValue.length) return Promise.reject('Link_title_required');
+      if (!formItemValue.trim().length) return Promise.reject('Blank_title_not_allowed');
+    }
+    return Promise.resolve();
+  }, []);
+  var preProcessBeforeOnchange = (0, _react.useCallback)(function (formItemName, formItemValue) {
+    if (formItemName === 'linkUrl') {
+      return formItemValue.trim();
+    }
+    return formItemValue;
+  }, []);
+  var onFormValueChange = (0, _react.useCallback)(function (e) {
+    var formItemName = e.target.name;
+    var formItemValue = e.target.value;
+    // pre-process form item value
+    formItemValue = preProcessBeforeOnchange(formItemName, formItemValue);
+    validateFormData(formItemName, formItemValue).then(function () {
+      return setValidatorErrorMessage((0, _objectSpread6.default)((0, _objectSpread6.default)({}, validatorErrorMessage), {}, (0, _defineProperty2.default)({}, formItemName, '')));
+    }, function (errMsg) {
+      return setValidatorErrorMessage((0, _objectSpread6.default)((0, _objectSpread6.default)({}, validatorErrorMessage), {}, (0, _defineProperty2.default)({}, formItemName, errMsg)));
+    });
+    setFormData((0, _objectSpread6.default)((0, _objectSpread6.default)({}, formData), {}, (0, _defineProperty2.default)({}, formItemName, formItemValue)));
+  }, [formData, preProcessBeforeOnchange, validateFormData, validatorErrorMessage]);
+  var onSubmit = (0, _react.useCallback)(function (e) {
+    // re-validate form data before submit
+    Object.entries(formData).forEach(function (_ref2) {
+      var _ref3 = (0, _slicedToArray2.default)(_ref2, 2),
+        key = _ref3[0],
+        value = _ref3[1];
+      return validateFormData(key, value).catch(function (errMsg) {
+        return setValidatorErrorMessage(function (prev) {
+          return (0, _objectSpread6.default)((0, _objectSpread6.default)({}, prev), {}, (0, _defineProperty2.default)({}, key, errMsg));
+        });
+      });
+    });
+    if (!isSubmitDisabled) {
+      var isLinkActive = (0, _helper.isLinkType)(editor);
+      isLinkActive ? (0, _helper.updateLink)(editor, formData.linkUrl, formData.linkTitle) : (0, _helper.insertLink)({
+        editor: editor,
+        url: formData.linkUrl,
+        title: formData.linkTitle
+      });
+      onCloseModal();
+    }
+    e.preventDefault();
+    e.stopPropagation();
+  }, [editor, formData, isSubmitDisabled, onCloseModal, validateFormData]);
+  var onKeydown = (0, _react.useCallback)(function (e) {
+    if (e.key === 'Enter') {
+      onSubmit(e);
+    }
+  }, [onSubmit]);
+  return /*#__PURE__*/_react.default.createElement(_reactstrap.Modal, {
+    isOpen: true,
+    toggle: onCloseModal,
+    onOpened: onOpened
+  }, /*#__PURE__*/_react.default.createElement(_reactstrap.ModalHeader, {
+    toggle: onCloseModal
+  }, t('Insert_link')), /*#__PURE__*/_react.default.createElement(_reactstrap.ModalBody, null, /*#__PURE__*/_react.default.createElement(_reactstrap.Form, {
+    onChange: onFormValueChange
+  }, /*#__PURE__*/_react.default.createElement(_reactstrap.FormGroup, null, /*#__PURE__*/_react.default.createElement(_reactstrap.Label, {
+    for: "linkUrl"
+  }, t('Link_address')), /*#__PURE__*/_react.default.createElement(_reactstrap.Input, {
+    onKeyDown: onKeydown
+    // `onChange={() => void 0}`  to fix reactstrap error which need `onChange` when `value` setteled, (`onChange` has been listened at `<Form>` )
+    ,
+    onChange: function onChange() {
+      return void 0;
+    },
+    value: formData.linkUrl,
+    invalid: !!validatorErrorMessage.linkUrl,
+    name: "linkUrl",
+    innerRef: linkAddressRef,
+    type: "url",
+    id: "linkUrl"
+  }), /*#__PURE__*/_react.default.createElement(_reactstrap.FormFeedback, null, t(validatorErrorMessage.linkUrl))), /*#__PURE__*/_react.default.createElement(_reactstrap.FormGroup, null, /*#__PURE__*/_react.default.createElement(_reactstrap.Label, {
+    for: "linkTitle"
+  }, t('Link_title')), /*#__PURE__*/_react.default.createElement(_reactstrap.Input, {
+    onKeyDown: onKeydown
+    // `onChange={() => void 0}`  to fix reactstrap error which need `onChange` when `value` setteled, (`onChange` has been listened at `<Form>` )
+    ,
+    onChange: function onChange() {
+      return void 0;
+    },
+    value: formData.linkTitle,
+    invalid: !!validatorErrorMessage.linkTitle,
+    name: "linkTitle",
+    id: "linkTitle"
+  }), /*#__PURE__*/_react.default.createElement(_reactstrap.FormFeedback, null, t(validatorErrorMessage.linkTitle))))), /*#__PURE__*/_react.default.createElement(_reactstrap.ModalFooter, null, /*#__PURE__*/_react.default.createElement(_reactstrap.Button, {
+    onClick: onCloseModal,
+    color: "secondary"
+  }, t('Cancel')), /*#__PURE__*/_react.default.createElement(_reactstrap.Button, {
+    onClick: onSubmit,
+    disabled: isSubmitDisabled,
+    color: "primary"
+  }, t('Add_link'))));
+};
+var _default = exports.default = LinkModal;

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

@@ -0,0 +1,104 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _slate = require("slate");
+var _slugid = _interopRequireDefault(require("slugid"));
+var _queries = require("../../core/queries");
+var _helper = require("./helper");
+var _elementTypes = require("../../constants/element-types");
+var _common = require("../../../utils/common");
+var _focusEditor = require("../../core/transforms/focus-editor");
+var withLink = function withLink(editor) {
+  var isInline = editor.isInline,
+    deleteBackward = editor.deleteBackward,
+    insertText = editor.insertText,
+    normalizeNode = editor.normalizeNode,
+    insertData = editor.insertData;
+  var newEditor = editor;
+
+  // Rewrite isInline
+  newEditor.isInline = function (elem) {
+    var type = elem.type;
+    if (type === _elementTypes.LINK) {
+      return true;
+    }
+    return isInline(elem);
+  };
+
+  // ! bug: insertFragment will insert the same character twice in LinkNode, so we need to delete the first character
+  newEditor.insertText = function (text) {
+    var isCollapsed = _slate.Range.isCollapsed(editor.selection);
+    var path = _slate.Editor.path(editor, editor.selection);
+    var isLinkNode = (0, _queries.getSelectedNodeByType)(editor, _elementTypes.LINK);
+    var isFocusAtLinkEnd = _slate.Editor.isEnd(editor, editor.selection.focus, path);
+    if (isCollapsed && isLinkNode && isFocusAtLinkEnd) {
+      _slate.Editor.insertFragment(newEditor, [{
+        id: _slugid.default.nice(),
+        text: text
+      }]);
+      return;
+    }
+    return insertText(text);
+  };
+  newEditor.insertData = function (data) {
+    // Paste link content
+    var text = data.getData('text/plain');
+    if ((0, _common.isUrl)(text) && !(0, _common.isImage)(text)) {
+      var link = (0, _helper.generateLinkNode)(text, text);
+      _slate.Editor.insertFragment(newEditor, [link], {
+        select: true
+      });
+      return;
+    }
+    insertData(data);
+  };
+  newEditor.deleteBackward = function (unit) {
+    var selection = newEditor.selection;
+    if (!selection) return deleteBackward(unit);
+    // Delete link node
+    var isDeletingLinkNode = (0, _helper.isLinkType)(editor);
+    if (isDeletingLinkNode) {
+      var linkNodeInfo = (0, _helper.getLinkInfo)(editor);
+      var next = _slate.Editor.next(editor);
+      var nextPath = _slate.Path.next(linkNodeInfo.path);
+      var nextNode = _slate.Editor.node(editor, nextPath);
+      (0, _focusEditor.focusEditor)(editor, next[1]);
+      _slate.Transforms.select(editor, nextNode[1]);
+      if (linkNodeInfo && linkNodeInfo.linkTitle.length === 1) {
+        _slate.Transforms.delete(newEditor, {
+          at: linkNodeInfo.path
+        });
+        return;
+      }
+    }
+    return deleteBackward(unit);
+  };
+
+  // Rewrite normalizeNode
+  newEditor.normalizeNode = function (_ref) {
+    var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+      node = _ref2[0],
+      path = _ref2[1];
+    var type = (0, _queries.getNodeType)(node);
+    if (type !== _elementTypes.LINK) {
+      // If the type is not link, perform default normalizeNode
+      return normalizeNode([node, path]);
+    }
+
+    // If the link is empty, delete it
+    var str = _slate.Node.string(node);
+    if (str === '') {
+      return _slate.Transforms.removeNodes(newEditor, {
+        at: path
+      });
+    }
+    return normalizeNode([node, path]);
+  };
+  return newEditor;
+};
+var _default = exports.default = withLink;