@atlaskit/editor-plugin-type-ahead 0.6.0 → 0.7.1

package/dist/esm/ui/WrapperTypeAhead.js

@@ -0,0 +1,117 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import React, { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import { updateQuery } from '../commands/update-query';
+import { getPluginState, moveSelectedIndex } from '../utils';
+import { useItemInsert } from './hooks/use-item-insert';
+import { useLoadItems } from './hooks/use-load-items';
+import { useOnForceSelect } from './hooks/use-on-force-select';
+import { InputQuery } from './InputQuery';
+export var WrapperTypeAhead = /*#__PURE__*/React.memo(function (_ref) {
+  var triggerHandler = _ref.triggerHandler,
+    editorView = _ref.editorView,
+    anchorElement = _ref.anchorElement,
+    shouldFocusCursorInsideQuery = _ref.shouldFocusCursorInsideQuery,
+    popupsMountPoint = _ref.popupsMountPoint,
+    popupsBoundariesElement = _ref.popupsBoundariesElement,
+    popupsScrollableElement = _ref.popupsScrollableElement,
+    createAnalyticsEvent = _ref.createAnalyticsEvent,
+    inputMethod = _ref.inputMethod,
+    getDecorationPosition = _ref.getDecorationPosition,
+    reopenQuery = _ref.reopenQuery,
+    onUndoRedo = _ref.onUndoRedo;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    closed = _useState2[0],
+    setClosed = _useState2[1];
+  var _useState3 = useState(reopenQuery || ''),
+    _useState4 = _slicedToArray(_useState3, 2),
+    query = _useState4[0],
+    setQuery = _useState4[1];
+  var queryRef = useRef(query);
+  var editorViewRef = useRef(editorView);
+  var items = useLoadItems(triggerHandler, editorView, query);
+  useLayoutEffect(function () {
+    queryRef.current = query;
+  }, [query]);
+  var _useItemInsert = useItemInsert(triggerHandler, editorView, items),
+    _useItemInsert2 = _slicedToArray(_useItemInsert, 2),
+    onItemInsert = _useItemInsert2[0],
+    onTextInsert = _useItemInsert2[1];
+  var selectNextItem = useMemo(function () {
+    return moveSelectedIndex({
+      editorView: editorView,
+      direction: 'next'
+    });
+  }, [editorView]);
+  var selectPreviousItem = useMemo(function () {
+    return moveSelectedIndex({
+      editorView: editorView,
+      direction: 'previous'
+    });
+  }, [editorView]);
+  var cancel = useCallback(function (_ref2) {
+    var setSelectionAt = _ref2.setSelectionAt,
+      addPrefixTrigger = _ref2.addPrefixTrigger,
+      text = _ref2.text,
+      forceFocusOnEditor = _ref2.forceFocusOnEditor;
+    setClosed(true);
+    var fullquery = addPrefixTrigger ? "".concat(triggerHandler.trigger).concat(text) : text;
+    onTextInsert({
+      forceFocusOnEditor: forceFocusOnEditor,
+      setSelectionAt: setSelectionAt,
+      text: fullquery
+    });
+  }, [triggerHandler, onTextInsert]);
+  var insertSelectedItem = useCallback(function () {
+    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SelectItemMode.SELECTED;
+    var view = editorViewRef.current;
+    var _ref3 = getPluginState(view.state),
+      selectedIndex = _ref3.selectedIndex;
+    setClosed(true);
+    queueMicrotask(function () {
+      onItemInsert({
+        mode: mode,
+        index: selectedIndex,
+        query: queryRef.current
+      });
+    });
+  }, [onItemInsert]);
+  var showTypeAheadPopupList = useCallback(function () {}, []);
+  var closePopup = useCallback(function () {
+    setClosed(true);
+  }, []);
+  useEffect(function () {
+    var view = editorViewRef.current;
+    var pluginState = getPluginState(view.state);
+    if (query.length === 0 || query === (pluginState === null || pluginState === void 0 ? void 0 : pluginState.query) || !(pluginState !== null && pluginState !== void 0 && pluginState.triggerHandler)) {
+      return;
+    }
+    updateQuery(query)(view.state, view.dispatch);
+  }, [query, reopenQuery]);
+  useOnForceSelect({
+    triggerHandler: triggerHandler,
+    items: items,
+    query: query,
+    editorView: editorView,
+    closePopup: closePopup
+  });
+  if (closed) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(InputQuery, {
+    triggerQueryPrefix: triggerHandler.trigger,
+    onQueryChange: setQuery,
+    onItemSelect: insertSelectedItem,
+    selectNextItem: selectNextItem,
+    selectPreviousItem: selectPreviousItem,
+    onQueryFocus: showTypeAheadPopupList,
+    cancel: cancel,
+    forceFocus: shouldFocusCursorInsideQuery,
+    onUndoRedo: onUndoRedo,
+    reopenQuery: reopenQuery,
+    editorView: editorView,
+    items: items
+  });
+});
+WrapperTypeAhead.displayName = 'WrapperTypeAhead';

package/dist/esm/ui/hooks/use-item-insert.js

@@ -0,0 +1,103 @@
+import { useCallback, useLayoutEffect, useRef } from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import { insertTypeAheadItem } from '../../commands/insert-type-ahead-item';
+import { CloseSelectionOptions } from '../../constants';
+import { closeTypeAhead } from '../../transforms/close-type-ahead';
+import { setSelectionBeforeQuery } from '../../transforms/set-selection-before-query';
+var insertRawQuery = function insertRawQuery(_ref) {
+  var view = _ref.view,
+    setSelectionAt = _ref.setSelectionAt,
+    text = _ref.text,
+    forceFocusOnEditor = _ref.forceFocusOnEditor;
+  var _view$state = view.state,
+    tr = _view$state.tr,
+    schema = _view$state.schema;
+  closeTypeAhead(tr);
+  if (text.length > 0) {
+    tr.replaceSelectionWith(schema.text(text));
+    if (setSelectionAt === CloseSelectionOptions.BEFORE_TEXT_INSERTED) {
+      setSelectionBeforeQuery(text)(tr);
+    }
+  }
+  view.dispatch(tr);
+  if (forceFocusOnEditor) {
+    view.focus();
+  }
+};
+export var useItemInsert = function useItemInsert(triggerHandler, editorView, items) {
+  var editorViewRef = useRef(editorView);
+  var itemsRef = useRef(items);
+  var onTextInsert = useCallback(function (_ref2) {
+    var setSelectionAt = _ref2.setSelectionAt,
+      text = _ref2.text,
+      forceFocusOnEditor = _ref2.forceFocusOnEditor;
+    if (!triggerHandler) {
+      return;
+    }
+    var view = editorViewRef.current;
+    insertRawQuery({
+      view: view,
+      setSelectionAt: setSelectionAt,
+      text: text,
+      forceFocusOnEditor: forceFocusOnEditor
+    });
+  }, [triggerHandler]);
+  var onItemInsert = useCallback(function (_ref3) {
+    var mode = _ref3.mode,
+      index = _ref3.index,
+      query = _ref3.query;
+    var sourceListItem = itemsRef.current;
+    if (sourceListItem.length === 0 || !triggerHandler) {
+      var text = "".concat(triggerHandler.trigger).concat(query);
+      onTextInsert({
+        forceFocusOnEditor: true,
+        setSelectionAt: CloseSelectionOptions.AFTER_TEXT_INSERTED,
+        text: text
+      });
+      return;
+    }
+    var itemToInsert = sourceListItem[index];
+    if (!itemToInsert) {
+      return;
+    }
+    var view = editorViewRef.current;
+    insertTypeAheadItem(view)({
+      item: itemToInsert,
+      handler: triggerHandler,
+      mode: mode,
+      query: query,
+      sourceListItem: sourceListItem
+    });
+  }, [triggerHandler, onTextInsert]);
+  var onItemMatch = useCallback(function (_ref4) {
+    var mode = _ref4.mode,
+      query = _ref4.query;
+    var _items = itemsRef.current;
+    if (_items && _items.length > 1) {
+      return false;
+    }
+    if (_items.length === 1) {
+      queueMicrotask(function () {
+        onItemInsert({
+          mode: mode,
+          query: query,
+          index: 0
+        });
+      });
+    } else {
+      var text = "".concat(triggerHandler.trigger).concat(query);
+      queueMicrotask(function () {
+        onTextInsert({
+          forceFocusOnEditor: true,
+          setSelectionAt: CloseSelectionOptions.AFTER_TEXT_INSERTED,
+          text: mode === SelectItemMode.SPACE ? text.concat(' ') : text
+        });
+      });
+    }
+    return true;
+  }, [onItemInsert, triggerHandler, onTextInsert]);
+  useLayoutEffect(function () {
+    itemsRef.current = items;
+  }, [items]);
+  return [onItemInsert, onTextInsert, onItemMatch];
+};

package/dist/esm/ui/hooks/use-load-items.js

@@ -0,0 +1,43 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useEffect, useRef, useState } from 'react';
+import { updateListItem } from '../../commands/update-list-items';
+var EMPTY_LIST_ITEM = [];
+export var useLoadItems = function useLoadItems(triggerHandler, editorView, query) {
+  var _useState = useState(EMPTY_LIST_ITEM),
+    _useState2 = _slicedToArray(_useState, 2),
+    items = _useState2[0],
+    setItems = _useState2[1];
+  var componentIsMounted = useRef(true);
+  var editorViewRef = useRef(editorView);
+  useEffect(function () {
+    var getItems = triggerHandler === null || triggerHandler === void 0 ? void 0 : triggerHandler.getItems;
+    if (!getItems) {
+      setItems(EMPTY_LIST_ITEM);
+      return;
+    }
+    var options = {
+      query: query || '',
+      editorState: editorView.state
+    };
+    var view = editorViewRef.current;
+    getItems(options).then(function (result) {
+      var list = result.length > 0 ? result : EMPTY_LIST_ITEM;
+      if (componentIsMounted.current) {
+        setItems(list);
+      }
+      queueMicrotask(function () {
+        updateListItem(list)(view.state, view.dispatch);
+      });
+    });
+
+    // ignore because EditorView is mutable but we don't want to
+    // call loadItems when it changes, only when the query changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [triggerHandler, query]);
+  useEffect(function () {
+    return function () {
+      componentIsMounted.current = false;
+    };
+  }, []);
+  return items;
+};

package/dist/esm/ui/hooks/use-on-force-select.js

@@ -0,0 +1,35 @@
+import { useLayoutEffect, useRef } from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import { insertTypeAheadItem } from '../../commands/insert-type-ahead-item';
+export var useOnForceSelect = function useOnForceSelect(_ref) {
+  var triggerHandler = _ref.triggerHandler,
+    items = _ref.items,
+    query = _ref.query,
+    editorView = _ref.editorView,
+    closePopup = _ref.closePopup;
+  var editorViewRef = useRef(editorView);
+  useLayoutEffect(function () {
+    if (!query || typeof triggerHandler.forceSelect !== 'function') {
+      return;
+    }
+    var item = triggerHandler.forceSelect({
+      items: items,
+      query: query,
+      editorState: editorViewRef.current.state
+    });
+    if (!item) {
+      return;
+    }
+    var view = editorViewRef.current;
+    closePopup();
+    queueMicrotask(function () {
+      insertTypeAheadItem(view)({
+        item: item,
+        mode: SelectItemMode.SPACE,
+        query: query,
+        handler: triggerHandler,
+        sourceListItem: items
+      });
+    });
+  }, [triggerHandler, closePopup, query, items]);
+};

package/dist/esm/utils.js

@@ -0,0 +1,124 @@
+import { TypeAheadAvailableNodes } from '@atlaskit/editor-common/type-ahead';
+import { updateSelectedIndex } from './commands/update-selected-index';
+import { typeAheadListMessages } from './messages';
+import { pluginKey as typeAheadPluginKey } from './pm-plugins/key';
+import { StatsModifier } from './stats-modifier';
+export var isTypeAheadHandler = function isTypeAheadHandler(handler) {
+  return handler && Object.values(TypeAheadAvailableNodes).includes(handler.id) && typeof handler.trigger === 'string' && typeof handler.selectItem === 'function' && typeof handler.getItems === 'function';
+};
+
+/** Is a typeahead plugin open? */
+export var isTypeAheadOpen = function isTypeAheadOpen(editorState) {
+  var _typeAheadPluginKey$g;
+  return !!(typeAheadPluginKey !== null && typeAheadPluginKey !== void 0 && (_typeAheadPluginKey$g = typeAheadPluginKey.getState(editorState)) !== null && _typeAheadPluginKey$g !== void 0 && (_typeAheadPluginKey$g = _typeAheadPluginKey$g.decorationSet) !== null && _typeAheadPluginKey$g !== void 0 && _typeAheadPluginKey$g.find().length);
+};
+export var getPluginState = function getPluginState(editorState) {
+  return typeAheadPluginKey.getState(editorState);
+};
+export var getTypeAheadHandler = function getTypeAheadHandler(editorState) {
+  var _typeAheadPluginKey$g2;
+  return (_typeAheadPluginKey$g2 = typeAheadPluginKey.getState(editorState)) === null || _typeAheadPluginKey$g2 === void 0 ? void 0 : _typeAheadPluginKey$g2.triggerHandler;
+};
+export var getTypeAheadQuery = function getTypeAheadQuery(editorState) {
+  var _typeAheadPluginKey$g3;
+  return (_typeAheadPluginKey$g3 = typeAheadPluginKey.getState(editorState)) === null || _typeAheadPluginKey$g3 === void 0 ? void 0 : _typeAheadPluginKey$g3.query;
+};
+export var isTypeAheadAllowed = function isTypeAheadAllowed(state) {
+  var isOpen = isTypeAheadOpen(state);
+  // if the TypeAhead is open
+  // we should not allow it
+  return !isOpen;
+};
+export var findHandler = function findHandler(id, state) {
+  var pluginState = typeAheadPluginKey.getState(state);
+  if (!pluginState || !pluginState.typeAheadHandlers || pluginState.typeAheadHandlers.length === 0) {
+    return null;
+  }
+  var typeAheadHandlers = pluginState.typeAheadHandlers;
+  return typeAheadHandlers.find(function (h) {
+    return h.id === id;
+  }) || null;
+};
+export var findHandlerByTrigger = function findHandlerByTrigger(_ref) {
+  var trigger = _ref.trigger,
+    editorState = _ref.editorState;
+  var pluginState = typeAheadPluginKey.getState(editorState);
+  if (!pluginState || !pluginState.typeAheadHandlers || pluginState.typeAheadHandlers.length === 0) {
+    return null;
+  }
+  var typeAheadHandlers = pluginState.typeAheadHandlers;
+  return typeAheadHandlers.find(function (h) {
+    return h.trigger === trigger;
+  }) || null;
+};
+export var moveSelectedIndex = function moveSelectedIndex(_ref2) {
+  var editorView = _ref2.editorView,
+    direction = _ref2.direction;
+  return function () {
+    var typeAheadState = getPluginState(editorView.state);
+    if (!typeAheadState) {
+      return;
+    }
+    var selectedIndex = typeAheadState.selectedIndex,
+      items = typeAheadState.items;
+    var stats = typeAheadState.stats instanceof StatsModifier ? typeAheadState.stats : new StatsModifier();
+    var nextIndex;
+    if (direction === 'next') {
+      stats.increaseArrowDown();
+
+      /**
+       * See: https://product-fabric.atlassian.net/browse/ED-17200
+       * `selectedIndex` is forced to -1 now to not immediately focus the typeahead
+       * and only do so when there is explicit logic to focus into the typeahead
+       * options.
+       *
+       * This check for "set index to 1 when -1"
+       * - is a temporary workaround to get back the previous behaviour without
+       *    entirely reverting the a11y improvements
+       *
+       */
+      if (selectedIndex === -1 && items.length > 1) {
+        nextIndex = 1;
+      } else {
+        nextIndex = selectedIndex >= items.length - 1 ? 0 : selectedIndex + 1;
+      }
+    } else {
+      stats.increaseArrowUp();
+      nextIndex = selectedIndex <= 0 ? items.length - 1 : selectedIndex - 1;
+    }
+    updateSelectedIndex(nextIndex)(editorView.state, editorView.dispatch);
+  };
+};
+export var getTypeAheadListAriaLabels = function getTypeAheadListAriaLabels(trigger, intl, item) {
+  var _item$mention, _item$mention2, _item$emoji, _item$emoji2, _item$emoji3;
+  switch (trigger) {
+    case '@':
+      return {
+        popupAriaLabel: intl.formatMessage(typeAheadListMessages.mentionPopupLabel),
+        listItemAriaLabel: intl.formatMessage(typeAheadListMessages.metionListItemLabel, {
+          name: (item === null || item === void 0 || (_item$mention = item.mention) === null || _item$mention === void 0 ? void 0 : _item$mention.name) || '',
+          shortName: (item === null || item === void 0 || (_item$mention2 = item.mention) === null || _item$mention2 === void 0 ? void 0 : _item$mention2.mentionName) || ''
+        })
+      };
+    case '/':
+      return {
+        popupAriaLabel: intl.formatMessage(typeAheadListMessages.quickInsertPopupLabel),
+        listItemAriaLabel: intl.formatMessage(typeAheadListMessages.emojiListItemLabel, {
+          name: (item === null || item === void 0 ? void 0 : item.title) || '',
+          shortcut: (item === null || item === void 0 || (_item$emoji = item.emoji) === null || _item$emoji === void 0 ? void 0 : _item$emoji.shortName) || ''
+        })
+      };
+    case ':':
+      return {
+        popupAriaLabel: intl.formatMessage(typeAheadListMessages.emojiPopupLabel),
+        listItemAriaLabel: intl.formatMessage(typeAheadListMessages.emojiListItemLabel, {
+          name: (item === null || item === void 0 || (_item$emoji2 = item.emoji) === null || _item$emoji2 === void 0 ? void 0 : _item$emoji2.name) || '',
+          shortcut: (item === null || item === void 0 || (_item$emoji3 = item.emoji) === null || _item$emoji3 === void 0 ? void 0 : _item$emoji3.shortName) || ''
+        })
+      };
+    default:
+      return {
+        popupAriaLabel: intl.formatMessage(typeAheadListMessages.typeAheadPopupLabel)
+      };
+  }
+};

package/dist/types/api.d.ts

@@ -0,0 +1,60 @@
+import type { TypeAheadItem } from '@atlaskit/editor-common/provider-factory';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { Command } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadHandler, TypeAheadInputMethod } from './types';
+type CloseOptions = {
+    insertCurrentQueryAsRawText: boolean;
+    attachCommand?: Command;
+};
+type InsertItemProps = {
+    contentItem: TypeAheadItem;
+    query: string;
+    sourceListItem: TypeAheadItem[];
+};
+/**
+ * Please do not use it. Ping #help-editor and talk to the Lego team before use it.
+ *
+ * @private
+ * @deprecated
+ *
+ */
+export declare const createTypeAheadTools: (editorView: EditorView) => {
+    isOpen: () => TypeAheadHandler | false;
+    currentQuery: () => string | undefined;
+    close: (options?: CloseOptions) => boolean;
+    openMention: (inputMethod: TypeAheadInputMethod) => boolean;
+    searchMention: (query?: string) => {
+        type: (appendValue: string) => Promise<TypeAheadItem[]> | undefined;
+        result: () => Promise<TypeAheadItem[] | undefined>;
+        close: (options?: CloseOptions) => boolean;
+        insert: ({ index, mode }: {
+            index: number;
+            mode?: SelectItemMode | undefined;
+        }) => Promise<void>;
+    };
+    openQuickInsert: (inputMethod: TypeAheadInputMethod) => boolean;
+    searchQuickInsert: (query?: string) => {
+        type: (appendValue: string) => Promise<TypeAheadItem[]> | undefined;
+        result: () => Promise<TypeAheadItem[] | undefined>;
+        close: (options?: CloseOptions) => boolean;
+        insert: ({ index, mode }: {
+            index: number;
+            mode?: SelectItemMode | undefined;
+        }) => Promise<void>;
+    };
+    openEmoji: (inputMethod: TypeAheadInputMethod) => boolean;
+    searchEmoji: (query?: string) => {
+        type: (appendValue: string) => Promise<TypeAheadItem[]> | undefined;
+        result: () => Promise<TypeAheadItem[] | undefined>;
+        close: (options?: CloseOptions) => boolean;
+        insert: ({ index, mode }: {
+            index: number;
+            mode?: SelectItemMode | undefined;
+        }) => Promise<void>;
+    };
+    insertItemMention: ({ contentItem, query, sourceListItem }: InsertItemProps) => boolean;
+    insertItemEmoji: ({ contentItem, query, sourceListItem }: InsertItemProps) => boolean;
+    insertItemQuickInsert: ({ contentItem, query, sourceListItem }: InsertItemProps) => boolean;
+};
+export {};

package/dist/types/commands/insert-type-ahead-item.d.ts

@@ -0,0 +1,12 @@
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadHandler, TypeAheadItem } from '../types';
+type Props = {
+    item: TypeAheadItem;
+    handler: TypeAheadHandler;
+    mode: SelectItemMode;
+    sourceListItem: Array<TypeAheadItem>;
+    query: string;
+};
+export declare const insertTypeAheadItem: (view: EditorView) => ({ item, handler, mode, query, sourceListItem }: Props) => void;
+export {};

package/dist/types/commands/update-list-items.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from '@atlaskit/editor-common/types';
+import type { TypeAheadItem } from '../types';
+export declare const updateListItem: (items: Array<TypeAheadItem>) => Command;

package/dist/types/commands/update-query.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from '@atlaskit/editor-common/types';
+export declare const updateQuery: (query: string) => Command;

package/dist/types/commands/update-selected-index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from '@atlaskit/editor-common/types';
+export declare const updateSelectedIndex: (selectedIndex: number) => Command;

package/dist/types/index.d.ts

@@ -1 +1,2 @@
-export type { TypeAheadPlugin, TypeAheadPluginOptions, TypeAheadInputMethod, } from './types';
+export { typeAheadPlugin } from './plugin';
+export type { TypeAheadHandler, TypeAheadInputMethod, TypeAheadPlugin, TypeAheadPluginOptions, TypeAheadPluginState, } from './types';

package/dist/types/insert-utils.d.ts

@@ -0,0 +1,18 @@
+import { Fragment, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+type Position = {
+    start: number;
+    end: number;
+};
+export declare const insertBlockNode: ({ node, tr, position, }: {
+    node: PMNode;
+    tr: Transaction;
+    position: Position;
+}) => Transaction;
+export declare const insertInlineNodeOrFragment: ({ maybeFragment, tr, position, selectInlineNode, }: {
+    maybeFragment: Fragment | PMNode;
+    tr: Transaction;
+    position: Position;
+    selectInlineNode: boolean;
+}) => Transaction;
+export {};

package/dist/types/messages.d.ts

@@ -0,0 +1,72 @@
+export declare const typeAheadListMessages: {
+    typeAheadPopupLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    quickInsertPopupLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    quickInsertInputLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPopupLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiInputLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    mentionPopupLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    mentionInputLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    metionListItemLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiListItemLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    inputQueryAssistiveLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    searchResultsLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    noSearchResultsLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    descriptionLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    shortcutLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types/plugin.d.ts

@@ -0,0 +1,10 @@
+import type { TypeAheadPlugin } from './types';
+/**
+ *
+ * Revamped typeahead using decorations instead of the `typeAheadQuery` mark
+ *
+ * https://product-fabric.atlassian.net/wiki/spaces/E/pages/2992177582/Technical+TypeAhead+Data+Flow
+ *
+ *
+ */
+export declare const typeAheadPlugin: TypeAheadPlugin;

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

@@ -0,0 +1,9 @@
+export declare enum ACTIONS {
+    OPEN_TYPEAHEAD_AT_CURSOR = "OPEN_TYPEAHEAD_AT_CURSOR",
+    CLOSE_TYPE_AHEAD = "CLOSE_TYPE_AHEAD",
+    CHANGE_QUERY = "CHANGE_QUERY",
+    INSERT_ITEM = "INSERT_ITEM",
+    INSERT_RAW_QUERY = "INSERT_RAW_QUERY",
+    UPDATE_LIST_ITEMS = "UPDATE_LIST_ITEMS",
+    UPDATE_SELECTED_INDEX = "UPDATE_SELECTED_INDEX"
+}

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

@@ -0,0 +1,14 @@
+import type { IntlShape } from 'react-intl-next';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { CreateTypeAheadDecorations, PopupMountPointReference, RemoveTypeAheadDecorations } from '../types';
+type FactoryProps = {
+    intl: IntlShape;
+    popupMountRef: PopupMountPointReference;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+};
+type FactoryReturn = {
+    createDecorations: CreateTypeAheadDecorations;
+    removeDecorations: RemoveTypeAheadDecorations;
+};
+export declare const factoryDecorations: ({ intl, popupMountRef, createAnalyticsEvent, }: FactoryProps) => FactoryReturn;
+export {};

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

@@ -0,0 +1,6 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { TypeAheadHandler } from '../types';
+export declare function inputRulePlugin(schema: Schema, typeAheads: TypeAheadHandler[], featureFlags: FeatureFlags): SafePlugin | undefined;
+export default inputRulePlugin;

package/dist/types/pm-plugins/insert-item-plugin.d.ts

@@ -0,0 +1,2 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare function createPlugin(): SafePlugin;

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

@@ -0,0 +1,3 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { TypeAheadPluginState } from '../types';
+export declare const pluginKey: PluginKey<TypeAheadPluginState>;