@atlaskit/editor-plugin-hyperlink 0.0.0

package/dist/esm/Toolbar.js

@@ -0,0 +1,271 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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) { _defineProperty(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; }
+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;
+}
+var dispatchAnalytics = function dispatchAnalytics(dispatch, state, analyticsBuilder, editorAnalyticsApi) {
+  if (dispatch) {
+    var tr = state.tr;
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent(analyticsBuilder(ACTION_SUBJECT_ID.HYPERLINK))(tr);
+    dispatch(tr);
+  }
+};
+var visitHyperlink = function visitHyperlink(editorAnalyticsApi) {
+  return function (state, dispatch) {
+    dispatchAnalytics(dispatch, state, buildVisitedLinkPayload, editorAnalyticsApi);
+    return true;
+  };
+};
+var openLinkSettings = function openLinkSettings(editorAnalyticsApi) {
+  return function (state, dispatch) {
+    dispatchAnalytics(dispatch, state, buildOpenedSettingsPayload, editorAnalyticsApi);
+    return true;
+  };
+};
+function getLinkText(activeLinkMark, state) {
+  if (!activeLinkMark.node) {
+    return undefined;
+  }
+  var textToUrl = normalizeUrl(activeLinkMark.node.text);
+  var linkMark = activeLinkMark.node.marks.find(function (mark) {
+    return mark.type === state.schema.marks.link;
+  });
+  var linkHref = linkMark && linkMark.attrs.href;
+  if (textToUrl === linkHref) {
+    return undefined;
+  }
+  return activeLinkMark.node.text;
+}
+export function HyperlinkAddToolbarWithState(_ref) {
+  var _ref$linkPickerOption = _ref.linkPickerOptions,
+    linkPickerOptions = _ref$linkPickerOption === void 0 ? {} : _ref$linkPickerOption,
+    onSubmit = _ref.onSubmit,
+    displayText = _ref.displayText,
+    displayUrl = _ref.displayUrl,
+    providerFactory = _ref.providerFactory,
+    view = _ref.view,
+    onCancel = _ref.onCancel,
+    invokeMethod = _ref.invokeMethod,
+    featureFlags = _ref.featureFlags,
+    onClose = _ref.onClose,
+    onEscapeCallback = _ref.onEscapeCallback,
+    onClickAwayCallback = _ref.onClickAwayCallback,
+    pluginInjectionApi = _ref.pluginInjectionApi;
+  var _useSharedPluginState = useSharedPluginState(pluginInjectionApi, ['hyperlink']),
+    hyperlinkState = _useSharedPluginState.hyperlinkState;
+  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
+  });
+}
+var getSettingsButtonGroup = function getSettingsButtonGroup(state, intl, featureFlags, editorAnalyticsApi) {
+  var floatingToolbarLinkSettingsButton = featureFlags.floatingToolbarLinkSettingsButton;
+  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 var getToolbarConfig = function getToolbarConfig(options, featureFlags, pluginInjectionApi) {
+  return function (state, intl, providerFactory) {
+    var _pluginInjectionApi$d;
+    var formatMessage = intl.formatMessage;
+    var linkState = stateKey.getState(state);
+    var 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
+     */
+    var lpLinkPicker = featureFlags.lpLinkPicker,
+      lpLinkPickerFocusTrap = featureFlags.lpLinkPickerFocusTrap,
+      preventPopupOverflow = featureFlags.preventPopupOverflow;
+    var shouldEnableFocusTrap = Boolean(lpLinkPicker && lpLinkPickerFocusTrap);
+    if (linkState && linkState.activeLinkMark) {
+      var activeLinkMark = linkState.activeLinkMark;
+      var 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(function (nodeType) {
+          return !!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;
+            var pos = activeLinkMark.pos,
+              node = activeLinkMark.node;
+            var linkMark = node.marks.filter(function (mark) {
+              return mark.type === state.schema.marks.link;
+            });
+            var link = linkMark[0] && linkMark[0].attrs.href;
+            var isValidUrl = isSafeUrl(link);
+            var labelOpenLink = formatMessage(isValidUrl ? linkMessages.openLink : linkToolbarCommonMessages.unableToOpenLink);
+            // TODO: ED-14403 investigate why these are not translating?
+            var labelUnlink = formatMessage(linkToolbarCommonMessages.unlink);
+            var editLink = formatMessage(linkToolbarCommonMessages.editLink);
+            var metadata = {
+              url: link,
+              title: ''
+            };
+            if (activeLinkMark.node.text) {
+              metadata.title = activeLinkMark.node.text;
+            }
+            return _objectSpread(_objectSpread({}, hyperLinkToolbar), {}, {
+              height: 32,
+              width: 250,
+              items: [].concat(_toConsumableArray((_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: state,
+                  formatMessage: formatMessage,
+                  markType: state.schema.marks.link
+                }]
+              }], _toConsumableArray(getSettingsButtonGroup(state, intl, featureFlags, editorAnalyticsApi))),
+              scrollable: true
+            });
+          }
+        case 'EDIT_INSERTED':
+        case 'INSERT':
+          {
+            var _link;
+            if (isEditLink(activeLinkMark) && activeLinkMark.node) {
+              var _linkMark = activeLinkMark.node.marks.filter(function (mark) {
+                return mark.type === state.schema.marks.link;
+              });
+              _link = _linkMark[0] && _linkMark[0].attrs.href;
+            }
+            var displayText = isEditLink(activeLinkMark) ? getLinkText(activeLinkMark, state) : linkState.activeText;
+            var popupHeight = lpLinkPicker ? LINKPICKER_HEIGHT_IN_PX : RECENT_SEARCH_HEIGHT_IN_PX;
+            return _objectSpread(_objectSpread({}, hyperLinkToolbar), {}, {
+              preventPopupOverflow: preventPopupOverflow,
+              height: popupHeight,
+              width: RECENT_SEARCH_WIDTH_IN_PX,
+              focusTrap: shouldEnableFocusTrap,
+              items: [{
+                type: 'custom',
+                fallback: [],
+                disableArrowNavigation: true,
+                render: function 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: function onCancel() {
+                      return view.focus();
+                    },
+                    onClose: lpLinkPickerFocusTrap ? function () {
+                      return view.focus();
+                    } : undefined,
+                    onEscapeCallback: onEscapeCallback,
+                    onClickAwayCallback: onClickAwayCallback,
+                    onSubmit: function onSubmit(href) {
+                      var _options$cardOptions;
+                      var title = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+                      var displayText = arguments.length > 2 ? arguments[2] : undefined;
+                      var inputMethod = arguments.length > 3 ? arguments[3] : undefined;
+                      var analytic = arguments.length > 4 ? arguments[4] : undefined;
+                      var isEdit = isEditLink(activeLinkMark);
+                      var action = isEdit ? ACTION.UPDATED : ACTION.INSERTED;
+                      var command = isEdit ? commandWithMetadata(updateLink(href, displayText || title, activeLinkMark.pos), {
+                        action: action,
+                        inputMethod: 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/esm/commands.js

@@ -0,0 +1,222 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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) { _defineProperty(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; }
+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), function (state, dispatch) {
+    var $pos = state.doc.resolve(pos);
+    var node = state.doc.nodeAt(pos);
+    var linkMark = state.schema.marks.link;
+    var mark = linkMark.isInSet(node.marks);
+    var url = normalizeUrl(href);
+    if (mark && mark.attrs.href === url) {
+      return false;
+    }
+    var rightBound = to && pos !== to ? to : pos - $pos.textOffset + node.nodeSize;
+    var tr = state.tr.removeMark(pos, rightBound, linkMark);
+    if (href.trim()) {
+      tr.addMark(pos, rightBound, linkMark.create(_objectSpread(_objectSpread({}, 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 function (state, dispatch) {
+    var $pos = state.doc.resolve(pos);
+    var node = state.doc.nodeAt(pos);
+    if (!node) {
+      return false;
+    }
+    var url = normalizeUrl(href);
+    var mark = state.schema.marks.link.isInSet(node.marks);
+    var linkMark = state.schema.marks.link;
+    var rightBound = to && pos !== to ? to : pos - $pos.textOffset + node.nodeSize;
+    var 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)
+      var linkAttrs = _objectSpread(_objectSpread({}, 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 function (state, dispatch) {
+    var link = state.schema.marks.link;
+    var tr = state.tr;
+    if (incomingHref.trim()) {
+      var _stateKey$getState;
+      var 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.
+      var currentText = (_stateKey$getState = stateKey.getState(state)) === null || _stateKey$getState === void 0 ? void 0 : _stateKey$getState.activeText;
+      var markEnd = to;
+      var 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;
+        var 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: 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: 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 var insertLinkWithAnalytics = function insertLinkWithAnalytics(inputMethod, from, to, href, editorAnalyticsApi, title, displayText) {
+  var cardsAvailable = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;
+  var sourceEvent = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 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 var insertLinkWithAnalyticsMobileNative = function 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 function (state, dispatch) {
+    if (dispatch) {
+      var _tr = state.tr;
+      _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) {
+      var _tr2 = state.tr.setMeta(stateKey, {
+        type: LinkAction.SHOW_INSERT_TOOLBAR,
+        inputMethod: 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: inputMethod
+        },
+        eventType: EVENT_TYPE.UI
+      })(_tr2);
+      dispatch(_tr2);
+    }
+    return true;
+  };
+}
+export function hideLinkToolbar() {
+  return function (state, dispatch) {
+    if (dispatch) {
+      dispatch(hideLinkToolbarSetMeta(state.tr));
+    }
+    return true;
+  };
+}
+export var hideLinkToolbarSetMeta = function hideLinkToolbarSetMeta(tr) {
+  return tr.setMeta(stateKey, {
+    type: LinkAction.HIDE_TOOLBAR
+  });
+};
+export var onEscapeCallback = function onEscapeCallback(state, dispatch) {
+  var _toolbarKey$getState2, _toolbarKey$getState3;
+  var tr = state.tr;
+  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 var onClickAwayCallback = function onClickAwayCallback(state, dispatch) {
+  if (dispatch) {
+    hideLinkToolbar()(state, dispatch);
+    return true;
+  }
+  return false;
+};

package/dist/esm/index.js

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

package/dist/esm/plugin.js

@@ -0,0 +1,114 @@
+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 as _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 as _plugin, stateKey } from './pm-plugins/main';
+import { prependToolbarButtons, toolbarButtonsPlugin } from './pm-plugins/toolbar-buttons';
+import { getToolbarConfig } from './Toolbar';
+export 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: link
+      }];
+    },
+    actions: {
+      prependToolbarButtons: prependToolbarButtons,
+      showLinkToolbar: function showLinkToolbar() {
+        var _api$dependencies$ana;
+        var inputMethod = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : INPUT_METHOD.TOOLBAR;
+        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: function getSharedState(editorState) {
+      if (!editorState) {
+        return undefined;
+      }
+      return 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 _plugin(dispatch, options === null || options === void 0 ? void 0 : options.editorAppearance);
+        }
+      }, {
+        name: 'fakeCursorToolbarPlugin',
+        plugin: function plugin() {
+          return fakeCursorToolbarPlugin;
+        }
+      }, {
+        name: 'hyperlinkInputRule',
+        plugin: function plugin(_ref2) {
+          var _api$dependencies$ana2;
+          var schema = _ref2.schema,
+            featureFlags = _ref2.featureFlags;
+          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: function 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: function quickInsert(_ref3) {
+        var formatMessage = _ref3.formatMessage;
+        return [{
+          id: 'hyperlink',
+          title: formatMessage(messages.link),
+          description: formatMessage(messages.linkDescription),
+          keywords: ['hyperlink', 'url'],
+          priority: 1200,
+          keyshortcut: tooltip(addLink),
+          icon: function icon() {
+            return /*#__PURE__*/React.createElement(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(stateKey, {
+              type: LinkAction.SHOW_INSERT_TOOLBAR,
+              inputMethod: 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: 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/esm/pm-plugins/fake-curor-for-toolbar-plugin-key.js

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

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

@@ -0,0 +1,61 @@
+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';
+var createTextCursor = function createTextCursor(pos) {
+  var node = document.createElement('div');
+  node.className = 'ProseMirror-fake-text-cursor';
+  return Decoration.widget(pos, node, {
+    key: 'hyperlink-text-cursor'
+  });
+};
+var createTextSelection = function createTextSelection(from, to) {
+  return Decoration.inline(from, to, {
+    class: 'ProseMirror-fake-text-selection'
+  });
+};
+var getInsertLinkToolbarState = function getInsertLinkToolbarState(editorState) {
+  var state = hyperlinkStateKey.getState(editorState);
+  if (state && state.activeLinkMark) {
+    if (state.activeLinkMark.type === InsertStatus.INSERT_LINK_TOOLBAR) {
+      return state.activeLinkMark;
+    }
+  }
+  return undefined;
+};
+var fakeCursorToolbarPlugin = new SafePlugin({
+  key: fakeCursorForToolbarPluginKey,
+  state: {
+    init: function init() {
+      return 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 DecorationSet.create(tr.doc, [_from === _to ? createTextCursor(_from) : createTextSelection(_from, _to)]);
+      }
+      return DecorationSet.empty;
+    }
+  },
+  props: {
+    decorations: function decorations(state) {
+      return fakeCursorForToolbarPluginKey.getState(state);
+    }
+  }
+});
+export default fakeCursorToolbarPlugin;