@atlaskit/editor-plugin-hyperlink 0.0.0

package/dist/es2019/Toolbar.js

@@ -0,0 +1,260 @@
+import React from 'react';
+import { isSafeUrl } from '@atlaskit/adf-schema';
+import { ACTION, ACTION_SUBJECT_ID, buildOpenedSettingsPayload, buildVisitedLinkPayload, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { commandWithMetadata } from '@atlaskit/editor-common/card';
+import { useSharedPluginState } from '@atlaskit/editor-common/hooks';
+import { HyperlinkAddToolbar } from '@atlaskit/editor-common/link';
+import { linkMessages, linkToolbarMessages as linkToolbarCommonMessages } from '@atlaskit/editor-common/messages';
+import { LINKPICKER_HEIGHT_IN_PX, RECENT_SEARCH_HEIGHT_IN_PX, RECENT_SEARCH_WIDTH_IN_PX } from '@atlaskit/editor-common/ui';
+import { normalizeUrl } from '@atlaskit/editor-common/utils';
+import CogIcon from '@atlaskit/icon/glyph/editor/settings';
+import UnlinkIcon from '@atlaskit/icon/glyph/editor/unlink';
+import OpenIcon from '@atlaskit/icon/glyph/shortcut';
+import { editInsertedLink, insertLinkWithAnalytics, onClickAwayCallback, onEscapeCallback, removeLink, updateLink } from './commands';
+import { stateKey } from './pm-plugins/main';
+import { toolbarKey } from './pm-plugins/toolbar-buttons';
+/* type guard for edit links */
+function isEditLink(linkMark) {
+  return linkMark.pos !== undefined;
+}
+const dispatchAnalytics = (dispatch, state, analyticsBuilder, editorAnalyticsApi) => {
+  if (dispatch) {
+    const {
+      tr
+    } = state;
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent(analyticsBuilder(ACTION_SUBJECT_ID.HYPERLINK))(tr);
+    dispatch(tr);
+  }
+};
+const visitHyperlink = editorAnalyticsApi => (state, dispatch) => {
+  dispatchAnalytics(dispatch, state, buildVisitedLinkPayload, editorAnalyticsApi);
+  return true;
+};
+const openLinkSettings = editorAnalyticsApi => (state, dispatch) => {
+  dispatchAnalytics(dispatch, state, buildOpenedSettingsPayload, editorAnalyticsApi);
+  return true;
+};
+function getLinkText(activeLinkMark, state) {
+  if (!activeLinkMark.node) {
+    return undefined;
+  }
+  const textToUrl = normalizeUrl(activeLinkMark.node.text);
+  const linkMark = activeLinkMark.node.marks.find(mark => mark.type === state.schema.marks.link);
+  const linkHref = linkMark && linkMark.attrs.href;
+  if (textToUrl === linkHref) {
+    return undefined;
+  }
+  return activeLinkMark.node.text;
+}
+export function HyperlinkAddToolbarWithState({
+  linkPickerOptions = {},
+  onSubmit,
+  displayText,
+  displayUrl,
+  providerFactory,
+  view,
+  onCancel,
+  invokeMethod,
+  featureFlags,
+  onClose,
+  onEscapeCallback,
+  onClickAwayCallback,
+  pluginInjectionApi
+}) {
+  const {
+    hyperlinkState
+  } = useSharedPluginState(pluginInjectionApi, ['hyperlink']);
+  return /*#__PURE__*/React.createElement(HyperlinkAddToolbar, {
+    linkPickerOptions: linkPickerOptions,
+    onSubmit: onSubmit,
+    displayText: displayText,
+    displayUrl: displayUrl,
+    providerFactory: providerFactory,
+    view: view,
+    onCancel: onCancel,
+    invokeMethod: invokeMethod,
+    featureFlags: featureFlags,
+    onClose: onClose,
+    onEscapeCallback: onEscapeCallback,
+    onClickAwayCallback: onClickAwayCallback,
+    hyperlinkPluginState: hyperlinkState
+  });
+}
+const getSettingsButtonGroup = (state, intl, featureFlags, editorAnalyticsApi) => {
+  const {
+    floatingToolbarLinkSettingsButton
+  } = featureFlags;
+  return floatingToolbarLinkSettingsButton === 'true' ? [{
+    type: 'separator'
+  }, {
+    id: 'editor.link.settings',
+    type: 'button',
+    icon: CogIcon,
+    title: intl.formatMessage(linkToolbarCommonMessages.settingsLink),
+    onClick: openLinkSettings(editorAnalyticsApi),
+    href: 'https://id.atlassian.com/manage-profile/link-preferences',
+    target: '_blank'
+  }] : [];
+};
+export const getToolbarConfig = (options, featureFlags, pluginInjectionApi) => (state, intl, providerFactory) => {
+  var _pluginInjectionApi$d;
+  const {
+    formatMessage
+  } = intl;
+  const linkState = stateKey.getState(state);
+  const editorAnalyticsApi = pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$d = pluginInjectionApi.dependencies.analytics) === null || _pluginInjectionApi$d === void 0 ? void 0 : _pluginInjectionApi$d.actions;
+
+  /**
+   * Enable focus trap only if feature flag is enabled AND for the new version of the picker
+   */
+  const {
+    lpLinkPicker,
+    lpLinkPickerFocusTrap,
+    preventPopupOverflow
+  } = featureFlags;
+  const shouldEnableFocusTrap = Boolean(lpLinkPicker && lpLinkPickerFocusTrap);
+  if (linkState && linkState.activeLinkMark) {
+    const {
+      activeLinkMark
+    } = linkState;
+    const hyperLinkToolbar = {
+      title: 'Hyperlink floating controls',
+      nodeType: [state.schema.nodes.text, state.schema.nodes.paragraph, state.schema.nodes.heading, state.schema.nodes.taskItem, state.schema.nodes.decisionItem, state.schema.nodes.caption].filter(nodeType => !!nodeType),
+      // Use only the node types existing in the schema ED-6745
+      align: 'left',
+      className: activeLinkMark.type.match('INSERT|EDIT_INSERTED') ? 'hyperlink-floating-toolbar' : ''
+    };
+    switch (activeLinkMark.type) {
+      case 'EDIT':
+        {
+          var _toolbarKey$getState$, _toolbarKey$getState;
+          const {
+            pos,
+            node
+          } = activeLinkMark;
+          const linkMark = node.marks.filter(mark => mark.type === state.schema.marks.link);
+          const link = linkMark[0] && linkMark[0].attrs.href;
+          const isValidUrl = isSafeUrl(link);
+          const labelOpenLink = formatMessage(isValidUrl ? linkMessages.openLink : linkToolbarCommonMessages.unableToOpenLink);
+          // TODO: ED-14403 investigate why these are not translating?
+          const labelUnlink = formatMessage(linkToolbarCommonMessages.unlink);
+          const editLink = formatMessage(linkToolbarCommonMessages.editLink);
+          let metadata = {
+            url: link,
+            title: ''
+          };
+          if (activeLinkMark.node.text) {
+            metadata.title = activeLinkMark.node.text;
+          }
+          return {
+            ...hyperLinkToolbar,
+            height: 32,
+            width: 250,
+            items: [...((_toolbarKey$getState$ = (_toolbarKey$getState = toolbarKey.getState(state)) === null || _toolbarKey$getState === void 0 ? void 0 : _toolbarKey$getState.items(state, intl, providerFactory, link)) !== null && _toolbarKey$getState$ !== void 0 ? _toolbarKey$getState$ : []), {
+              id: 'editor.link.edit',
+              type: 'button',
+              onClick: editInsertedLink(editorAnalyticsApi),
+              selected: false,
+              title: editLink,
+              showTitle: true,
+              metadata: metadata
+            }, {
+              type: 'separator'
+            }, {
+              id: 'editor.link.openLink',
+              type: 'button',
+              disabled: !isValidUrl,
+              target: '_blank',
+              href: isValidUrl ? link : undefined,
+              onClick: visitHyperlink(editorAnalyticsApi),
+              selected: false,
+              title: labelOpenLink,
+              icon: OpenIcon,
+              className: 'hyperlink-open-link',
+              metadata: metadata,
+              tabIndex: null
+            }, {
+              type: 'separator'
+            }, {
+              id: 'editor.link.unlink',
+              type: 'button',
+              onClick: commandWithMetadata(removeLink(pos, editorAnalyticsApi), {
+                inputMethod: INPUT_METHOD.FLOATING_TB
+              }),
+              selected: false,
+              title: labelUnlink,
+              icon: UnlinkIcon,
+              tabIndex: null
+            }, {
+              type: 'copy-button',
+              items: [{
+                type: 'separator'
+              }, {
+                state,
+                formatMessage: formatMessage,
+                markType: state.schema.marks.link
+              }]
+            }, ...getSettingsButtonGroup(state, intl, featureFlags, editorAnalyticsApi)],
+            scrollable: true
+          };
+        }
+      case 'EDIT_INSERTED':
+      case 'INSERT':
+        {
+          let link;
+          if (isEditLink(activeLinkMark) && activeLinkMark.node) {
+            const linkMark = activeLinkMark.node.marks.filter(mark => mark.type === state.schema.marks.link);
+            link = linkMark[0] && linkMark[0].attrs.href;
+          }
+          const displayText = isEditLink(activeLinkMark) ? getLinkText(activeLinkMark, state) : linkState.activeText;
+          const popupHeight = lpLinkPicker ? LINKPICKER_HEIGHT_IN_PX : RECENT_SEARCH_HEIGHT_IN_PX;
+          return {
+            ...hyperLinkToolbar,
+            preventPopupOverflow,
+            height: popupHeight,
+            width: RECENT_SEARCH_WIDTH_IN_PX,
+            focusTrap: shouldEnableFocusTrap,
+            items: [{
+              type: 'custom',
+              fallback: [],
+              disableArrowNavigation: true,
+              render: (view, idx) => {
+                if (!view) {
+                  return null;
+                }
+                return /*#__PURE__*/React.createElement(HyperlinkAddToolbarWithState, {
+                  pluginInjectionApi: pluginInjectionApi,
+                  view: view,
+                  key: idx,
+                  linkPickerOptions: options === null || options === void 0 ? void 0 : options.linkPicker,
+                  featureFlags: featureFlags,
+                  displayUrl: link,
+                  displayText: displayText || '',
+                  providerFactory: providerFactory,
+                  onCancel: () => view.focus(),
+                  onClose: lpLinkPickerFocusTrap ? () => view.focus() : undefined,
+                  onEscapeCallback: onEscapeCallback,
+                  onClickAwayCallback: onClickAwayCallback,
+                  onSubmit: (href, title = '', displayText, inputMethod, analytic) => {
+                    var _options$cardOptions;
+                    const isEdit = isEditLink(activeLinkMark);
+                    const action = isEdit ? ACTION.UPDATED : ACTION.INSERTED;
+                    const command = isEdit ? commandWithMetadata(updateLink(href, displayText || title, activeLinkMark.pos), {
+                      action,
+                      inputMethod,
+                      sourceEvent: analytic
+                    }) : insertLinkWithAnalytics(inputMethod, activeLinkMark.from, activeLinkMark.to, href, editorAnalyticsApi, title, displayText, !!(options !== null && options !== void 0 && (_options$cardOptions = options.cardOptions) !== null && _options$cardOptions !== void 0 && _options$cardOptions.provider), analytic);
+                    command(view.state, view.dispatch, view);
+                    if (!lpLinkPickerFocusTrap) {
+                      view.focus();
+                    }
+                  }
+                });
+              }
+            }]
+          };
+        }
+    }
+  }
+  return;
+};

package/dist/es2019/commands.js

@@ -0,0 +1,225 @@
+import { Selection } from 'prosemirror-state';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, buildEditLinkPayload, EVENT_TYPE, INPUT_METHOD, unlinkPayload } from '@atlaskit/editor-common/analytics';
+import { addLinkMetadata, commandWithMetadata } from '@atlaskit/editor-common/card';
+import { withAnalytics } from '@atlaskit/editor-common/editor-analytics';
+import { isTextAtPos, LinkAction } from '@atlaskit/editor-common/link';
+import { filterCommands as filter, getLinkCreationAnalyticsEvent, normalizeUrl } from '@atlaskit/editor-common/utils';
+import { getBooleanFF } from '@atlaskit/platform-feature-flags';
+import { stateKey } from './pm-plugins/main';
+import { toolbarKey } from './pm-plugins/toolbar-buttons';
+export function setLinkHref(href, pos, editorAnalyticsApi, to, isTabPressed) {
+  return filter(isTextAtPos(pos), (state, dispatch) => {
+    const $pos = state.doc.resolve(pos);
+    const node = state.doc.nodeAt(pos);
+    const linkMark = state.schema.marks.link;
+    const mark = linkMark.isInSet(node.marks);
+    const url = normalizeUrl(href);
+    if (mark && mark.attrs.href === url) {
+      return false;
+    }
+    const rightBound = to && pos !== to ? to : pos - $pos.textOffset + node.nodeSize;
+    const tr = state.tr.removeMark(pos, rightBound, linkMark);
+    if (href.trim()) {
+      tr.addMark(pos, rightBound, linkMark.create({
+        ...(mark && mark.attrs || {}),
+        href: url
+      }));
+    } else {
+      editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent(unlinkPayload(ACTION_SUBJECT_ID.HYPERLINK))(tr);
+    }
+    if (!isTabPressed) {
+      tr.setMeta(stateKey, {
+        type: LinkAction.HIDE_TOOLBAR
+      });
+    }
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  });
+}
+export function updateLink(href, text, pos, to) {
+  return (state, dispatch) => {
+    const $pos = state.doc.resolve(pos);
+    const node = state.doc.nodeAt(pos);
+    if (!node) {
+      return false;
+    }
+    const url = normalizeUrl(href);
+    const mark = state.schema.marks.link.isInSet(node.marks);
+    const linkMark = state.schema.marks.link;
+    const rightBound = to && pos !== to ? to : pos - $pos.textOffset + node.nodeSize;
+    const tr = state.tr;
+    if (!url && text) {
+      tr.removeMark(pos, rightBound, linkMark);
+      tr.insertText(text, pos, rightBound);
+    } else if (!url) {
+      return false;
+    } else {
+      tr.insertText(text, pos, rightBound);
+      // Casting to LinkAttributes to prevent wrong attributes been passed (Example ED-7951)
+      const linkAttrs = {
+        ...(mark && mark.attrs || {}),
+        href: url
+      };
+      tr.addMark(pos, pos + text.length, linkMark.create(linkAttrs));
+      tr.setMeta(stateKey, {
+        type: LinkAction.HIDE_TOOLBAR
+      });
+    }
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+export function insertLink(from, to, incomingHref, incomingTitle, displayText, source, sourceEvent) {
+  return (state, dispatch) => {
+    const link = state.schema.marks.link;
+    const {
+      tr
+    } = state;
+    if (incomingHref.trim()) {
+      var _stateKey$getState;
+      const normalizedUrl = normalizeUrl(incomingHref);
+      // NB: in this context, `currentText` represents text which has been
+      // highlighted in the Editor, upon which a link is is being added.
+      const currentText = (_stateKey$getState = stateKey.getState(state)) === null || _stateKey$getState === void 0 ? void 0 : _stateKey$getState.activeText;
+      let markEnd = to;
+      const text = displayText || incomingTitle || incomingHref;
+      if (!displayText || displayText !== currentText) {
+        tr.insertText(text, from, to);
+        if (!isTextAtPos(from)(state)) {
+          markEnd = from + text.length + 1;
+        } else {
+          markEnd = from + text.length;
+        }
+      }
+      tr.addMark(from, markEnd, link.create({
+        href: normalizedUrl
+      }));
+      tr.setSelection(Selection.near(tr.doc.resolve(markEnd)));
+      if (!displayText || displayText === incomingHref) {
+        var _toolbarKey$getState;
+        const queueCardsFromChangedTr = (_toolbarKey$getState = toolbarKey.getState(state)) === null || _toolbarKey$getState === void 0 ? void 0 : _toolbarKey$getState.onInsertLinkCallback;
+        if (queueCardsFromChangedTr) {
+          queueCardsFromChangedTr === null || queueCardsFromChangedTr === void 0 ? void 0 : queueCardsFromChangedTr(state, tr, source, ACTION.INSERTED, false, sourceEvent);
+        } else {
+          addLinkMetadata(state.selection, tr, {
+            action: ACTION.INSERTED,
+            inputMethod: source,
+            sourceEvent
+          });
+        }
+      } else if (getBooleanFF('platform.linking-platform.editor.fix-link-insert-analytics')) {
+        /**
+         * Add link metadata because queue cards would have otherwise handled this for us
+         */
+        addLinkMetadata(state.selection, tr, {
+          action: ACTION.INSERTED,
+          inputMethod: source,
+          sourceEvent
+        });
+      }
+      tr.setMeta(stateKey, {
+        type: LinkAction.HIDE_TOOLBAR
+      });
+      if (dispatch) {
+        dispatch(tr);
+      }
+      return true;
+    }
+    tr.setMeta(stateKey, {
+      type: LinkAction.HIDE_TOOLBAR
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return false;
+  };
+}
+export const insertLinkWithAnalytics = (inputMethod, from, to, href, editorAnalyticsApi, title, displayText, cardsAvailable = false, sourceEvent = undefined) => {
+  // If smart cards are available, we send analytics for hyperlinks when a smart link is rejected.
+  if (cardsAvailable && !title && !displayText) {
+    return insertLink(from, to, href, title, displayText, inputMethod, sourceEvent);
+  }
+  return withAnalytics(editorAnalyticsApi, getLinkCreationAnalyticsEvent(inputMethod, href))(insertLink(from, to, href, title, displayText, inputMethod, sourceEvent));
+};
+export const insertLinkWithAnalyticsMobileNative = (inputMethod, from, to, href, editorAnalyticsApi, title, displayText) => {
+  return withAnalytics(editorAnalyticsApi, getLinkCreationAnalyticsEvent(inputMethod, href))(insertLink(from, to, href, title, displayText, inputMethod));
+};
+export function removeLink(pos, editorAnalyticsApi) {
+  return commandWithMetadata(setLinkHref('', pos, editorAnalyticsApi), {
+    action: ACTION.UNLINK
+  });
+}
+export function editInsertedLink(editorAnalyticsApi) {
+  return (state, dispatch) => {
+    if (dispatch) {
+      const {
+        tr
+      } = state;
+      tr.setMeta(stateKey, {
+        type: LinkAction.EDIT_INSERTED_TOOLBAR,
+        inputMethod: INPUT_METHOD.FLOATING_TB
+      });
+      editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent(buildEditLinkPayload(ACTION_SUBJECT_ID.HYPERLINK))(tr);
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+export function showLinkToolbar(inputMethod, editorAnalyticsApi) {
+  return function (state, dispatch) {
+    if (dispatch) {
+      const tr = state.tr.setMeta(stateKey, {
+        type: LinkAction.SHOW_INSERT_TOOLBAR,
+        inputMethod
+      });
+      editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent({
+        action: ACTION.INVOKED,
+        actionSubject: ACTION_SUBJECT.TYPEAHEAD,
+        actionSubjectId: ACTION_SUBJECT_ID.TYPEAHEAD_LINK,
+        attributes: {
+          inputMethod
+        },
+        eventType: EVENT_TYPE.UI
+      })(tr);
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+export function hideLinkToolbar() {
+  return function (state, dispatch) {
+    if (dispatch) {
+      dispatch(hideLinkToolbarSetMeta(state.tr));
+    }
+    return true;
+  };
+}
+export const hideLinkToolbarSetMeta = tr => {
+  return tr.setMeta(stateKey, {
+    type: LinkAction.HIDE_TOOLBAR
+  });
+};
+export const onEscapeCallback = (state, dispatch) => {
+  var _toolbarKey$getState2, _toolbarKey$getState3;
+  const {
+    tr
+  } = state;
+  hideLinkToolbarSetMeta(tr);
+  (_toolbarKey$getState2 = toolbarKey.getState(state)) === null || _toolbarKey$getState2 === void 0 ? void 0 : (_toolbarKey$getState3 = _toolbarKey$getState2.onEscapeCallback) === null || _toolbarKey$getState3 === void 0 ? void 0 : _toolbarKey$getState3.call(_toolbarKey$getState2, tr);
+  if (dispatch) {
+    dispatch(tr);
+    return true;
+  }
+  return false;
+};
+export const onClickAwayCallback = (state, dispatch) => {
+  if (dispatch) {
+    hideLinkToolbar()(state, dispatch);
+    return true;
+  }
+  return false;
+};

package/dist/es2019/index.js

@@ -0,0 +1 @@
+export { hyperlinkPlugin } from './plugin';

package/dist/es2019/plugin.js

@@ -0,0 +1,106 @@
+import React from 'react';
+import { link } from '@atlaskit/adf-schema';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { addLink, tooltip } from '@atlaskit/editor-common/keymaps';
+import { LinkAction } from '@atlaskit/editor-common/link';
+import { toolbarInsertBlockMessages as messages } from '@atlaskit/editor-common/messages';
+import { IconLink } from '@atlaskit/editor-common/quick-insert';
+import { hideLinkToolbarSetMeta, showLinkToolbar } from './commands';
+import fakeCursorToolbarPlugin from './pm-plugins/fake-cursor-for-toolbar';
+import { createInputRulePlugin } from './pm-plugins/input-rule';
+import { createKeymapPlugin } from './pm-plugins/keymap';
+import { plugin, stateKey } from './pm-plugins/main';
+import { prependToolbarButtons, toolbarButtonsPlugin } from './pm-plugins/toolbar-buttons';
+import { getToolbarConfig } from './Toolbar';
+export const hyperlinkPlugin = (options = {}, api) => {
+  var _api$dependencies, _api$dependencies$fea;
+  const 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() {
+      return [{
+        name: 'link',
+        mark: link
+      }];
+    },
+    actions: {
+      prependToolbarButtons,
+      showLinkToolbar: (inputMethod = INPUT_METHOD.TOOLBAR) => {
+        var _api$dependencies$ana;
+        return 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: hideLinkToolbarSetMeta
+    },
+    getSharedState(editorState) {
+      if (!editorState) {
+        return undefined;
+      }
+      return stateKey.getState(editorState);
+    },
+    pmPlugins() {
+      var _options$cardOptions;
+      // Skip analytics if card provider is available, as they will be
+      // sent on handleRejected upon attempting to resolve smart link.
+      const skipAnalytics = !!(options !== null && options !== void 0 && (_options$cardOptions = options.cardOptions) !== null && _options$cardOptions !== void 0 && _options$cardOptions.provider);
+      return [{
+        name: 'hyperlink',
+        plugin: ({
+          dispatch
+        }) => plugin(dispatch, options === null || options === void 0 ? void 0 : options.editorAppearance)
+      }, {
+        name: 'fakeCursorToolbarPlugin',
+        plugin: () => fakeCursorToolbarPlugin
+      }, {
+        name: 'hyperlinkInputRule',
+        plugin: ({
+          schema,
+          featureFlags
+        }) => {
+          var _api$dependencies$ana2;
+          return 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: () => {
+          var _api$dependencies$ana3;
+          return 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: toolbarButtonsPlugin
+      }];
+    },
+    pluginsOptions: {
+      quickInsert: ({
+        formatMessage
+      }) => [{
+        id: 'hyperlink',
+        title: formatMessage(messages.link),
+        description: formatMessage(messages.linkDescription),
+        keywords: ['hyperlink', 'url'],
+        priority: 1200,
+        keyshortcut: tooltip(addLink),
+        icon: () => /*#__PURE__*/React.createElement(IconLink, null),
+        action(insert, state) {
+          var _api$dependencies2, _api$dependencies2$an, _api$dependencies2$an2, _api$dependencies2$an3;
+          const tr = insert(undefined);
+          tr.setMeta(stateKey, {
+            type: LinkAction.SHOW_INSERT_TOOLBAR,
+            inputMethod: INPUT_METHOD.QUICK_INSERT
+          });
+          const 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: ACTION.INVOKED,
+            actionSubject: ACTION_SUBJECT.TYPEAHEAD,
+            actionSubjectId: ACTION_SUBJECT_ID.TYPEAHEAD_LINK,
+            attributes: {
+              inputMethod: INPUT_METHOD.QUICK_INSERT
+            },
+            eventType: EVENT_TYPE.UI
+          })(tr);
+          return analyticsAttached !== false ? tr : false;
+        }
+      }],
+      floatingToolbar: getToolbarConfig(options, featureFlags, api)
+    }
+  };
+};

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

@@ -0,0 +1,2 @@
+import { PluginKey } from 'prosemirror-state';
+export const fakeCursorForToolbarPluginKey = new PluginKey('fakeCursorToolbarPlugin');

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

@@ -0,0 +1,63 @@
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { InsertStatus } from '@atlaskit/editor-common/link';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { fakeCursorForToolbarPluginKey } from './fake-curor-for-toolbar-plugin-key';
+import { stateKey as hyperlinkStateKey } from './main';
+const createTextCursor = pos => {
+  const node = document.createElement('div');
+  node.className = 'ProseMirror-fake-text-cursor';
+  return Decoration.widget(pos, node, {
+    key: 'hyperlink-text-cursor'
+  });
+};
+const createTextSelection = (from, to) => Decoration.inline(from, to, {
+  class: 'ProseMirror-fake-text-selection'
+});
+const getInsertLinkToolbarState = editorState => {
+  const state = hyperlinkStateKey.getState(editorState);
+  if (state && state.activeLinkMark) {
+    if (state.activeLinkMark.type === InsertStatus.INSERT_LINK_TOOLBAR) {
+      return state.activeLinkMark;
+    }
+  }
+  return undefined;
+};
+const fakeCursorToolbarPlugin = new SafePlugin({
+  key: fakeCursorForToolbarPluginKey,
+  state: {
+    init() {
+      return DecorationSet.empty;
+    },
+    apply(tr, pluginState, oldState, newState) {
+      const oldInsertToolbarState = getInsertLinkToolbarState(oldState);
+      const insertToolbarState = getInsertLinkToolbarState(newState);
+      // Map DecorationSet if it still refers to the same position in the document
+      if (oldInsertToolbarState && insertToolbarState) {
+        const {
+          from,
+          to
+        } = insertToolbarState;
+        const oldFrom = tr.mapping.map(oldInsertToolbarState.from);
+        const 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) {
+        const {
+          from,
+          to
+        } = insertToolbarState;
+        return DecorationSet.create(tr.doc, [from === to ? createTextCursor(from) : createTextSelection(from, to)]);
+      }
+      return DecorationSet.empty;
+    }
+  },
+  props: {
+    decorations(state) {
+      return fakeCursorForToolbarPluginKey.getState(state);
+    }
+  }
+});
+export default fakeCursorToolbarPlugin;