@atlaskit/editor-plugin-type-ahead 3.1.9 → 3.1.10

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @atlaskit/editor-plugin-type-ahead
 
+## 3.1.10
+
+### Patch Changes
+
+- [`265c1bf0cefa4`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/265c1bf0cefa4) -
+  Sorted type and interface props to improve Atlaskit docs
+- Updated dependencies
+
 ## 3.1.9
 
 ### Patch Changes

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

@@ -4,8 +4,8 @@ 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;
+    insertCurrentQueryAsRawText: boolean;
 };
 type InsertItemProps = {
     contentItem: TypeAheadItem;

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

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

package/dist/types/pm-plugins/commands/insert-utils.d.ts

@@ -1,18 +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;
+    start: number;
 };
 export declare const insertBlockNode: ({ node, tr, position, }: {
     node: PMNode;
-    tr: Transaction;
     position: Position;
+    tr: Transaction;
 }) => Transaction;
 export declare const insertInlineNodeOrFragment: ({ maybeFragment, tr, position, selectInlineNode, }: {
     maybeFragment: Fragment | PMNode;
-    tr: Transaction;
     position: Position;
     selectInlineNode: boolean;
+    tr: Transaction;
 }) => Transaction;
 export {};

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

@@ -4,10 +4,10 @@ import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import type { TypeAheadPlugin } from '../typeAheadPluginType';
 import type { CreateTypeAheadDecorations, PopupMountPointReference, RemoveTypeAheadDecorations } from '../types';
 type FactoryProps = {
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     intl: IntlShape;
-    popupMountRef: PopupMountPointReference;
     nodeViewPortalProviderAPI: PortalProviderAPI;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    popupMountRef: PopupMountPointReference;
 };
 type FactoryReturn = {
     createDecorations: CreateTypeAheadDecorations;

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

@@ -6,12 +6,12 @@ import { type ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import { type TypeAheadPlugin } from '../typeAheadPluginType';
 import type { PopupMountPointReference, TypeAheadHandler } from '../types';
 type Props = {
-    reactDispatch: Dispatch;
-    popupMountRef: PopupMountPointReference;
-    typeAheadHandlers: Array<TypeAheadHandler>;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     getIntl: () => IntlShape;
     nodeViewPortalProviderAPI: PortalProviderAPI;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    popupMountRef: PopupMountPointReference;
+    reactDispatch: Dispatch;
+    typeAheadHandlers: Array<TypeAheadHandler>;
 };
 export declare function createPlugin({ reactDispatch, popupMountRef, typeAheadHandlers, getIntl, nodeViewPortalProviderAPI, api, }: Props): SafePlugin;
 export {};

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

@@ -2,8 +2,8 @@ import { InsertTypeAheadStep } from '@atlaskit/adf-schema/steps';
 import type { ReadonlyTransaction } from '@atlaskit/editor-prosemirror/state';
 import type { CreateTypeAheadDecorations, PopupMountPointReference, RemoveTypeAheadDecorations, TypeAheadHandler, TypeAheadPluginState } from '../types';
 export type ReducerOptions = {
-    popupMountRef: PopupMountPointReference;
     createDecorations: CreateTypeAheadDecorations;
+    popupMountRef: PopupMountPointReference;
     removeDecorations: RemoveTypeAheadDecorations;
     typeAheadHandlers: Array<TypeAheadHandler>;
 };

package/dist/types/pm-plugins/stats-modifier.d.ts

@@ -3,8 +3,8 @@ export declare class StatsModifier implements TypeAheadStatsModifier {
     startedAt: number;
     endedAt: number;
     keyCount: {
-        arrowUp: number;
         arrowDown: number;
+        arrowUp: number;
     };
     constructor();
     increaseArrowUp: () => void;

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

@@ -14,29 +14,29 @@ export declare const isTypeAheadAllowed: (state: EditorState) => boolean;
 export declare const findHandler: (id: string, state: EditorState) => TypeAheadHandler | null;
 export declare const skipForwardToSafeItem: ({ currentIndex, nextIndex, listSize, itemIsDisabled, }: {
     currentIndex: number;
-    nextIndex: number;
-    listSize: number;
     itemIsDisabled: (idx: number) => boolean;
+    listSize: number;
+    nextIndex: number;
 }) => number;
 export declare const skipBackwardToSafeItem: ({ currentIndex, nextIndex, listSize, itemIsDisabled, }: {
     currentIndex: number;
-    nextIndex: number;
-    listSize: number;
     itemIsDisabled: (idx: number) => boolean;
+    listSize: number;
+    nextIndex: number;
 }) => number;
 export declare const findHandlerByTrigger: ({ trigger, editorState, }: {
-    trigger: string;
     editorState: EditorState;
+    trigger: string;
 }) => TypeAheadHandler | null;
 type MoveSelectedIndexProps = {
-    editorView: EditorView;
-    direction: 'next' | 'previous';
     api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    direction: 'next' | 'previous';
+    editorView: EditorView;
 };
 export declare const moveSelectedIndex: ({ editorView, direction, api }: MoveSelectedIndexProps) => () => void;
 type TypeAheadAssistiveLabels = {
-    popupAriaLabel: string;
     listItemAriaLabel?: string;
+    popupAriaLabel: string;
 };
 export declare const getTypeAheadListAriaLabels: (trigger: string | undefined, intl: IntlShape, item?: TypeAheadItem) => TypeAheadAssistiveLabels;
 export {};

package/dist/types/typeAheadPluginType.d.ts

@@ -8,22 +8,30 @@ import type { MetricsPlugin } from '@atlaskit/editor-plugin-metrics';
 import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
 import { type TypeAheadPluginOptions, type TypeAheadPluginSharedState, type OpenTypeAheadProps } from './types';
 type InsertTypeAheadItemProps = {
-    triggerHandler: TypeAheadHandler;
     contentItem: TypeAheadItem;
+    mode?: SelectItemMode;
     query: string;
     sourceListItem: TypeAheadItem[];
-    mode?: SelectItemMode;
+    triggerHandler: TypeAheadHandler;
 };
 type CloseTypeAheadProps = {
-    insertCurrentQueryAsRawText: boolean;
     attachCommand?: Command;
+    insertCurrentQueryAsRawText: boolean;
 };
 /**
  * Type ahead plugin to be added to an `EditorPresetBuilder` and used with `ComposableEditor`
  * from `@atlaskit/editor-core`.
  */
 export type TypeAheadPlugin = NextEditorPlugin<'typeAhead', {
-    pluginConfiguration: TypeAheadPluginOptions | undefined;
+    actions: {
+        close: (props: CloseTypeAheadProps) => boolean;
+        findHandlerByTrigger: (trigger: string) => TypeAheadHandler | null;
+        insert: (props: InsertTypeAheadItemProps) => boolean;
+        isAllowed: (editorState: EditorState) => boolean;
+        isOpen: (editorState: EditorState) => boolean;
+        open: (props: OpenTypeAheadProps) => boolean;
+        openAtTransaction: (props: OpenTypeAheadProps) => (tr: Transaction) => boolean;
+    };
     dependencies: [
         OptionalPlugin<AnalyticsPlugin>,
         OptionalPlugin<FeatureFlagsPlugin>,
@@ -31,15 +39,7 @@ export type TypeAheadPlugin = NextEditorPlugin<'typeAhead', {
         OptionalPlugin<ContextPanelPlugin>,
         OptionalPlugin<MetricsPlugin>
     ];
+    pluginConfiguration: TypeAheadPluginOptions | undefined;
     sharedState: TypeAheadPluginSharedState;
-    actions: {
-        isOpen: (editorState: EditorState) => boolean;
-        isAllowed: (editorState: EditorState) => boolean;
-        insert: (props: InsertTypeAheadItemProps) => boolean;
-        findHandlerByTrigger: (trigger: string) => TypeAheadHandler | null;
-        open: (props: OpenTypeAheadProps) => boolean;
-        close: (props: CloseTypeAheadProps) => boolean;
-        openAtTransaction: (props: OpenTypeAheadProps) => (tr: Transaction) => boolean;
-    };
 }>;
 export {};

package/dist/types/types/index.d.ts

@@ -17,32 +17,32 @@ export interface TypeAheadStatsSerializable extends TypeAheadStats {
     serialize: () => TypeAheadStats;
 }
 export interface TypeAheadStatsModifier extends TypeAheadStatsSerializable {
-    increaseArrowUp: () => void;
     increaseArrowDown: () => void;
+    increaseArrowUp: () => void;
 }
 export interface TypeAheadStatsMobileModifier extends TypeAheadStatsSerializable {
-    resetTime: () => void;
     closeTime: () => void;
+    resetTime: () => void;
 }
 export type TypeAheadPluginState = {
-    decorationSet: DecorationSet;
     decorationElement: HTMLElement | null;
-    typeAheadHandlers: Array<TypeAheadHandler>;
-    query: string;
-    items: Array<TypeAheadItem>;
+    decorationSet: DecorationSet;
     errorInfo: TypeAheadErrorInfo;
-    triggerHandler?: TypeAheadHandler;
-    selectedIndex: number;
-    stats: TypeAheadStatsSerializable | null;
     inputMethod: TypeAheadInputMethod | null;
+    items: Array<TypeAheadItem>;
+    query: string;
     /**
      * If true, removes the trigger character from query when typeahead is closed
      */
     removePrefixTriggerOnCancel?: boolean;
+    selectedIndex: number;
+    stats: TypeAheadStatsSerializable | null;
+    triggerHandler?: TypeAheadHandler;
+    typeAheadHandlers: Array<TypeAheadHandler>;
 };
 export type OnInsertSelectedItemProps = {
-    mode: SelectItemMode;
     index: number;
+    mode: SelectItemMode;
     query: string;
 };
 export type OnItemMatchProps = {
@@ -61,12 +61,12 @@ export type InsertionTransactionMeta = (editorState: EditorState) => Transaction
 type PopupMountPoints = Pick<UiComponentFactoryParams, 'popupsMountPoint' | 'popupsBoundariesElement' | 'popupsScrollableElement'>;
 export type PopupMountPointReference = Record<'current', PopupMountPoints | null>;
 export type CreateTypeAheadDecorations = (tr: ReadonlyTransaction, options: {
-    triggerHandler: TypeAheadHandler;
     inputMethod: TypeAheadInputMethod;
     reopenQuery?: string;
+    triggerHandler: TypeAheadHandler;
 }) => {
-    decorationSet: DecorationSet;
     decorationElement: HTMLElement | null;
+    decorationSet: DecorationSet;
     stats: TypeAheadStatsSerializable | null;
 };
 export type RemoveTypeAheadDecorations = (decorationSet?: DecorationSet) => boolean;
@@ -80,20 +80,20 @@ export type TypeAheadPluginOptions = {
     isMobile?: boolean;
 };
 export interface TypeAheadPluginSharedState {
-    query: string;
-    isOpen: boolean;
-    isAllowed: boolean;
     currentHandler?: TypeAheadHandler;
-    decorationSet: DecorationSet;
     decorationElement: HTMLElement | null;
-    triggerHandler?: TypeAheadHandler;
-    items: Array<TypeAheadItem>;
+    decorationSet: DecorationSet;
     errorInfo: TypeAheadErrorInfo;
+    isAllowed: boolean;
+    isOpen: boolean;
+    items: Array<TypeAheadItem>;
+    query: string;
     selectedIndex: number;
+    triggerHandler?: TypeAheadHandler;
 }
 export type OpenTypeAheadProps = {
-    triggerHandler: TypeAheadHandler;
     inputMethod: TypeAheadInputMethod;
     query?: string;
     removePrefixTriggerOnCancel?: boolean;
+    triggerHandler: TypeAheadHandler;
 };

package/dist/types/ui/InputQuery.d.ts

@@ -9,23 +9,23 @@ import type { TypeAheadItem } from '@atlaskit/editor-common/types';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import { CloseSelectionOptions } from '../pm-plugins/constants';
 type InputQueryProps = {
-    triggerQueryPrefix: string;
-    onQueryChange: (query: string) => void;
-    onItemSelect: (mode: SelectItemMode) => void;
-    selectNextItem: () => void;
-    selectPreviousItem: () => void;
     cancel: (props: {
+        addPrefixTrigger: boolean;
         forceFocusOnEditor: boolean;
         setSelectionAt: CloseSelectionOptions;
-        addPrefixTrigger: boolean;
         text: string;
     }) => void;
-    onQueryFocus: () => void;
+    editorView: EditorView;
     forceFocus: boolean;
+    items: TypeAheadItem[];
+    onItemSelect: (mode: SelectItemMode) => void;
+    onQueryChange: (query: string) => void;
+    onQueryFocus: () => void;
     onUndoRedo?: (inputType: 'historyUndo' | 'historyRedo') => boolean;
     reopenQuery?: string;
-    editorView: EditorView;
-    items: TypeAheadItem[];
+    selectNextItem: () => void;
+    selectPreviousItem: () => void;
+    triggerQueryPrefix: string;
 };
 export declare const InputQuery: React.MemoExoticComponent<({ triggerQueryPrefix, cancel, onQueryChange, onItemSelect, selectNextItem, selectPreviousItem, forceFocus, reopenQuery, onQueryFocus, onUndoRedo, editorView, items, }: InputQueryProps) => jsx.JSX.Element>;
 export {};

package/dist/types/ui/ListRow.d.ts

@@ -1,10 +1,10 @@
 import React, { type ReactNode, type MouseEventHandler } from 'react';
 import { type ListRowProps } from 'react-virtualized';
 type Props = {
+    children: ReactNode;
     measure: () => void;
-    registerChild?: (element?: Element) => void;
     onMouseMove: MouseEventHandler<HTMLDivElement>;
-    children: ReactNode;
+    registerChild?: (element?: Element) => void;
 } & Pick<ListRowProps, 'index' | 'style' | 'isScrolling' | 'isVisible'>;
 /**
  *

package/dist/types/ui/MoreOptions.d.ts

@@ -1,10 +1,10 @@
 import { jsx } from '@emotion/react';
 type Props = {
-    onClick: () => void;
-    isFocused: boolean;
-    title: string;
     ariaLabel?: string;
     iconBefore?: React.ReactNode;
+    isFocused: boolean;
+    onClick: () => void;
+    title: string;
 };
 export declare const MoreOptions: ({ onClick, isFocused, title, ariaLabel, iconBefore }: Props) => jsx.JSX.Element;
 export {};

package/dist/types/ui/TypeAheadErrorFallback/EmptyState.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
 type EmptyStateProps = {
-    header: string;
-    testId?: string;
     description?: React.ReactNode;
+    header: string;
     renderImage?: () => React.ReactNode;
+    testId?: string;
 };
 export declare const EmptyState: ({ testId, header, description, renderImage }: EmptyStateProps) => React.JSX.Element;
 export {};

package/dist/types/ui/TypeAheadList.d.ts

@@ -11,29 +11,29 @@ import { type InputMethodType } from '../pm-plugins/analytics';
 import { type TypeAheadPlugin } from '../typeAheadPluginType';
 import type { TypeAheadHandler } from '../types';
 export declare const TypeAheadList: React.FC<import("react-intl-next").WithIntlProps<{
-    items: Array<TypeAheadItem>;
-    selectedIndex: number;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    decorationElement: HTMLElement;
     editorView: EditorView;
-    onItemClick: (mode: SelectItemMode, index: number, inputMethod?: InputMethodType) => void;
     fitHeight: number;
-    decorationElement: HTMLElement;
-    triggerHandler?: TypeAheadHandler;
+    items: Array<TypeAheadItem>;
     moreElementsInQuickInsertViewEnabled?: boolean;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
-    showMoreOptionsButton?: boolean;
+    onItemClick: (mode: SelectItemMode, index: number, inputMethod?: InputMethodType) => void;
     onMoreOptionsClicked?: () => void;
+    selectedIndex: number;
+    showMoreOptionsButton?: boolean;
+    triggerHandler?: TypeAheadHandler;
 } & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<{
-        items: Array<TypeAheadItem>;
-        selectedIndex: number;
+        api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+        decorationElement: HTMLElement;
         editorView: EditorView;
-        onItemClick: (mode: SelectItemMode, index: number, inputMethod?: InputMethodType) => void;
         fitHeight: number;
-        decorationElement: HTMLElement;
-        triggerHandler?: TypeAheadHandler;
+        items: Array<TypeAheadItem>;
         moreElementsInQuickInsertViewEnabled?: boolean;
-        api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
-        showMoreOptionsButton?: boolean;
+        onItemClick: (mode: SelectItemMode, index: number, inputMethod?: InputMethodType) => void;
         onMoreOptionsClicked?: () => void;
+        selectedIndex: number;
+        showMoreOptionsButton?: boolean;
+        triggerHandler?: TypeAheadHandler;
     } & WrappedComponentProps>;
 };

package/dist/types/ui/TypeAheadListItem.d.ts

@@ -9,15 +9,15 @@ import { type ExtractInjectionAPI, type TypeAheadItem } from '@atlaskit/editor-c
 import { type TypeAheadPlugin } from '../typeAheadPluginType';
 export declare const itemIcon: import("@emotion/react").SerializedStyles;
 type TypeAheadListItemProps = {
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    ariaLabel?: string;
+    firstOnlineSupportedIndex: number;
     item: TypeAheadItem;
-    itemsLength: number;
     itemIndex: number;
-    selectedIndex: number;
-    ariaLabel?: string;
-    onItemClick: (mode: SelectItemMode, index: number) => void;
+    itemsLength: number;
     moreElementsInQuickInsertViewEnabled?: boolean;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
-    firstOnlineSupportedIndex: number;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+    selectedIndex: number;
 };
 export declare const TypeAheadListItem: React.MemoExoticComponent<({ item, itemsLength, selectedIndex, onItemClick, itemIndex, ariaLabel, moreElementsInQuickInsertViewEnabled, api, firstOnlineSupportedIndex, }: TypeAheadListItemProps) => jsx.JSX.Element>;
 export {};

package/dist/types/ui/TypeAheadMenu.d.ts

@@ -4,11 +4,11 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { TypeAheadPlugin } from '../typeAheadPluginType';
 import type { PopupMountPointReference, TypeAheadPluginSharedState } from '../types';
 type TypeAheadMenuType = {
-    typeAheadState: Omit<TypeAheadPluginSharedState, 'isOpen' | 'isAllowed' | 'selectedIndex'>;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     editorView: EditorView;
     popupMountRef: PopupMountPointReference;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     selectedIndex: number;
+    typeAheadState: Omit<TypeAheadPluginSharedState, 'isOpen' | 'isAllowed' | 'selectedIndex'>;
 };
 export declare const TypeAheadMenu: React.MemoExoticComponent<({ editorView, popupMountRef, typeAheadState, selectedIndex, api }: TypeAheadMenuType) => React.JSX.Element | null>;
 export {};

package/dist/types/ui/TypeAheadPopup.d.ts

@@ -11,26 +11,26 @@ import { CloseSelectionOptions } from '../pm-plugins/constants';
 import type { TypeAheadPlugin } from '../typeAheadPluginType';
 import type { OnSelectItem, TypeAheadErrorInfo } from '../types';
 type TypeAheadPopupProps = {
-    triggerHandler: TypeAheadHandler;
-    editorView: EditorView;
     anchorElement: HTMLElement;
-    popupsMountPoint?: HTMLElement;
-    popupsBoundariesElement?: HTMLElement;
-    popupsScrollableElement?: HTMLElement;
-    items: Array<TypeAheadItem>;
-    errorInfo: TypeAheadErrorInfo;
-    selectedIndex: number;
-    setSelectedItem: OnSelectItem;
-    decorationSet: DecorationSet;
-    isEmptyQuery: boolean;
-    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     cancel: (params: {
-        setSelectionAt: CloseSelectionOptions;
         addPrefixTrigger: boolean;
         forceFocusOnEditor: boolean;
+        setSelectionAt: CloseSelectionOptions;
     }) => void;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    decorationSet: DecorationSet;
+    editorView: EditorView;
+    errorInfo: TypeAheadErrorInfo;
+    isEmptyQuery: boolean;
+    items: Array<TypeAheadItem>;
+    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    selectedIndex: number;
+    setSelectedItem: OnSelectItem;
     showMoreOptionsButton?: boolean;
+    triggerHandler: TypeAheadHandler;
 };
 export declare const TypeAheadPopup: React.MemoExoticComponent<(props: TypeAheadPopupProps) => jsx.JSX.Element>;
 export {};

package/dist/types/ui/WrapperTypeAhead.d.ts

@@ -4,18 +4,18 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { TypeAheadPlugin } from '../typeAheadPluginType';
 import type { TypeAheadHandler, TypeAheadInputMethod } from '../types';
 type WrapperProps = {
-    triggerHandler: TypeAheadHandler;
-    editorView: EditorView;
     anchorElement: HTMLElement;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    editorView: EditorView;
     getDecorationPosition: () => number | undefined;
-    shouldFocusCursorInsideQuery: boolean;
+    inputMethod?: TypeAheadInputMethod;
     onUndoRedo?: (inputType: 'historyUndo' | 'historyRedo') => boolean;
-    reopenQuery?: string;
-    popupsMountPoint?: HTMLElement;
     popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
     popupsScrollableElement?: HTMLElement;
-    inputMethod?: TypeAheadInputMethod;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    reopenQuery?: string;
+    shouldFocusCursorInsideQuery: boolean;
+    triggerHandler: TypeAheadHandler;
 };
 export declare const WrapperTypeAhead: React.MemoExoticComponent<({ triggerHandler, editorView, anchorElement, shouldFocusCursorInsideQuery, popupsMountPoint, popupsBoundariesElement, popupsScrollableElement, inputMethod, getDecorationPosition, reopenQuery, onUndoRedo, api, }: WrapperProps) => React.JSX.Element | null>;
 export {};

package/dist/types/ui/hooks/use-on-force-select.d.ts

@@ -1,11 +1,11 @@
 import type { TypeAheadHandler, TypeAheadItem } from '@atlaskit/editor-common/types';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 type Props = {
-    triggerHandler: TypeAheadHandler;
+    closePopup: () => void;
+    editorView: EditorView;
     items: Array<TypeAheadItem>;
     query: string;
-    editorView: EditorView;
-    closePopup: () => void;
+    triggerHandler: TypeAheadHandler;
 };
 export declare const useOnForceSelect: ({ triggerHandler, items, query, editorView, closePopup, }: Props) => void;
 export {};

package/dist/types/ui/modern/TypeAheadMenu.d.ts

@@ -4,10 +4,10 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { TypeAheadPlugin } from '../../typeAheadPluginType';
 import type { PopupMountPointReference, TypeAheadPluginSharedState } from '../../types';
 type TypeAheadMenuType = {
-    typeAheadState: Omit<TypeAheadPluginSharedState, 'isOpen' | 'isAllowed' | 'selectedIndex'>;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     editorView: EditorView;
     popupMountRef: PopupMountPointReference;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    typeAheadState: Omit<TypeAheadPluginSharedState, 'isOpen' | 'isAllowed' | 'selectedIndex'>;
 };
 export declare const TypeAheadMenu: React.MemoExoticComponent<({ editorView, popupMountRef, typeAheadState, api }: TypeAheadMenuType) => React.JSX.Element | null>;
 export {};

package/dist/types/ui/modern/TypeAheadPopup.d.ts

@@ -11,27 +11,27 @@ import { CloseSelectionOptions } from '../../pm-plugins/constants';
 import type { TypeAheadPlugin } from '../../typeAheadPluginType';
 import type { TypeAheadErrorInfo } from '../../types';
 type TypeAheadPopupProps = {
-    triggerHandler: TypeAheadHandler;
-    editorView: EditorView;
     anchorElement: HTMLElement;
-    popupsMountPoint?: HTMLElement;
-    popupsBoundariesElement?: HTMLElement;
-    popupsScrollableElement?: HTMLElement;
-    items: Array<TypeAheadItem>;
-    errorInfo: TypeAheadErrorInfo;
-    decorationSet: DecorationSet;
-    isEmptyQuery: boolean;
-    query: string;
-    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     cancel: (params: {
-        setSelectionAt: CloseSelectionOptions;
         addPrefixTrigger: boolean;
         forceFocusOnEditor: boolean;
+        setSelectionAt: CloseSelectionOptions;
     }) => void;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    decorationSet: DecorationSet;
+    editorView: EditorView;
+    errorInfo: TypeAheadErrorInfo;
+    isEmptyQuery: boolean;
+    items: Array<TypeAheadItem>;
+    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    query: string;
     setSelectedItem?: (props: {
         index: number;
     }) => void;
+    triggerHandler: TypeAheadHandler;
 };
 export declare const TypeAheadPopup: React.MemoExoticComponent<(props: TypeAheadPopupProps) => jsx.JSX.Element>;
 export {};

package/dist/types-ts4.5/pm-plugins/api.d.ts

@@ -4,8 +4,8 @@ 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;
+    insertCurrentQueryAsRawText: boolean;
 };
 type InsertItemProps = {
     contentItem: TypeAheadItem;

package/dist/types-ts4.5/pm-plugins/commands/insert-type-ahead-item.d.ts

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

package/dist/types-ts4.5/pm-plugins/commands/insert-utils.d.ts

@@ -1,18 +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;
+    start: number;
 };
 export declare const insertBlockNode: ({ node, tr, position, }: {
     node: PMNode;
-    tr: Transaction;
     position: Position;
+    tr: Transaction;
 }) => Transaction;
 export declare const insertInlineNodeOrFragment: ({ maybeFragment, tr, position, selectInlineNode, }: {
     maybeFragment: Fragment | PMNode;
-    tr: Transaction;
     position: Position;
     selectInlineNode: boolean;
+    tr: Transaction;
 }) => Transaction;
 export {};

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

@@ -4,10 +4,10 @@ import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import type { TypeAheadPlugin } from '../typeAheadPluginType';
 import type { CreateTypeAheadDecorations, PopupMountPointReference, RemoveTypeAheadDecorations } from '../types';
 type FactoryProps = {
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     intl: IntlShape;
-    popupMountRef: PopupMountPointReference;
     nodeViewPortalProviderAPI: PortalProviderAPI;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    popupMountRef: PopupMountPointReference;
 };
 type FactoryReturn = {
     createDecorations: CreateTypeAheadDecorations;

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

@@ -6,12 +6,12 @@ import { type ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import { type TypeAheadPlugin } from '../typeAheadPluginType';
 import type { PopupMountPointReference, TypeAheadHandler } from '../types';
 type Props = {
-    reactDispatch: Dispatch;
-    popupMountRef: PopupMountPointReference;
-    typeAheadHandlers: Array<TypeAheadHandler>;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     getIntl: () => IntlShape;
     nodeViewPortalProviderAPI: PortalProviderAPI;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    popupMountRef: PopupMountPointReference;
+    reactDispatch: Dispatch;
+    typeAheadHandlers: Array<TypeAheadHandler>;
 };
 export declare function createPlugin({ reactDispatch, popupMountRef, typeAheadHandlers, getIntl, nodeViewPortalProviderAPI, api, }: Props): SafePlugin;
 export {};

package/dist/types-ts4.5/pm-plugins/reducer.d.ts

@@ -2,8 +2,8 @@ import { InsertTypeAheadStep } from '@atlaskit/adf-schema/steps';
 import type { ReadonlyTransaction } from '@atlaskit/editor-prosemirror/state';
 import type { CreateTypeAheadDecorations, PopupMountPointReference, RemoveTypeAheadDecorations, TypeAheadHandler, TypeAheadPluginState } from '../types';
 export type ReducerOptions = {
-    popupMountRef: PopupMountPointReference;
     createDecorations: CreateTypeAheadDecorations;
+    popupMountRef: PopupMountPointReference;
     removeDecorations: RemoveTypeAheadDecorations;
     typeAheadHandlers: Array<TypeAheadHandler>;
 };

package/dist/types-ts4.5/pm-plugins/stats-modifier.d.ts

@@ -3,8 +3,8 @@ export declare class StatsModifier implements TypeAheadStatsModifier {
     startedAt: number;
     endedAt: number;
     keyCount: {
-        arrowUp: number;
         arrowDown: number;
+        arrowUp: number;
     };
     constructor();
     increaseArrowUp: () => void;

package/dist/types-ts4.5/pm-plugins/utils.d.ts

@@ -14,29 +14,29 @@ export declare const isTypeAheadAllowed: (state: EditorState) => boolean;
 export declare const findHandler: (id: string, state: EditorState) => TypeAheadHandler | null;
 export declare const skipForwardToSafeItem: ({ currentIndex, nextIndex, listSize, itemIsDisabled, }: {
     currentIndex: number;
-    nextIndex: number;
-    listSize: number;
     itemIsDisabled: (idx: number) => boolean;
+    listSize: number;
+    nextIndex: number;
 }) => number;
 export declare const skipBackwardToSafeItem: ({ currentIndex, nextIndex, listSize, itemIsDisabled, }: {
     currentIndex: number;
-    nextIndex: number;
-    listSize: number;
     itemIsDisabled: (idx: number) => boolean;
+    listSize: number;
+    nextIndex: number;
 }) => number;
 export declare const findHandlerByTrigger: ({ trigger, editorState, }: {
-    trigger: string;
     editorState: EditorState;
+    trigger: string;
 }) => TypeAheadHandler | null;
 type MoveSelectedIndexProps = {
-    editorView: EditorView;
-    direction: 'next' | 'previous';
     api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    direction: 'next' | 'previous';
+    editorView: EditorView;
 };
 export declare const moveSelectedIndex: ({ editorView, direction, api }: MoveSelectedIndexProps) => () => void;
 type TypeAheadAssistiveLabels = {
-    popupAriaLabel: string;
     listItemAriaLabel?: string;
+    popupAriaLabel: string;
 };
 export declare const getTypeAheadListAriaLabels: (trigger: string | undefined, intl: IntlShape, item?: TypeAheadItem) => TypeAheadAssistiveLabels;
 export {};

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

@@ -8,22 +8,30 @@ import type { MetricsPlugin } from '@atlaskit/editor-plugin-metrics';
 import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
 import { type TypeAheadPluginOptions, type TypeAheadPluginSharedState, type OpenTypeAheadProps } from './types';
 type InsertTypeAheadItemProps = {
-    triggerHandler: TypeAheadHandler;
     contentItem: TypeAheadItem;
+    mode?: SelectItemMode;
     query: string;
     sourceListItem: TypeAheadItem[];
-    mode?: SelectItemMode;
+    triggerHandler: TypeAheadHandler;
 };
 type CloseTypeAheadProps = {
-    insertCurrentQueryAsRawText: boolean;
     attachCommand?: Command;
+    insertCurrentQueryAsRawText: boolean;
 };
 /**
  * Type ahead plugin to be added to an `EditorPresetBuilder` and used with `ComposableEditor`
  * from `@atlaskit/editor-core`.
  */
 export type TypeAheadPlugin = NextEditorPlugin<'typeAhead', {
-    pluginConfiguration: TypeAheadPluginOptions | undefined;
+    actions: {
+        close: (props: CloseTypeAheadProps) => boolean;
+        findHandlerByTrigger: (trigger: string) => TypeAheadHandler | null;
+        insert: (props: InsertTypeAheadItemProps) => boolean;
+        isAllowed: (editorState: EditorState) => boolean;
+        isOpen: (editorState: EditorState) => boolean;
+        open: (props: OpenTypeAheadProps) => boolean;
+        openAtTransaction: (props: OpenTypeAheadProps) => (tr: Transaction) => boolean;
+    };
     dependencies: [
         OptionalPlugin<AnalyticsPlugin>,
         OptionalPlugin<FeatureFlagsPlugin>,
@@ -31,15 +39,7 @@ export type TypeAheadPlugin = NextEditorPlugin<'typeAhead', {
         OptionalPlugin<ContextPanelPlugin>,
         OptionalPlugin<MetricsPlugin>
     ];
+    pluginConfiguration: TypeAheadPluginOptions | undefined;
     sharedState: TypeAheadPluginSharedState;
-    actions: {
-        isOpen: (editorState: EditorState) => boolean;
-        isAllowed: (editorState: EditorState) => boolean;
-        insert: (props: InsertTypeAheadItemProps) => boolean;
-        findHandlerByTrigger: (trigger: string) => TypeAheadHandler | null;
-        open: (props: OpenTypeAheadProps) => boolean;
-        close: (props: CloseTypeAheadProps) => boolean;
-        openAtTransaction: (props: OpenTypeAheadProps) => (tr: Transaction) => boolean;
-    };
 }>;
 export {};

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

@@ -17,32 +17,32 @@ export interface TypeAheadStatsSerializable extends TypeAheadStats {
     serialize: () => TypeAheadStats;
 }
 export interface TypeAheadStatsModifier extends TypeAheadStatsSerializable {
-    increaseArrowUp: () => void;
     increaseArrowDown: () => void;
+    increaseArrowUp: () => void;
 }
 export interface TypeAheadStatsMobileModifier extends TypeAheadStatsSerializable {
-    resetTime: () => void;
     closeTime: () => void;
+    resetTime: () => void;
 }
 export type TypeAheadPluginState = {
-    decorationSet: DecorationSet;
     decorationElement: HTMLElement | null;
-    typeAheadHandlers: Array<TypeAheadHandler>;
-    query: string;
-    items: Array<TypeAheadItem>;
+    decorationSet: DecorationSet;
     errorInfo: TypeAheadErrorInfo;
-    triggerHandler?: TypeAheadHandler;
-    selectedIndex: number;
-    stats: TypeAheadStatsSerializable | null;
     inputMethod: TypeAheadInputMethod | null;
+    items: Array<TypeAheadItem>;
+    query: string;
     /**
      * If true, removes the trigger character from query when typeahead is closed
      */
     removePrefixTriggerOnCancel?: boolean;
+    selectedIndex: number;
+    stats: TypeAheadStatsSerializable | null;
+    triggerHandler?: TypeAheadHandler;
+    typeAheadHandlers: Array<TypeAheadHandler>;
 };
 export type OnInsertSelectedItemProps = {
-    mode: SelectItemMode;
     index: number;
+    mode: SelectItemMode;
     query: string;
 };
 export type OnItemMatchProps = {
@@ -61,12 +61,12 @@ export type InsertionTransactionMeta = (editorState: EditorState) => Transaction
 type PopupMountPoints = Pick<UiComponentFactoryParams, 'popupsMountPoint' | 'popupsBoundariesElement' | 'popupsScrollableElement'>;
 export type PopupMountPointReference = Record<'current', PopupMountPoints | null>;
 export type CreateTypeAheadDecorations = (tr: ReadonlyTransaction, options: {
-    triggerHandler: TypeAheadHandler;
     inputMethod: TypeAheadInputMethod;
     reopenQuery?: string;
+    triggerHandler: TypeAheadHandler;
 }) => {
-    decorationSet: DecorationSet;
     decorationElement: HTMLElement | null;
+    decorationSet: DecorationSet;
     stats: TypeAheadStatsSerializable | null;
 };
 export type RemoveTypeAheadDecorations = (decorationSet?: DecorationSet) => boolean;
@@ -80,20 +80,20 @@ export type TypeAheadPluginOptions = {
     isMobile?: boolean;
 };
 export interface TypeAheadPluginSharedState {
-    query: string;
-    isOpen: boolean;
-    isAllowed: boolean;
     currentHandler?: TypeAheadHandler;
-    decorationSet: DecorationSet;
     decorationElement: HTMLElement | null;
-    triggerHandler?: TypeAheadHandler;
-    items: Array<TypeAheadItem>;
+    decorationSet: DecorationSet;
     errorInfo: TypeAheadErrorInfo;
+    isAllowed: boolean;
+    isOpen: boolean;
+    items: Array<TypeAheadItem>;
+    query: string;
     selectedIndex: number;
+    triggerHandler?: TypeAheadHandler;
 }
 export type OpenTypeAheadProps = {
-    triggerHandler: TypeAheadHandler;
     inputMethod: TypeAheadInputMethod;
     query?: string;
     removePrefixTriggerOnCancel?: boolean;
+    triggerHandler: TypeAheadHandler;
 };

package/dist/types-ts4.5/ui/InputQuery.d.ts

@@ -9,23 +9,23 @@ import type { TypeAheadItem } from '@atlaskit/editor-common/types';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import { CloseSelectionOptions } from '../pm-plugins/constants';
 type InputQueryProps = {
-    triggerQueryPrefix: string;
-    onQueryChange: (query: string) => void;
-    onItemSelect: (mode: SelectItemMode) => void;
-    selectNextItem: () => void;
-    selectPreviousItem: () => void;
     cancel: (props: {
+        addPrefixTrigger: boolean;
         forceFocusOnEditor: boolean;
         setSelectionAt: CloseSelectionOptions;
-        addPrefixTrigger: boolean;
         text: string;
     }) => void;
-    onQueryFocus: () => void;
+    editorView: EditorView;
     forceFocus: boolean;
+    items: TypeAheadItem[];
+    onItemSelect: (mode: SelectItemMode) => void;
+    onQueryChange: (query: string) => void;
+    onQueryFocus: () => void;
     onUndoRedo?: (inputType: 'historyUndo' | 'historyRedo') => boolean;
     reopenQuery?: string;
-    editorView: EditorView;
-    items: TypeAheadItem[];
+    selectNextItem: () => void;
+    selectPreviousItem: () => void;
+    triggerQueryPrefix: string;
 };
 export declare const InputQuery: React.MemoExoticComponent<({ triggerQueryPrefix, cancel, onQueryChange, onItemSelect, selectNextItem, selectPreviousItem, forceFocus, reopenQuery, onQueryFocus, onUndoRedo, editorView, items, }: InputQueryProps) => jsx.JSX.Element>;
 export {};

package/dist/types-ts4.5/ui/ListRow.d.ts

@@ -1,10 +1,10 @@
 import React, { type ReactNode, type MouseEventHandler } from 'react';
 import { type ListRowProps } from 'react-virtualized';
 type Props = {
+    children: ReactNode;
     measure: () => void;
-    registerChild?: (element?: Element) => void;
     onMouseMove: MouseEventHandler<HTMLDivElement>;
-    children: ReactNode;
+    registerChild?: (element?: Element) => void;
 } & Pick<ListRowProps, 'index' | 'style' | 'isScrolling' | 'isVisible'>;
 /**
  *

package/dist/types-ts4.5/ui/MoreOptions.d.ts

@@ -1,10 +1,10 @@
 import { jsx } from '@emotion/react';
 type Props = {
-    onClick: () => void;
-    isFocused: boolean;
-    title: string;
     ariaLabel?: string;
     iconBefore?: React.ReactNode;
+    isFocused: boolean;
+    onClick: () => void;
+    title: string;
 };
 export declare const MoreOptions: ({ onClick, isFocused, title, ariaLabel, iconBefore }: Props) => jsx.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/TypeAheadErrorFallback/EmptyState.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
 type EmptyStateProps = {
-    header: string;
-    testId?: string;
     description?: React.ReactNode;
+    header: string;
     renderImage?: () => React.ReactNode;
+    testId?: string;
 };
 export declare const EmptyState: ({ testId, header, description, renderImage }: EmptyStateProps) => React.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/TypeAheadList.d.ts

@@ -11,29 +11,29 @@ import { type InputMethodType } from '../pm-plugins/analytics';
 import { type TypeAheadPlugin } from '../typeAheadPluginType';
 import type { TypeAheadHandler } from '../types';
 export declare const TypeAheadList: React.FC<import("react-intl-next").WithIntlProps<{
-    items: Array<TypeAheadItem>;
-    selectedIndex: number;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    decorationElement: HTMLElement;
     editorView: EditorView;
-    onItemClick: (mode: SelectItemMode, index: number, inputMethod?: InputMethodType) => void;
     fitHeight: number;
-    decorationElement: HTMLElement;
-    triggerHandler?: TypeAheadHandler;
+    items: Array<TypeAheadItem>;
     moreElementsInQuickInsertViewEnabled?: boolean;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
-    showMoreOptionsButton?: boolean;
+    onItemClick: (mode: SelectItemMode, index: number, inputMethod?: InputMethodType) => void;
     onMoreOptionsClicked?: () => void;
+    selectedIndex: number;
+    showMoreOptionsButton?: boolean;
+    triggerHandler?: TypeAheadHandler;
 } & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<{
-        items: Array<TypeAheadItem>;
-        selectedIndex: number;
+        api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+        decorationElement: HTMLElement;
         editorView: EditorView;
-        onItemClick: (mode: SelectItemMode, index: number, inputMethod?: InputMethodType) => void;
         fitHeight: number;
-        decorationElement: HTMLElement;
-        triggerHandler?: TypeAheadHandler;
+        items: Array<TypeAheadItem>;
         moreElementsInQuickInsertViewEnabled?: boolean;
-        api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
-        showMoreOptionsButton?: boolean;
+        onItemClick: (mode: SelectItemMode, index: number, inputMethod?: InputMethodType) => void;
         onMoreOptionsClicked?: () => void;
+        selectedIndex: number;
+        showMoreOptionsButton?: boolean;
+        triggerHandler?: TypeAheadHandler;
     } & WrappedComponentProps>;
 };

package/dist/types-ts4.5/ui/TypeAheadListItem.d.ts

@@ -9,15 +9,15 @@ import { type ExtractInjectionAPI, type TypeAheadItem } from '@atlaskit/editor-c
 import { type TypeAheadPlugin } from '../typeAheadPluginType';
 export declare const itemIcon: import("@emotion/react").SerializedStyles;
 type TypeAheadListItemProps = {
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    ariaLabel?: string;
+    firstOnlineSupportedIndex: number;
     item: TypeAheadItem;
-    itemsLength: number;
     itemIndex: number;
-    selectedIndex: number;
-    ariaLabel?: string;
-    onItemClick: (mode: SelectItemMode, index: number) => void;
+    itemsLength: number;
     moreElementsInQuickInsertViewEnabled?: boolean;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
-    firstOnlineSupportedIndex: number;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+    selectedIndex: number;
 };
 export declare const TypeAheadListItem: React.MemoExoticComponent<({ item, itemsLength, selectedIndex, onItemClick, itemIndex, ariaLabel, moreElementsInQuickInsertViewEnabled, api, firstOnlineSupportedIndex, }: TypeAheadListItemProps) => jsx.JSX.Element>;
 export {};

package/dist/types-ts4.5/ui/TypeAheadMenu.d.ts

@@ -4,11 +4,11 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { TypeAheadPlugin } from '../typeAheadPluginType';
 import type { PopupMountPointReference, TypeAheadPluginSharedState } from '../types';
 type TypeAheadMenuType = {
-    typeAheadState: Omit<TypeAheadPluginSharedState, 'isOpen' | 'isAllowed' | 'selectedIndex'>;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     editorView: EditorView;
     popupMountRef: PopupMountPointReference;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     selectedIndex: number;
+    typeAheadState: Omit<TypeAheadPluginSharedState, 'isOpen' | 'isAllowed' | 'selectedIndex'>;
 };
 export declare const TypeAheadMenu: React.MemoExoticComponent<({ editorView, popupMountRef, typeAheadState, selectedIndex, api }: TypeAheadMenuType) => React.JSX.Element | null>;
 export {};

package/dist/types-ts4.5/ui/TypeAheadPopup.d.ts

@@ -11,26 +11,26 @@ import { CloseSelectionOptions } from '../pm-plugins/constants';
 import type { TypeAheadPlugin } from '../typeAheadPluginType';
 import type { OnSelectItem, TypeAheadErrorInfo } from '../types';
 type TypeAheadPopupProps = {
-    triggerHandler: TypeAheadHandler;
-    editorView: EditorView;
     anchorElement: HTMLElement;
-    popupsMountPoint?: HTMLElement;
-    popupsBoundariesElement?: HTMLElement;
-    popupsScrollableElement?: HTMLElement;
-    items: Array<TypeAheadItem>;
-    errorInfo: TypeAheadErrorInfo;
-    selectedIndex: number;
-    setSelectedItem: OnSelectItem;
-    decorationSet: DecorationSet;
-    isEmptyQuery: boolean;
-    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     cancel: (params: {
-        setSelectionAt: CloseSelectionOptions;
         addPrefixTrigger: boolean;
         forceFocusOnEditor: boolean;
+        setSelectionAt: CloseSelectionOptions;
     }) => void;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    decorationSet: DecorationSet;
+    editorView: EditorView;
+    errorInfo: TypeAheadErrorInfo;
+    isEmptyQuery: boolean;
+    items: Array<TypeAheadItem>;
+    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    selectedIndex: number;
+    setSelectedItem: OnSelectItem;
     showMoreOptionsButton?: boolean;
+    triggerHandler: TypeAheadHandler;
 };
 export declare const TypeAheadPopup: React.MemoExoticComponent<(props: TypeAheadPopupProps) => jsx.JSX.Element>;
 export {};

package/dist/types-ts4.5/ui/WrapperTypeAhead.d.ts

@@ -4,18 +4,18 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { TypeAheadPlugin } from '../typeAheadPluginType';
 import type { TypeAheadHandler, TypeAheadInputMethod } from '../types';
 type WrapperProps = {
-    triggerHandler: TypeAheadHandler;
-    editorView: EditorView;
     anchorElement: HTMLElement;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    editorView: EditorView;
     getDecorationPosition: () => number | undefined;
-    shouldFocusCursorInsideQuery: boolean;
+    inputMethod?: TypeAheadInputMethod;
     onUndoRedo?: (inputType: 'historyUndo' | 'historyRedo') => boolean;
-    reopenQuery?: string;
-    popupsMountPoint?: HTMLElement;
     popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
     popupsScrollableElement?: HTMLElement;
-    inputMethod?: TypeAheadInputMethod;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    reopenQuery?: string;
+    shouldFocusCursorInsideQuery: boolean;
+    triggerHandler: TypeAheadHandler;
 };
 export declare const WrapperTypeAhead: React.MemoExoticComponent<({ triggerHandler, editorView, anchorElement, shouldFocusCursorInsideQuery, popupsMountPoint, popupsBoundariesElement, popupsScrollableElement, inputMethod, getDecorationPosition, reopenQuery, onUndoRedo, api, }: WrapperProps) => React.JSX.Element | null>;
 export {};

package/dist/types-ts4.5/ui/hooks/use-on-force-select.d.ts

@@ -1,11 +1,11 @@
 import type { TypeAheadHandler, TypeAheadItem } from '@atlaskit/editor-common/types';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 type Props = {
-    triggerHandler: TypeAheadHandler;
+    closePopup: () => void;
+    editorView: EditorView;
     items: Array<TypeAheadItem>;
     query: string;
-    editorView: EditorView;
-    closePopup: () => void;
+    triggerHandler: TypeAheadHandler;
 };
 export declare const useOnForceSelect: ({ triggerHandler, items, query, editorView, closePopup, }: Props) => void;
 export {};

package/dist/types-ts4.5/ui/modern/TypeAheadMenu.d.ts

@@ -4,10 +4,10 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { TypeAheadPlugin } from '../../typeAheadPluginType';
 import type { PopupMountPointReference, TypeAheadPluginSharedState } from '../../types';
 type TypeAheadMenuType = {
-    typeAheadState: Omit<TypeAheadPluginSharedState, 'isOpen' | 'isAllowed' | 'selectedIndex'>;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     editorView: EditorView;
     popupMountRef: PopupMountPointReference;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    typeAheadState: Omit<TypeAheadPluginSharedState, 'isOpen' | 'isAllowed' | 'selectedIndex'>;
 };
 export declare const TypeAheadMenu: React.MemoExoticComponent<({ editorView, popupMountRef, typeAheadState, api }: TypeAheadMenuType) => React.JSX.Element | null>;
 export {};

package/dist/types-ts4.5/ui/modern/TypeAheadPopup.d.ts

@@ -11,27 +11,27 @@ import { CloseSelectionOptions } from '../../pm-plugins/constants';
 import type { TypeAheadPlugin } from '../../typeAheadPluginType';
 import type { TypeAheadErrorInfo } from '../../types';
 type TypeAheadPopupProps = {
-    triggerHandler: TypeAheadHandler;
-    editorView: EditorView;
     anchorElement: HTMLElement;
-    popupsMountPoint?: HTMLElement;
-    popupsBoundariesElement?: HTMLElement;
-    popupsScrollableElement?: HTMLElement;
-    items: Array<TypeAheadItem>;
-    errorInfo: TypeAheadErrorInfo;
-    decorationSet: DecorationSet;
-    isEmptyQuery: boolean;
-    query: string;
-    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
     cancel: (params: {
-        setSelectionAt: CloseSelectionOptions;
         addPrefixTrigger: boolean;
         forceFocusOnEditor: boolean;
+        setSelectionAt: CloseSelectionOptions;
     }) => void;
-    api: ExtractInjectionAPI<TypeAheadPlugin> | undefined;
+    decorationSet: DecorationSet;
+    editorView: EditorView;
+    errorInfo: TypeAheadErrorInfo;
+    isEmptyQuery: boolean;
+    items: Array<TypeAheadItem>;
+    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    query: string;
     setSelectedItem?: (props: {
         index: number;
     }) => void;
+    triggerHandler: TypeAheadHandler;
 };
 export declare const TypeAheadPopup: React.MemoExoticComponent<(props: TypeAheadPopupProps) => jsx.JSX.Element>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-type-ahead",
-	"version": "3.1.9",
+	"version": "3.1.10",
 	"description": "Type-ahead plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -47,7 +47,7 @@
 		"@atlaskit/primitives": "^14.11.0",
 		"@atlaskit/prosemirror-input-rules": "^3.4.0",
 		"@atlaskit/theme": "^19.0.0",
-		"@atlaskit/tmp-editor-statsig": "^11.3.0",
+		"@atlaskit/tmp-editor-statsig": "^11.5.0",
 		"@atlaskit/tokens": "^6.0.0",
 		"@babel/runtime": "^7.0.0",
 		"@emotion/react": "^11.7.1",
@@ -58,7 +58,7 @@
 		"w3c-keyname": "^2.1.8"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^107.26.0",
+		"@atlaskit/editor-common": "^107.28.0",
 		"react": "^18.2.0",
 		"react-dom": "^18.2.0",
 		"react-intl-next": "npm:react-intl@^5.18.1"
@@ -66,7 +66,6 @@
 	"devDependencies": {
 		"@af/visual-regression": "workspace:^",
 		"@atlaskit/ssr": "workspace:^",
-		"@atlaskit/visual-regression": "workspace:^",
 		"@testing-library/react": "^13.4.0",
 		"@types/react-virtualized": "^9.18.12",
 		"wait-for-expect": "^1.2.0"