@atlaskit/editor-plugin-hyperlink 0.0.0

package/dist/cjs/plugin.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hyperlinkPlugin = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _adfSchema = require("@atlaskit/adf-schema");
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _keymaps = require("@atlaskit/editor-common/keymaps");
+var _link = require("@atlaskit/editor-common/link");
+var _messages = require("@atlaskit/editor-common/messages");
+var _quickInsert = require("@atlaskit/editor-common/quick-insert");
+var _commands = require("./commands");
+var _fakeCursorForToolbar = _interopRequireDefault(require("./pm-plugins/fake-cursor-for-toolbar"));
+var _inputRule = require("./pm-plugins/input-rule");
+var _keymap = require("./pm-plugins/keymap");
+var _main = require("./pm-plugins/main");
+var _toolbarButtons = require("./pm-plugins/toolbar-buttons");
+var _Toolbar = require("./Toolbar");
+var hyperlinkPlugin = function hyperlinkPlugin() {
+  var _api$dependencies, _api$dependencies$fea;
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var api = arguments.length > 1 ? arguments[1] : undefined;
+  var featureFlags = (api === null || api === void 0 ? void 0 : (_api$dependencies = api.dependencies) === null || _api$dependencies === void 0 ? void 0 : (_api$dependencies$fea = _api$dependencies.featureFlags) === null || _api$dependencies$fea === void 0 ? void 0 : _api$dependencies$fea.sharedState.currentState()) || {};
+  return {
+    name: 'hyperlink',
+    marks: function marks() {
+      return [{
+        name: 'link',
+        mark: _adfSchema.link
+      }];
+    },
+    actions: {
+      prependToolbarButtons: _toolbarButtons.prependToolbarButtons,
+      showLinkToolbar: function showLinkToolbar() {
+        var _api$dependencies$ana;
+        var inputMethod = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _analytics.INPUT_METHOD.TOOLBAR;
+        return (0, _commands.showLinkToolbar)(inputMethod, api === null || api === void 0 ? void 0 : (_api$dependencies$ana = api.dependencies.analytics) === null || _api$dependencies$ana === void 0 ? void 0 : _api$dependencies$ana.actions);
+      },
+      hideLinkToolbar: _commands.hideLinkToolbarSetMeta
+    },
+    getSharedState: function getSharedState(editorState) {
+      if (!editorState) {
+        return undefined;
+      }
+      return _main.stateKey.getState(editorState);
+    },
+    pmPlugins: function pmPlugins() {
+      var _options$cardOptions;
+      // Skip analytics if card provider is available, as they will be
+      // sent on handleRejected upon attempting to resolve smart link.
+      var skipAnalytics = !!(options !== null && options !== void 0 && (_options$cardOptions = options.cardOptions) !== null && _options$cardOptions !== void 0 && _options$cardOptions.provider);
+      return [{
+        name: 'hyperlink',
+        plugin: function plugin(_ref) {
+          var dispatch = _ref.dispatch;
+          return (0, _main.plugin)(dispatch, options === null || options === void 0 ? void 0 : options.editorAppearance);
+        }
+      }, {
+        name: 'fakeCursorToolbarPlugin',
+        plugin: function plugin() {
+          return _fakeCursorForToolbar.default;
+        }
+      }, {
+        name: 'hyperlinkInputRule',
+        plugin: function plugin(_ref2) {
+          var _api$dependencies$ana2;
+          var schema = _ref2.schema,
+            featureFlags = _ref2.featureFlags;
+          return (0, _inputRule.createInputRulePlugin)(schema, skipAnalytics, featureFlags, api === null || api === void 0 ? void 0 : (_api$dependencies$ana2 = api.dependencies.analytics) === null || _api$dependencies$ana2 === void 0 ? void 0 : _api$dependencies$ana2.actions);
+        }
+      }, {
+        name: 'hyperlinkKeymap',
+        plugin: function plugin() {
+          var _api$dependencies$ana3;
+          return (0, _keymap.createKeymapPlugin)(skipAnalytics, api === null || api === void 0 ? void 0 : (_api$dependencies$ana3 = api.dependencies.analytics) === null || _api$dependencies$ana3 === void 0 ? void 0 : _api$dependencies$ana3.actions);
+        }
+      }, {
+        name: 'hyperlinkToolbarButtons',
+        plugin: _toolbarButtons.toolbarButtonsPlugin
+      }];
+    },
+    pluginsOptions: {
+      quickInsert: function quickInsert(_ref3) {
+        var formatMessage = _ref3.formatMessage;
+        return [{
+          id: 'hyperlink',
+          title: formatMessage(_messages.toolbarInsertBlockMessages.link),
+          description: formatMessage(_messages.toolbarInsertBlockMessages.linkDescription),
+          keywords: ['hyperlink', 'url'],
+          priority: 1200,
+          keyshortcut: (0, _keymaps.tooltip)(_keymaps.addLink),
+          icon: function icon() {
+            return /*#__PURE__*/_react.default.createElement(_quickInsert.IconLink, null);
+          },
+          action: function action(insert, state) {
+            var _api$dependencies2, _api$dependencies2$an, _api$dependencies2$an2, _api$dependencies2$an3;
+            var tr = insert(undefined);
+            tr.setMeta(_main.stateKey, {
+              type: _link.LinkAction.SHOW_INSERT_TOOLBAR,
+              inputMethod: _analytics.INPUT_METHOD.QUICK_INSERT
+            });
+            var analyticsAttached = api === null || api === void 0 ? void 0 : (_api$dependencies2 = api.dependencies) === null || _api$dependencies2 === void 0 ? void 0 : (_api$dependencies2$an = _api$dependencies2.analytics) === null || _api$dependencies2$an === void 0 ? void 0 : (_api$dependencies2$an2 = _api$dependencies2$an.actions) === null || _api$dependencies2$an2 === void 0 ? void 0 : (_api$dependencies2$an3 = _api$dependencies2$an2.attachAnalyticsEvent) === null || _api$dependencies2$an3 === void 0 ? void 0 : _api$dependencies2$an3.call(_api$dependencies2$an2, {
+              action: _analytics.ACTION.INVOKED,
+              actionSubject: _analytics.ACTION_SUBJECT.TYPEAHEAD,
+              actionSubjectId: _analytics.ACTION_SUBJECT_ID.TYPEAHEAD_LINK,
+              attributes: {
+                inputMethod: _analytics.INPUT_METHOD.QUICK_INSERT
+              },
+              eventType: _analytics.EVENT_TYPE.UI
+            })(tr);
+            return analyticsAttached !== false ? tr : false;
+          }
+        }];
+      },
+      floatingToolbar: (0, _Toolbar.getToolbarConfig)(options, featureFlags, api)
+    }
+  };
+};
+exports.hyperlinkPlugin = hyperlinkPlugin;

package/dist/cjs/pm-plugins/fake-curor-for-toolbar-plugin-key.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fakeCursorForToolbarPluginKey = void 0;
+var _prosemirrorState = require("prosemirror-state");
+var fakeCursorForToolbarPluginKey = new _prosemirrorState.PluginKey('fakeCursorToolbarPlugin');
+exports.fakeCursorForToolbarPluginKey = fakeCursorForToolbarPluginKey;

package/dist/cjs/pm-plugins/fake-cursor-for-toolbar.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _prosemirrorView = require("prosemirror-view");
+var _link = require("@atlaskit/editor-common/link");
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _fakeCurorForToolbarPluginKey = require("./fake-curor-for-toolbar-plugin-key");
+var _main = require("./main");
+var createTextCursor = function createTextCursor(pos) {
+  var node = document.createElement('div');
+  node.className = 'ProseMirror-fake-text-cursor';
+  return _prosemirrorView.Decoration.widget(pos, node, {
+    key: 'hyperlink-text-cursor'
+  });
+};
+var createTextSelection = function createTextSelection(from, to) {
+  return _prosemirrorView.Decoration.inline(from, to, {
+    class: 'ProseMirror-fake-text-selection'
+  });
+};
+var getInsertLinkToolbarState = function getInsertLinkToolbarState(editorState) {
+  var state = _main.stateKey.getState(editorState);
+  if (state && state.activeLinkMark) {
+    if (state.activeLinkMark.type === _link.InsertStatus.INSERT_LINK_TOOLBAR) {
+      return state.activeLinkMark;
+    }
+  }
+  return undefined;
+};
+var fakeCursorToolbarPlugin = new _safePlugin.SafePlugin({
+  key: _fakeCurorForToolbarPluginKey.fakeCursorForToolbarPluginKey,
+  state: {
+    init: function init() {
+      return _prosemirrorView.DecorationSet.empty;
+    },
+    apply: function apply(tr, pluginState, oldState, newState) {
+      var oldInsertToolbarState = getInsertLinkToolbarState(oldState);
+      var insertToolbarState = getInsertLinkToolbarState(newState);
+      // Map DecorationSet if it still refers to the same position in the document
+      if (oldInsertToolbarState && insertToolbarState) {
+        var from = insertToolbarState.from,
+          to = insertToolbarState.to;
+        var oldFrom = tr.mapping.map(oldInsertToolbarState.from);
+        var oldTo = tr.mapping.map(oldInsertToolbarState.to);
+        if (oldFrom === from && oldTo === to) {
+          return pluginState.map(tr.mapping, tr.doc);
+        }
+      }
+      // Update DecorationSet if new insert toolbar, or if we have moved to a different position in the doc
+      if (insertToolbarState) {
+        var _from = insertToolbarState.from,
+          _to = insertToolbarState.to;
+        return _prosemirrorView.DecorationSet.create(tr.doc, [_from === _to ? createTextCursor(_from) : createTextSelection(_from, _to)]);
+      }
+      return _prosemirrorView.DecorationSet.empty;
+    }
+  },
+  props: {
+    decorations: function decorations(state) {
+      return _fakeCurorForToolbarPluginKey.fakeCursorForToolbarPluginKey.getState(state);
+    }
+  }
+});
+var _default = fakeCursorToolbarPlugin;
+exports.default = _default;

package/dist/cjs/pm-plugins/input-rule.js

@@ -0,0 +1,95 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInputRulePlugin = createInputRulePlugin;
+exports.createLinkInputRule = createLinkInputRule;
+exports.default = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _card = require("@atlaskit/editor-common/card");
+var _utils = require("@atlaskit/editor-common/utils");
+var _prosemirrorInputRules = require("@atlaskit/prosemirror-input-rules");
+function createLinkInputRule(regexp) {
+  var skipAnalytics = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var editorAnalyticsApi = arguments.length > 2 ? arguments[2] : undefined;
+  // Plain typed text (eg, typing 'www.google.com') should convert to a hyperlink
+  return (0, _prosemirrorInputRules.createRule)(regexp, function (state, match, start, end) {
+    var schema = state.schema;
+    if (state.doc.rangeHasMark(start, end, schema.marks.link)) {
+      return null;
+    }
+    var link = match;
+    var url = (0, _utils.normalizeUrl)(link.url);
+    var markType = schema.mark('link', {
+      href: url
+    });
+
+    // Need access to complete text to check if last URL is part of a filepath before linkifying
+    var nodeBefore = state.selection.$from.nodeBefore;
+    if (!nodeBefore || !nodeBefore.isText || !nodeBefore.text) {
+      return null;
+    }
+    var filepaths = (0, _utils.findFilepaths)(nodeBefore.text,
+    // The position referenced by 'start' is relative to the start of the document, findFilepaths deals with index in a node only.
+    start - (nodeBefore.text.length - link.text.length) // (start of link match) - (whole node text length - link length) gets start of text node, which is used as offset
+    );
+
+    if ((0, _utils.isLinkInMatches)(start, filepaths)) {
+      var _tr = state.tr;
+      return _tr;
+    }
+    var from = start;
+    var to = Math.min(start + link.text.length, state.doc.content.size);
+    var tr = state.tr.addMark(from, to, markType);
+
+    // Keep old behavior that will delete the space after the link
+    if (to === end) {
+      tr.insertText(' ');
+    }
+    (0, _card.addLinkMetadata)(state.selection, tr, {
+      inputMethod: _analytics.INPUT_METHOD.AUTO_DETECT
+    });
+    if (skipAnalytics) {
+      return tr;
+    }
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent((0, _utils.getLinkCreationAnalyticsEvent)(_analytics.INPUT_METHOD.AUTO_DETECT, url))(tr);
+    return tr;
+  });
+}
+function createInputRulePlugin(schema) {
+  var skipAnalytics = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var featureFlags = arguments.length > 2 ? arguments[2] : undefined;
+  var editorAnalyticsApi = arguments.length > 3 ? arguments[3] : undefined;
+  if (!schema.marks.link) {
+    return;
+  }
+  var urlWithASpaceRule = createLinkInputRule(_utils.LinkMatcher.create(), skipAnalytics, editorAnalyticsApi);
+
+  // [something](link) should convert to a hyperlink
+  var markdownLinkRule = (0, _prosemirrorInputRules.createRule)(/(^|[^!])\[(.*?)\]\((\S+)\)$/, function (state, match, start, end) {
+    var schema = state.schema;
+    var _match = (0, _slicedToArray2.default)(match, 4),
+      prefix = _match[1],
+      linkText = _match[2],
+      linkUrl = _match[3];
+    var url = (0, _utils.normalizeUrl)(linkUrl).trim();
+    var markType = schema.mark('link', {
+      href: url
+    });
+    var tr = state.tr.replaceWith(start + prefix.length, end, schema.text((linkText || '').trim(), [markType]));
+    (0, _card.addLinkMetadata)(state.selection, tr, {
+      inputMethod: _analytics.INPUT_METHOD.FORMATTING
+    });
+    if (skipAnalytics) {
+      return tr;
+    }
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent((0, _utils.getLinkCreationAnalyticsEvent)(_analytics.INPUT_METHOD.FORMATTING, url))(tr);
+    return tr;
+  });
+  return (0, _prosemirrorInputRules.createPlugin)('hyperlink', [urlWithASpaceRule, markdownLinkRule]);
+}
+var _default = createInputRulePlugin;
+exports.default = _default;

package/dist/cjs/pm-plugins/keymap.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createKeymapPlugin = createKeymapPlugin;
+exports.default = void 0;
+var _prosemirrorKeymap = require("prosemirror-keymap");
+var _adfSchema = require("@atlaskit/adf-schema");
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _keymaps = require("@atlaskit/editor-common/keymaps");
+var _utils = require("@atlaskit/editor-common/utils");
+var _commands = require("../commands");
+var _main = require("../pm-plugins/main");
+function createKeymapPlugin() {
+  var skipAnalytics = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  var editorAnalyticsApi = arguments.length > 1 ? arguments[1] : undefined;
+  var list = {};
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.addLink.common, (0, _commands.showLinkToolbar)(_analytics.INPUT_METHOD.SHORTCUT, editorAnalyticsApi), list);
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.enter.common, mayConvertLastWordToHyperlink(skipAnalytics, editorAnalyticsApi), list);
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.insertNewLine.common, mayConvertLastWordToHyperlink(skipAnalytics, editorAnalyticsApi), list);
+  (0, _keymaps.bindKeymapWithCommand)(_keymaps.escape.common, function (state, dispatch, view) {
+    var hyperlinkPlugin = _main.stateKey.getState(state);
+    if (hyperlinkPlugin.activeLinkMark) {
+      (0, _commands.hideLinkToolbar)()(state, dispatch);
+      if (view) {
+        view.focus();
+      }
+      return false;
+    }
+    return false;
+  }, list);
+  return (0, _prosemirrorKeymap.keymap)(list);
+}
+var mayConvertLastWordToHyperlink = function mayConvertLastWordToHyperlink(skipAnalytics, editorAnalyticsApi) {
+  return function (state, dispatch) {
+    var nodeBefore = state.selection.$from.nodeBefore;
+    if (!nodeBefore || !nodeBefore.isText || !nodeBefore.text) {
+      return false;
+    }
+    var words = nodeBefore.text.split(' ');
+    var lastWord = words[words.length - 1];
+    var match = (0, _adfSchema.getLinkMatch)(lastWord);
+    if (match) {
+      var hyperlinkedText = match.raw;
+      var start = state.selection.$from.pos - hyperlinkedText.length;
+      var end = state.selection.$from.pos;
+      if (state.doc.rangeHasMark(start, end, state.schema.marks.link)) {
+        return false;
+      }
+      var url = match.url;
+      var markType = state.schema.mark('link', {
+        href: url
+      });
+      var filepaths = (0, _utils.findFilepaths)(nodeBefore.text, start - (nodeBefore.text.length - hyperlinkedText.length) // The position referenced by 'start' is relative to the start of the document, findFilepaths deals with index in a node only.
+      );
+
+      if ((0, _utils.isLinkInMatches)(start, filepaths)) {
+        return false;
+      }
+      var tr = state.tr.addMark(start, end, markType);
+      if (dispatch) {
+        if (skipAnalytics) {
+          dispatch(tr);
+        } else {
+          editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent((0, _utils.getLinkCreationAnalyticsEvent)(_analytics.INPUT_METHOD.AUTO_DETECT, url))(tr);
+          dispatch(tr);
+        }
+      }
+    }
+    return false;
+  };
+};
+var _default = createKeymapPlugin;
+exports.default = _default;

package/dist/cjs/pm-plugins/main.js

@@ -0,0 +1,257 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stateKey = exports.plugin = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _prosemirrorState = require("prosemirror-state");
+var _uuid = _interopRequireDefault(require("uuid"));
+var _link3 = require("@atlaskit/editor-common/link");
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _utils = require("@atlaskit/editor-common/utils");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var isSelectionInsideLink = function isSelectionInsideLink(state) {
+  return !!state.doc.type.schema.marks.link.isInSet(state.selection.$from.marks());
+};
+var isSelectionAroundLink = function isSelectionAroundLink(state) {
+  var _state$selection = state.selection,
+    $from = _state$selection.$from,
+    $to = _state$selection.$to;
+  var node = $from.nodeAfter;
+  return !!node && $from.textOffset === 0 && $to.pos - $from.pos === node.nodeSize && !!state.doc.type.schema.marks.link.isInSet(node.marks);
+};
+var mapTransactionToState = function mapTransactionToState(state, tr) {
+  if (!state) {
+    return undefined;
+  } else if (state.type === _link3.InsertStatus.EDIT_LINK_TOOLBAR || state.type === _link3.InsertStatus.EDIT_INSERTED_TOOLBAR) {
+    var _tr$mapping$mapResult = tr.mapping.mapResult(state.pos, 1),
+      pos = _tr$mapping$mapResult.pos,
+      deleted = _tr$mapping$mapResult.deleted;
+    var node = tr.doc.nodeAt(pos);
+    // If the position was not deleted & it is still a link
+    if (!deleted && !!node.type.schema.marks.link.isInSet(node.marks)) {
+      if (node === state.node && pos === state.pos) {
+        return state;
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        pos: pos,
+        node: node
+      });
+    }
+    // If the position has been deleted, then require a navigation to show the toolbar again
+    return;
+  } else if (state.type === _link3.InsertStatus.INSERT_LINK_TOOLBAR) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      from: tr.mapping.map(state.from),
+      to: tr.mapping.map(state.to)
+    });
+  }
+  return;
+};
+var toState = function toState(state, action, editorState) {
+  // Show insert or edit toolbar
+  if (!state) {
+    switch (action) {
+      case _link3.LinkAction.SHOW_INSERT_TOOLBAR:
+        {
+          var _editorState$selectio = editorState.selection,
+            from = _editorState$selectio.from,
+            to = _editorState$selectio.to;
+          if ((0, _utils.canLinkBeCreatedInRange)(from, to)(editorState)) {
+            return {
+              type: _link3.InsertStatus.INSERT_LINK_TOOLBAR,
+              from: from,
+              to: to
+            };
+          }
+          return undefined;
+        }
+      case _link3.LinkAction.SELECTION_CHANGE:
+        // If the user has moved their cursor, see if they're in a link
+        var link = getActiveLinkMark(editorState);
+        if (link) {
+          return _objectSpread(_objectSpread({}, link), {}, {
+            type: _link3.InsertStatus.EDIT_LINK_TOOLBAR
+          });
+        }
+        return undefined;
+      default:
+        return undefined;
+    }
+  }
+  // Update toolbar state if selection changes, or if toolbar is hidden
+  if (state.type === _link3.InsertStatus.EDIT_LINK_TOOLBAR) {
+    switch (action) {
+      case _link3.LinkAction.EDIT_INSERTED_TOOLBAR:
+        {
+          var _link = getActiveLinkMark(editorState);
+          if (_link) {
+            if (_link.pos === state.pos && _link.node === state.node) {
+              return _objectSpread(_objectSpread({}, state), {}, {
+                type: _link3.InsertStatus.EDIT_INSERTED_TOOLBAR
+              });
+            }
+            return _objectSpread(_objectSpread({}, _link), {}, {
+              type: _link3.InsertStatus.EDIT_INSERTED_TOOLBAR
+            });
+          }
+          return undefined;
+        }
+      case _link3.LinkAction.SELECTION_CHANGE:
+        var _link2 = getActiveLinkMark(editorState);
+        if (_link2) {
+          if (_link2.pos === state.pos && _link2.node === state.node) {
+            // Make sure we return the same object, if it's the same link
+            return state;
+          }
+          return _objectSpread(_objectSpread({}, _link2), {}, {
+            type: _link3.InsertStatus.EDIT_LINK_TOOLBAR
+          });
+        }
+        return undefined;
+      case _link3.LinkAction.HIDE_TOOLBAR:
+        return undefined;
+      default:
+        return state;
+    }
+  }
+
+  // Remove toolbar if user changes selection or toolbar is hidden
+  if (state.type === _link3.InsertStatus.INSERT_LINK_TOOLBAR) {
+    switch (action) {
+      case _link3.LinkAction.SELECTION_CHANGE:
+      case _link3.LinkAction.HIDE_TOOLBAR:
+        return undefined;
+      default:
+        return state;
+    }
+  }
+  return;
+};
+var getActiveLinkMark = function getActiveLinkMark(state) {
+  var $from = state.selection.$from;
+  if (isSelectionInsideLink(state) || isSelectionAroundLink(state)) {
+    var pos = $from.pos - $from.textOffset;
+    var node = state.doc.nodeAt(pos);
+    return node && node.isText ? {
+      node: node,
+      pos: pos
+    } : undefined;
+  }
+  return undefined;
+};
+var getActiveText = function getActiveText(selection) {
+  var currentSlice = selection.content();
+  if (currentSlice.size === 0) {
+    return;
+  }
+  if (currentSlice.content.childCount === 1 && currentSlice.content.firstChild && selection instanceof _prosemirrorState.TextSelection) {
+    return currentSlice.content.firstChild.textContent;
+  }
+  return;
+};
+var stateKey = new _prosemirrorState.PluginKey('hyperlinkPlugin');
+exports.stateKey = stateKey;
+var plugin = function plugin(dispatch, editorAppearance) {
+  return new _safePlugin.SafePlugin({
+    state: {
+      init: function init(_, state) {
+        var canInsertLink = (0, _utils.canLinkBeCreatedInRange)(state.selection.from, state.selection.to)(state);
+        return {
+          activeText: getActiveText(state.selection),
+          canInsertLink: canInsertLink,
+          timesViewed: 0,
+          activeLinkMark: toState(undefined, _link3.LinkAction.SELECTION_CHANGE, state),
+          editorAppearance: editorAppearance
+        };
+      },
+      apply: function apply(tr, pluginState, oldState, newState) {
+        var state = pluginState;
+        var action = tr.getMeta(stateKey) && tr.getMeta(stateKey).type;
+        var inputMethod = tr.getMeta(stateKey) && tr.getMeta(stateKey).inputMethod;
+        if (tr.docChanged) {
+          state = {
+            activeText: state.activeText,
+            canInsertLink: (0, _utils.canLinkBeCreatedInRange)(newState.selection.from, newState.selection.to)(newState),
+            timesViewed: state.timesViewed,
+            inputMethod: inputMethod,
+            activeLinkMark: mapTransactionToState(state.activeLinkMark, tr),
+            editorAppearance: editorAppearance
+          };
+        }
+        if (action) {
+          var stateForAnalytics = [_link3.LinkAction.SHOW_INSERT_TOOLBAR, _link3.LinkAction.EDIT_INSERTED_TOOLBAR].includes(action) ? {
+            timesViewed: ++state.timesViewed,
+            searchSessionId: (0, _uuid.default)()
+          } : {
+            timesViewed: state.timesViewed,
+            searchSessionId: state.searchSessionId
+          };
+          state = _objectSpread({
+            activeText: state.activeText,
+            canInsertLink: state.canInsertLink,
+            inputMethod: inputMethod,
+            activeLinkMark: toState(state.activeLinkMark, action, newState),
+            editorAppearance: editorAppearance
+          }, stateForAnalytics);
+        }
+        var hasPositionChanged = oldState.selection.from !== newState.selection.from || oldState.selection.to !== newState.selection.to;
+        if (tr.selectionSet && hasPositionChanged) {
+          state = {
+            activeText: getActiveText(newState.selection),
+            canInsertLink: (0, _utils.canLinkBeCreatedInRange)(newState.selection.from, newState.selection.to)(newState),
+            activeLinkMark: toState(state.activeLinkMark, _link3.LinkAction.SELECTION_CHANGE, newState),
+            timesViewed: state.timesViewed,
+            searchSessionId: state.searchSessionId,
+            inputMethod: inputMethod,
+            editorAppearance: editorAppearance
+          };
+        }
+        if (!(0, _utils.shallowEqual)(state, pluginState)) {
+          dispatch(stateKey, state);
+        }
+        return state;
+      }
+    },
+    key: stateKey,
+    props: {
+      handleDOMEvents: {
+        mouseup: function mouseup(_, event) {
+          // this prevents redundant selection transaction when clicking on link
+          // link state will be update on slection change which happens on mousedown
+          if (isLinkDirectTarget(event)) {
+            event.preventDefault();
+            return true;
+          }
+          return false;
+        },
+        mousedown: function mousedown(view, event) {
+          // since link clicks are disallowed by browsers inside contenteditable
+          // so we need to handle shift+click selection ourselves in this case
+          if (!event.shiftKey || !isLinkDirectTarget(event)) {
+            return false;
+          }
+          var state = view.state;
+          var $anchor = state.selection.$anchor;
+          var newPosition = view.posAtCoords({
+            left: event.clientX,
+            top: event.clientY
+          });
+          if ((newPosition === null || newPosition === void 0 ? void 0 : newPosition.pos) != null && newPosition.pos !== $anchor.pos) {
+            var tr = state.tr.setSelection(_prosemirrorState.TextSelection.create(state.doc, $anchor.pos, newPosition.pos));
+            view.dispatch(tr);
+            return true;
+          }
+          return false;
+        }
+      }
+    }
+  });
+};
+exports.plugin = plugin;
+function isLinkDirectTarget(event) {
+  return (event === null || event === void 0 ? void 0 : event.target) instanceof HTMLElement && event.target.tagName === 'A';
+}

package/dist/cjs/pm-plugins/toolbar-buttons.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toolbarKey = exports.toolbarButtonsPlugin = exports.prependToolbarButtons = void 0;
+var _prosemirrorState = require("prosemirror-state");
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var toolbarKey = new _prosemirrorState.PluginKey('hyperlinkToolbarItems');
+exports.toolbarKey = toolbarKey;
+var prependToolbarButtons = function prependToolbarButtons(_ref) {
+  var items = _ref.items,
+    onEscapeCallback = _ref.onEscapeCallback,
+    onInsertLinkCallback = _ref.onInsertLinkCallback,
+    view = _ref.view;
+  var tr = view.state.tr,
+    dispatch = view.dispatch;
+  tr.setMeta(toolbarKey, {
+    items: items,
+    onEscapeCallback: onEscapeCallback,
+    onInsertLinkCallback: onInsertLinkCallback
+  });
+  dispatch(tr);
+};
+exports.prependToolbarButtons = prependToolbarButtons;
+var toolbarButtonsPlugin = function toolbarButtonsPlugin() {
+  return new _safePlugin.SafePlugin({
+    key: toolbarKey,
+    state: {
+      init: function init(_, state) {
+        return undefined;
+      },
+      apply: function apply(tr, pluginState) {
+        var metaState = tr.getMeta(toolbarKey);
+        if (metaState) {
+          return metaState;
+        }
+        return pluginState;
+      }
+    }
+  });
+};
+exports.toolbarButtonsPlugin = toolbarButtonsPlugin;

package/dist/cjs/version.json

@@ -0,0 +1,5 @@
+{
+	"name": "@atlaskit/editor-plugin-hyperlink",
+	"version": "0.1.0",
+	"sideEffects": false
+}