@atlaskit/editor-plugin-hyperlink 0.0.0

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

@@ -0,0 +1,85 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { addLinkMetadata } from '@atlaskit/editor-common/card';
+import { findFilepaths, getLinkCreationAnalyticsEvent, isLinkInMatches, LinkMatcher, normalizeUrl } from '@atlaskit/editor-common/utils';
+import { createPlugin, createRule } from '@atlaskit/prosemirror-input-rules';
+export 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 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 = 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 = 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 (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(' ');
+    }
+    addLinkMetadata(state.selection, tr, {
+      inputMethod: INPUT_METHOD.AUTO_DETECT
+    });
+    if (skipAnalytics) {
+      return tr;
+    }
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent(getLinkCreationAnalyticsEvent(INPUT_METHOD.AUTO_DETECT, url))(tr);
+    return tr;
+  });
+}
+export 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(LinkMatcher.create(), skipAnalytics, editorAnalyticsApi);
+
+  // [something](link) should convert to a hyperlink
+  var markdownLinkRule = createRule(/(^|[^!])\[(.*?)\]\((\S+)\)$/, function (state, match, start, end) {
+    var schema = state.schema;
+    var _match = _slicedToArray(match, 4),
+      prefix = _match[1],
+      linkText = _match[2],
+      linkUrl = _match[3];
+    var url = normalizeUrl(linkUrl).trim();
+    var markType = schema.mark('link', {
+      href: url
+    });
+    var tr = state.tr.replaceWith(start + prefix.length, end, schema.text((linkText || '').trim(), [markType]));
+    addLinkMetadata(state.selection, tr, {
+      inputMethod: INPUT_METHOD.FORMATTING
+    });
+    if (skipAnalytics) {
+      return tr;
+    }
+    editorAnalyticsApi === null || editorAnalyticsApi === void 0 ? void 0 : editorAnalyticsApi.attachAnalyticsEvent(getLinkCreationAnalyticsEvent(INPUT_METHOD.FORMATTING, url))(tr);
+    return tr;
+  });
+  return createPlugin('hyperlink', [urlWithASpaceRule, markdownLinkRule]);
+}
+export default createInputRulePlugin;

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

@@ -0,0 +1,67 @@
+import { keymap } from 'prosemirror-keymap';
+import { getLinkMatch } from '@atlaskit/adf-schema';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { addLink, bindKeymapWithCommand, enter, escape, insertNewLine } from '@atlaskit/editor-common/keymaps';
+import { findFilepaths, getLinkCreationAnalyticsEvent, isLinkInMatches } from '@atlaskit/editor-common/utils';
+import { hideLinkToolbar, showLinkToolbar } from '../commands';
+import { stateKey } from '../pm-plugins/main';
+export function createKeymapPlugin() {
+  var skipAnalytics = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  var editorAnalyticsApi = arguments.length > 1 ? arguments[1] : undefined;
+  var list = {};
+  bindKeymapWithCommand(addLink.common, showLinkToolbar(INPUT_METHOD.SHORTCUT, editorAnalyticsApi), list);
+  bindKeymapWithCommand(enter.common, mayConvertLastWordToHyperlink(skipAnalytics, editorAnalyticsApi), list);
+  bindKeymapWithCommand(insertNewLine.common, mayConvertLastWordToHyperlink(skipAnalytics, editorAnalyticsApi), list);
+  bindKeymapWithCommand(escape.common, function (state, dispatch, view) {
+    var hyperlinkPlugin = stateKey.getState(state);
+    if (hyperlinkPlugin.activeLinkMark) {
+      hideLinkToolbar()(state, dispatch);
+      if (view) {
+        view.focus();
+      }
+      return false;
+    }
+    return false;
+  }, list);
+  return 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 = 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 = 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 (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(getLinkCreationAnalyticsEvent(INPUT_METHOD.AUTO_DETECT, url))(tr);
+          dispatch(tr);
+        }
+      }
+    }
+    return false;
+  };
+};
+export default createKeymapPlugin;

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

@@ -0,0 +1,248 @@
+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 { PluginKey, TextSelection } from 'prosemirror-state';
+import uuid from 'uuid';
+import { InsertStatus, LinkAction } from '@atlaskit/editor-common/link';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { canLinkBeCreatedInRange, shallowEqual } from '@atlaskit/editor-common/utils';
+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 === InsertStatus.EDIT_LINK_TOOLBAR || state.type === 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 === 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 LinkAction.SHOW_INSERT_TOOLBAR:
+        {
+          var _editorState$selectio = editorState.selection,
+            from = _editorState$selectio.from,
+            to = _editorState$selectio.to;
+          if (canLinkBeCreatedInRange(from, to)(editorState)) {
+            return {
+              type: InsertStatus.INSERT_LINK_TOOLBAR,
+              from: from,
+              to: to
+            };
+          }
+          return undefined;
+        }
+      case 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: InsertStatus.EDIT_LINK_TOOLBAR
+          });
+        }
+        return undefined;
+      default:
+        return undefined;
+    }
+  }
+  // Update toolbar state if selection changes, or if toolbar is hidden
+  if (state.type === InsertStatus.EDIT_LINK_TOOLBAR) {
+    switch (action) {
+      case LinkAction.EDIT_INSERTED_TOOLBAR:
+        {
+          var _link = getActiveLinkMark(editorState);
+          if (_link) {
+            if (_link.pos === state.pos && _link.node === state.node) {
+              return _objectSpread(_objectSpread({}, state), {}, {
+                type: InsertStatus.EDIT_INSERTED_TOOLBAR
+              });
+            }
+            return _objectSpread(_objectSpread({}, _link), {}, {
+              type: InsertStatus.EDIT_INSERTED_TOOLBAR
+            });
+          }
+          return undefined;
+        }
+      case 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: InsertStatus.EDIT_LINK_TOOLBAR
+          });
+        }
+        return undefined;
+      case LinkAction.HIDE_TOOLBAR:
+        return undefined;
+      default:
+        return state;
+    }
+  }
+
+  // Remove toolbar if user changes selection or toolbar is hidden
+  if (state.type === InsertStatus.INSERT_LINK_TOOLBAR) {
+    switch (action) {
+      case LinkAction.SELECTION_CHANGE:
+      case 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 TextSelection) {
+    return currentSlice.content.firstChild.textContent;
+  }
+  return;
+};
+export var stateKey = new PluginKey('hyperlinkPlugin');
+export var plugin = function plugin(dispatch, editorAppearance) {
+  return new SafePlugin({
+    state: {
+      init: function init(_, state) {
+        var canInsertLink = canLinkBeCreatedInRange(state.selection.from, state.selection.to)(state);
+        return {
+          activeText: getActiveText(state.selection),
+          canInsertLink: canInsertLink,
+          timesViewed: 0,
+          activeLinkMark: toState(undefined, 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: canLinkBeCreatedInRange(newState.selection.from, newState.selection.to)(newState),
+            timesViewed: state.timesViewed,
+            inputMethod: inputMethod,
+            activeLinkMark: mapTransactionToState(state.activeLinkMark, tr),
+            editorAppearance: editorAppearance
+          };
+        }
+        if (action) {
+          var stateForAnalytics = [LinkAction.SHOW_INSERT_TOOLBAR, LinkAction.EDIT_INSERTED_TOOLBAR].includes(action) ? {
+            timesViewed: ++state.timesViewed,
+            searchSessionId: uuid()
+          } : {
+            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: canLinkBeCreatedInRange(newState.selection.from, newState.selection.to)(newState),
+            activeLinkMark: toState(state.activeLinkMark, LinkAction.SELECTION_CHANGE, newState),
+            timesViewed: state.timesViewed,
+            searchSessionId: state.searchSessionId,
+            inputMethod: inputMethod,
+            editorAppearance: editorAppearance
+          };
+        }
+        if (!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(TextSelection.create(state.doc, $anchor.pos, newPosition.pos));
+            view.dispatch(tr);
+            return true;
+          }
+          return false;
+        }
+      }
+    }
+  });
+};
+function isLinkDirectTarget(event) {
+  return (event === null || event === void 0 ? void 0 : event.target) instanceof HTMLElement && event.target.tagName === 'A';
+}

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

@@ -0,0 +1,34 @@
+import { PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export var toolbarKey = new PluginKey('hyperlinkToolbarItems');
+export 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);
+};
+export var toolbarButtonsPlugin = function toolbarButtonsPlugin() {
+  return new 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;
+      }
+    }
+  });
+};

package/dist/esm/version.json

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

package/dist/types/Toolbar.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { HyperlinkAddToolbarProps } from '@atlaskit/editor-common/link';
+import type { ExtractInjectionAPI, FeatureFlags, FloatingToolbarHandler, HyperlinkPluginOptions } from '@atlaskit/editor-common/types';
+import type { hyperlinkPlugin } from './index';
+export declare function HyperlinkAddToolbarWithState({ linkPickerOptions, onSubmit, displayText, displayUrl, providerFactory, view, onCancel, invokeMethod, featureFlags, onClose, onEscapeCallback, onClickAwayCallback, pluginInjectionApi, }: HyperlinkAddToolbarProps & {
+    pluginInjectionApi: any;
+}): JSX.Element;
+export declare const getToolbarConfig: (options: HyperlinkPluginOptions, featureFlags: FeatureFlags, pluginInjectionApi: ExtractInjectionAPI<typeof hyperlinkPlugin> | undefined) => FloatingToolbarHandler;

package/dist/types/commands.d.ts

@@ -0,0 +1,20 @@
+import { Transaction } from 'prosemirror-state';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { EditorAnalyticsAPI, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { Command, LinkInputType } from '@atlaskit/editor-common/types';
+export declare function setLinkHref(href: string, pos: number, editorAnalyticsApi: EditorAnalyticsAPI | undefined, to?: number, isTabPressed?: boolean): Command;
+export declare function updateLink(href: string, text: string, pos: number, to?: number): Command;
+export declare function insertLink(from: number, to: number, incomingHref: string, incomingTitle?: string, displayText?: string, source?: LinkInputType, sourceEvent?: UIAnalyticsEvent | null | undefined): Command;
+export declare const insertLinkWithAnalytics: (inputMethod: LinkInputType, from: number, to: number, href: string, editorAnalyticsApi: EditorAnalyticsAPI | undefined, title?: string, displayText?: string, cardsAvailable?: boolean, sourceEvent?: UIAnalyticsEvent | null | undefined) => Command;
+export declare const insertLinkWithAnalyticsMobileNative: (inputMethod: LinkInputType, from: number, to: number, href: string, editorAnalyticsApi: EditorAnalyticsAPI | undefined, title?: string, displayText?: string) => Command;
+export declare function removeLink(pos: number, editorAnalyticsApi: EditorAnalyticsAPI | undefined): Command;
+export declare function editInsertedLink(editorAnalyticsApi: EditorAnalyticsAPI | undefined): Command;
+type InputMethod = INPUT_METHOD.TOOLBAR | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.SHORTCUT | INPUT_METHOD.INSERT_MENU;
+export type ShowLinkToolbar = (inputMethod: InputMethod) => Command;
+export declare function showLinkToolbar(inputMethod: InputMethod, editorAnalyticsApi: EditorAnalyticsAPI | undefined): Command;
+export declare function hideLinkToolbar(): Command;
+export type HideLinkToolbar = (tr: Transaction) => Transaction;
+export declare const hideLinkToolbarSetMeta: HideLinkToolbar;
+export declare const onEscapeCallback: Command;
+export declare const onClickAwayCallback: Command;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { hyperlinkPlugin } from './plugin';
+export type { HideLinkToolbar, ShowLinkToolbar } from './commands';
+export type { PrependToolbarButtons } from './pm-plugins/toolbar-buttons';

package/dist/types/plugin.d.ts

@@ -0,0 +1,38 @@
+import type { HyperlinkState } from '@atlaskit/editor-common/link';
+import type { HyperlinkPluginOptions, NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { analyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type featureFlagsPlugin from '@atlaskit/editor-plugin-feature-flags';
+import { HideLinkToolbar, ShowLinkToolbar } from './commands';
+import { PrependToolbarButtons } from './pm-plugins/toolbar-buttons';
+export declare const hyperlinkPlugin: NextEditorPlugin<'hyperlink', {
+    pluginConfiguration: HyperlinkPluginOptions | undefined;
+    dependencies: [
+        typeof featureFlagsPlugin,
+        OptionalPlugin<typeof analyticsPlugin>
+    ];
+    actions: {
+        /**
+         * Add items to the left of the hyperlink floating toolbar
+         * @param props
+         * -
+         * - items: Retrieve floating toolbar items to add
+         * - onEscapeCallback (optional): To be called when the link picker is escaped.
+         * - onInsertLinkCallback (optional): To be called when a link is inserted and it can be changed into a card.
+         */
+        prependToolbarButtons: PrependToolbarButtons;
+        /**
+         * Higher-order Command to show link toolbar.
+         *
+         * Example:
+         *
+         * ```
+         * pluginInjectionApi?.dependencies.hyperlink.actions.showLinkToolbar(
+         *   inputMethod
+         * )(state, dispatch)
+         * ```
+         */
+        showLinkToolbar: ShowLinkToolbar;
+        hideLinkToolbar: HideLinkToolbar;
+    };
+    sharedState: HyperlinkState | undefined;
+}>;

package/dist/types/pm-plugins/fake-curor-for-toolbar-plugin-key.d.ts

@@ -0,0 +1,2 @@
+import { PluginKey } from 'prosemirror-state';
+export declare const fakeCursorForToolbarPluginKey: PluginKey<any>;

package/dist/types/pm-plugins/fake-cursor-for-toolbar.d.ts

@@ -0,0 +1,3 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+declare const fakeCursorToolbarPlugin: SafePlugin;
+export default fakeCursorToolbarPlugin;

package/dist/types/pm-plugins/input-rule.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from 'prosemirror-model';
+import { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { InputRuleWrapper } from '@atlaskit/prosemirror-input-rules';
+export declare function createLinkInputRule(regexp: RegExp, skipAnalytics: boolean | undefined, editorAnalyticsApi: EditorAnalyticsAPI | undefined): InputRuleWrapper;
+export declare function createInputRulePlugin(schema: Schema, skipAnalytics: boolean | undefined, featureFlags: FeatureFlags, editorAnalyticsApi: EditorAnalyticsAPI | undefined): SafePlugin | undefined;
+export default createInputRulePlugin;

package/dist/types/pm-plugins/keymap.d.ts

@@ -0,0 +1,4 @@
+import { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare function createKeymapPlugin(skipAnalytics: boolean | undefined, editorAnalyticsApi: EditorAnalyticsAPI | undefined): SafePlugin | undefined;
+export default createKeymapPlugin;

package/dist/types/pm-plugins/main.d.ts

@@ -0,0 +1,7 @@
+import { PluginKey } from 'prosemirror-state';
+import { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { HyperlinkState } from '@atlaskit/editor-common/link';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { EditorAppearance } from '@atlaskit/editor-common/types';
+export declare const stateKey: PluginKey<HyperlinkState>;
+export declare const plugin: (dispatch: Dispatch, editorAppearance?: EditorAppearance) => SafePlugin<HyperlinkState>;

package/dist/types/pm-plugins/toolbar-buttons.d.ts

@@ -0,0 +1,21 @@
+import { EditorState, PluginKey, Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import type { IntlShape } from 'react-intl-next';
+import type { QueueCardsFromTransactionAction } from '@atlaskit/editor-common/card';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { FloatingToolbarItem } from '@atlaskit/editor-common/types';
+type HyperlinkToolbarItemsState = {
+    items: GetToolbarItems;
+    onEscapeCallback: ((tr: Transaction) => Transaction) | undefined;
+    onInsertLinkCallback: QueueCardsFromTransactionAction | undefined;
+};
+export declare const toolbarKey: PluginKey<HyperlinkToolbarItemsState | undefined>;
+type GetToolbarItems = (state: EditorState, intl: IntlShape, providerFactory: ProviderFactory, link: string) => FloatingToolbarItem<any>[];
+interface PrependToolbarButtonsProps extends HyperlinkToolbarItemsState {
+    view: EditorView;
+}
+export type PrependToolbarButtons = (props: PrependToolbarButtonsProps) => void;
+export declare const prependToolbarButtons: ({ items, onEscapeCallback, onInsertLinkCallback, view, }: PrependToolbarButtonsProps) => void;
+export declare const toolbarButtonsPlugin: () => SafePlugin<HyperlinkToolbarItemsState | undefined>;
+export {};

package/dist/types-ts4.5/Toolbar.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { HyperlinkAddToolbarProps } from '@atlaskit/editor-common/link';
+import type { ExtractInjectionAPI, FeatureFlags, FloatingToolbarHandler, HyperlinkPluginOptions } from '@atlaskit/editor-common/types';
+import type { hyperlinkPlugin } from './index';
+export declare function HyperlinkAddToolbarWithState({ linkPickerOptions, onSubmit, displayText, displayUrl, providerFactory, view, onCancel, invokeMethod, featureFlags, onClose, onEscapeCallback, onClickAwayCallback, pluginInjectionApi, }: HyperlinkAddToolbarProps & {
+    pluginInjectionApi: any;
+}): JSX.Element;
+export declare const getToolbarConfig: (options: HyperlinkPluginOptions, featureFlags: FeatureFlags, pluginInjectionApi: ExtractInjectionAPI<typeof hyperlinkPlugin> | undefined) => FloatingToolbarHandler;

package/dist/types-ts4.5/commands.d.ts

@@ -0,0 +1,20 @@
+import { Transaction } from 'prosemirror-state';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { EditorAnalyticsAPI, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { Command, LinkInputType } from '@atlaskit/editor-common/types';
+export declare function setLinkHref(href: string, pos: number, editorAnalyticsApi: EditorAnalyticsAPI | undefined, to?: number, isTabPressed?: boolean): Command;
+export declare function updateLink(href: string, text: string, pos: number, to?: number): Command;
+export declare function insertLink(from: number, to: number, incomingHref: string, incomingTitle?: string, displayText?: string, source?: LinkInputType, sourceEvent?: UIAnalyticsEvent | null | undefined): Command;
+export declare const insertLinkWithAnalytics: (inputMethod: LinkInputType, from: number, to: number, href: string, editorAnalyticsApi: EditorAnalyticsAPI | undefined, title?: string, displayText?: string, cardsAvailable?: boolean, sourceEvent?: UIAnalyticsEvent | null | undefined) => Command;
+export declare const insertLinkWithAnalyticsMobileNative: (inputMethod: LinkInputType, from: number, to: number, href: string, editorAnalyticsApi: EditorAnalyticsAPI | undefined, title?: string, displayText?: string) => Command;
+export declare function removeLink(pos: number, editorAnalyticsApi: EditorAnalyticsAPI | undefined): Command;
+export declare function editInsertedLink(editorAnalyticsApi: EditorAnalyticsAPI | undefined): Command;
+type InputMethod = INPUT_METHOD.TOOLBAR | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.SHORTCUT | INPUT_METHOD.INSERT_MENU;
+export type ShowLinkToolbar = (inputMethod: InputMethod) => Command;
+export declare function showLinkToolbar(inputMethod: InputMethod, editorAnalyticsApi: EditorAnalyticsAPI | undefined): Command;
+export declare function hideLinkToolbar(): Command;
+export type HideLinkToolbar = (tr: Transaction) => Transaction;
+export declare const hideLinkToolbarSetMeta: HideLinkToolbar;
+export declare const onEscapeCallback: Command;
+export declare const onClickAwayCallback: Command;
+export {};

package/dist/types-ts4.5/index.d.ts

@@ -0,0 +1,3 @@
+export { hyperlinkPlugin } from './plugin';
+export type { HideLinkToolbar, ShowLinkToolbar } from './commands';
+export type { PrependToolbarButtons } from './pm-plugins/toolbar-buttons';

package/dist/types-ts4.5/plugin.d.ts

@@ -0,0 +1,38 @@
+import type { HyperlinkState } from '@atlaskit/editor-common/link';
+import type { HyperlinkPluginOptions, NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { analyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type featureFlagsPlugin from '@atlaskit/editor-plugin-feature-flags';
+import { HideLinkToolbar, ShowLinkToolbar } from './commands';
+import { PrependToolbarButtons } from './pm-plugins/toolbar-buttons';
+export declare const hyperlinkPlugin: NextEditorPlugin<'hyperlink', {
+    pluginConfiguration: HyperlinkPluginOptions | undefined;
+    dependencies: [
+        typeof featureFlagsPlugin,
+        OptionalPlugin<typeof analyticsPlugin>
+    ];
+    actions: {
+        /**
+         * Add items to the left of the hyperlink floating toolbar
+         * @param props
+         * -
+         * - items: Retrieve floating toolbar items to add
+         * - onEscapeCallback (optional): To be called when the link picker is escaped.
+         * - onInsertLinkCallback (optional): To be called when a link is inserted and it can be changed into a card.
+         */
+        prependToolbarButtons: PrependToolbarButtons;
+        /**
+         * Higher-order Command to show link toolbar.
+         *
+         * Example:
+         *
+         * ```
+         * pluginInjectionApi?.dependencies.hyperlink.actions.showLinkToolbar(
+         *   inputMethod
+         * )(state, dispatch)
+         * ```
+         */
+        showLinkToolbar: ShowLinkToolbar;
+        hideLinkToolbar: HideLinkToolbar;
+    };
+    sharedState: HyperlinkState | undefined;
+}>;

package/dist/types-ts4.5/pm-plugins/fake-curor-for-toolbar-plugin-key.d.ts

@@ -0,0 +1,2 @@
+import { PluginKey } from 'prosemirror-state';
+export declare const fakeCursorForToolbarPluginKey: PluginKey<any>;

package/dist/types-ts4.5/pm-plugins/fake-cursor-for-toolbar.d.ts

@@ -0,0 +1,3 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+declare const fakeCursorToolbarPlugin: SafePlugin;
+export default fakeCursorToolbarPlugin;