@atlaskit/editor-plugin-type-ahead 0.5.0 → 0.7.0

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

@@ -0,0 +1,14 @@
+import type { IntlShape } from 'react-intl-next';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { PopupMountPointReference, TypeAheadHandler } from '../types';
+type Props = {
+    reactDispatch: Dispatch;
+    popupMountRef: PopupMountPointReference;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    getIntl: () => IntlShape;
+};
+export declare function createPlugin({ reactDispatch, popupMountRef, createAnalyticsEvent, typeAheadHandlers, getIntl, }: Props): SafePlugin;
+export {};

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

@@ -0,0 +1,10 @@
+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;
+    removeDecorations: RemoveTypeAheadDecorations;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+};
+export declare const createReducer: ({ typeAheadHandlers, removeDecorations, createDecorations, }: ReducerOptions) => (tr: ReadonlyTransaction, currentPluginState: TypeAheadPluginState, typeAheadStepOverride: InsertTypeAheadStep | null) => TypeAheadPluginState;

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

@@ -0,0 +1,4 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { InsertionTransactionMeta } from '../types';
+import type { ACTIONS } from './actions';
+export declare const isInsertionTransaction: (transactions: readonly Transaction[], action: ACTIONS) => InsertionTransactionMeta | null;

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

@@ -0,0 +1,20 @@
+import type { TypeAheadStatsModifier } from './types';
+export declare class StatsModifier implements TypeAheadStatsModifier {
+    startedAt: number;
+    endedAt: number;
+    keyCount: {
+        arrowUp: number;
+        arrowDown: number;
+    };
+    constructor();
+    increaseArrowUp: () => void;
+    increaseArrowDown: () => void;
+    serialize: () => {
+        startedAt: number;
+        endedAt: number;
+        keyCount: {
+            arrowUp: number;
+            arrowDown: number;
+        };
+    };
+}

package/dist/types/transforms/close-type-ahead.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const closeTypeAhead: (tr: Transaction) => Transaction;

package/dist/types/transforms/open-typeahead-at-cursor.d.ts

@@ -0,0 +1,11 @@
+import type { EditorCommand } from '@atlaskit/editor-common/types';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { TypeAheadHandler, TypeAheadInputMethod } from '../types';
+type Props = {
+    triggerHandler: TypeAheadHandler;
+    inputMethod: TypeAheadInputMethod;
+    query?: string;
+};
+export declare const openTypeAhead: (props: Props) => (tr: Transaction) => void;
+export declare const openTypeAheadAtCursor: ({ triggerHandler, inputMethod, query }: Props) => EditorCommand;
+export {};

package/dist/types/transforms/set-selection-before-query.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const setSelectionBeforeQuery: (rawText: string) => (tr: Transaction) => void;

package/dist/types/types.d.ts

@@ -1,9 +1,68 @@
 import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 import type { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
 import type { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
-import type { Command, NextEditorPlugin, OptionalPlugin, TypeAheadHandler, TypeAheadItem } from '@atlaskit/editor-common/types';
+import type { Command, NextEditorPlugin, OptionalPlugin, TypeAheadForceSelect, TypeAheadHandler, TypeAheadInsert, TypeAheadItem, TypeAheadItemRenderProps, TypeAheadSelectItem, TypeAheadStats, UiComponentFactoryParams } from '@atlaskit/editor-common/types';
 import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
-import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { EditorState, ReadonlyTransaction, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import type { CloseSelectionOptions } from './constants';
+export type { TypeAheadStats, TypeAheadItemRenderProps, TypeAheadInsert, TypeAheadSelectItem, TypeAheadItem, TypeAheadForceSelect, TypeAheadHandler, };
+export type OnSelectItem = (props: {
+    index: number;
+    item: TypeAheadItem;
+}) => void;
+export interface TypeAheadStatsSerializable extends TypeAheadStats {
+    serialize: () => TypeAheadStats;
+}
+export interface TypeAheadStatsModifier extends TypeAheadStatsSerializable {
+    increaseArrowUp: () => void;
+    increaseArrowDown: () => void;
+}
+export interface TypeAheadStatsMobileModifier extends TypeAheadStatsSerializable {
+    resetTime: () => void;
+    closeTime: () => void;
+}
+export type TypeAheadPluginState = {
+    decorationSet: DecorationSet;
+    decorationElement: HTMLElement | null;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+    query: string;
+    items: Array<TypeAheadItem>;
+    triggerHandler?: TypeAheadHandler;
+    selectedIndex: number;
+    stats: TypeAheadStatsSerializable | null;
+    inputMethod: TypeAheadInputMethod | null;
+};
+export type OnInsertSelectedItemProps = {
+    mode: SelectItemMode;
+    index: number;
+    query: string;
+};
+export type OnItemMatchProps = {
+    mode: SelectItemMode;
+    query: string;
+};
+export type OnInsertSelectedItem = (props: OnInsertSelectedItemProps) => void;
+export type OnItemMatch = (props: OnItemMatchProps) => boolean;
+export type OnTextInsertProps = {
+    forceFocusOnEditor: boolean;
+    setSelectionAt: CloseSelectionOptions;
+    text: string;
+};
+export type OnTextInsert = (props: OnTextInsertProps) => void;
+export type InsertionTransactionMeta = (editorState: EditorState) => Transaction | false;
+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;
+}) => {
+    decorationSet: DecorationSet;
+    decorationElement: HTMLElement | null;
+    stats: TypeAheadStatsSerializable | null;
+};
+export type RemoveTypeAheadDecorations = (decorationSet?: DecorationSet) => boolean;
 export type TypeAheadInputMethod = INPUT_METHOD.INSERT_MENU | INPUT_METHOD.KEYBOARD | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.TOOLBAR;
 export type TypeAheadPluginOptions = {
     isMobile?: boolean;
@@ -34,6 +93,9 @@ export type TypeAheadPlugin = NextEditorPlugin<'typeAhead', {
     dependencies: [OptionalPlugin<AnalyticsPlugin>];
     sharedState: {
         query: string;
+        isOpen: boolean;
+        isAllowed: boolean;
+        currentHandler?: TypeAheadHandler;
     };
     actions: {
         isOpen: (editorState: EditorState) => boolean;
@@ -45,4 +107,3 @@ export type TypeAheadPlugin = NextEditorPlugin<'typeAhead', {
         openAtTransaction: (props: OpenTypeAheadProps) => (tr: Transaction) => boolean;
     };
 }>;
-export {};

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

@@ -0,0 +1,33 @@
+/** @jsx jsx */
+/// <reference types="lodash" />
+import React from 'react';
+import { jsx } from '@emotion/react';
+import debounce from 'lodash/debounce';
+type Cancelable = ReturnType<typeof debounce>;
+type AssistiveTextProps = {
+    assistiveText: string;
+    isInFocus: boolean;
+    id: string;
+    statusDebounceMillis?: number;
+    debounce?: boolean;
+};
+type AssistiveTextState = {
+    bump: boolean;
+    debounced: boolean;
+    silenced: boolean;
+};
+declare class AssistveTextComponent extends React.Component<AssistiveTextProps, AssistiveTextState> {
+    static defaultProps: AssistiveTextProps;
+    debounceStatusUpdate: (() => void) & Cancelable;
+    state: {
+        bump: boolean;
+        debounced: boolean;
+        silenced: boolean;
+    };
+    componentWillMount(): void;
+    componentWillUnmount(): void;
+    componentWillReceiveProps(): void;
+    render(): jsx.JSX.Element;
+}
+export declare const AssistiveText: typeof AssistveTextComponent;
+export {};

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

@@ -0,0 +1,26 @@
+/** @jsx jsx */
+import React from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { CloseSelectionOptions } from '../constants';
+type InputQueryProps = {
+    triggerQueryPrefix: string;
+    onQueryChange: (query: string) => void;
+    onItemSelect: (mode: SelectItemMode) => void;
+    selectNextItem: () => void;
+    selectPreviousItem: () => void;
+    cancel: (props: {
+        forceFocusOnEditor: boolean;
+        setSelectionAt: CloseSelectionOptions;
+        addPrefixTrigger: boolean;
+        text: string;
+    }) => void;
+    onQueryFocus: () => void;
+    forceFocus: boolean;
+    onUndoRedo?: (inputType: 'historyUndo' | 'historyRedo') => boolean;
+    reopenQuery?: string;
+    editorView: EditorView;
+    items: any[];
+};
+export declare const InputQuery: React.FC<InputQueryProps>;
+export {};

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

@@ -0,0 +1,25 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadHandler, TypeAheadItem } from '../types';
+export declare const TypeAheadList: React.FC<import("react-intl-next").WithIntlProps<{
+    items: Array<TypeAheadItem>;
+    selectedIndex: number;
+    editorView: EditorView;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+    fitHeight: number;
+    decorationElement: HTMLElement;
+    triggerHandler?: TypeAheadHandler | undefined;
+} & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<{
+        items: Array<TypeAheadItem>;
+        selectedIndex: number;
+        editorView: EditorView;
+        onItemClick: (mode: SelectItemMode, index: number) => void;
+        fitHeight: number;
+        decorationElement: HTMLElement;
+        triggerHandler?: TypeAheadHandler | undefined;
+    } & WrappedComponentProps<"intl">>;
+};

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

@@ -0,0 +1,18 @@
+/** @jsx jsx */
+import React from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { TypeAheadItem } from '../types';
+export declare const ICON_HEIGHT = 40;
+export declare const ICON_WIDTH = 40;
+export declare const ITEM_PADDING = 12;
+export declare const itemIcon: import("@emotion/react").SerializedStyles;
+type TypeAheadListItemProps = {
+    item: TypeAheadItem;
+    itemsLength: number;
+    itemIndex: number;
+    selectedIndex: number;
+    ariaLabel?: string;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+};
+export declare const TypeAheadListItem: React.FC<TypeAheadListItemProps>;
+export {};

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

@@ -0,0 +1,29 @@
+/** @jsx jsx */
+import React from 'react';
+import type { FireAnalyticsCallback } from '@atlaskit/editor-common/analytics';
+import type { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { DecorationSet, EditorView } from '@atlaskit/editor-prosemirror/view';
+import { CloseSelectionOptions } from '../constants';
+import type { OnSelectItem, TypeAheadHandler, TypeAheadItem } from '../types';
+type TypeAheadPopupProps = {
+    triggerHandler: TypeAheadHandler;
+    editorView: EditorView;
+    anchorElement: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    fireAnalyticsCallback: FireAnalyticsCallback;
+    items: Array<TypeAheadItem>;
+    selectedIndex: number;
+    setSelectedItem: OnSelectItem;
+    decorationSet: DecorationSet;
+    isEmptyQuery: boolean;
+    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    cancel: (params: {
+        setSelectionAt: CloseSelectionOptions;
+        addPrefixTrigger: boolean;
+        forceFocusOnEditor: boolean;
+    }) => void;
+};
+export declare const TypeAheadPopup: React.FC<TypeAheadPopupProps>;
+export {};

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

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadHandler, TypeAheadInputMethod } from '../types';
+type WrapperProps = {
+    triggerHandler: TypeAheadHandler;
+    editorView: EditorView;
+    anchorElement: HTMLElement;
+    getDecorationPosition: () => number | undefined;
+    shouldFocusCursorInsideQuery: boolean;
+    onUndoRedo?: (inputType: 'historyUndo' | 'historyRedo') => boolean;
+    reopenQuery?: string;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    inputMethod?: TypeAheadInputMethod;
+};
+export declare const WrapperTypeAhead: React.FC<WrapperProps>;
+export {};

package/dist/types/ui/hooks/use-item-insert.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { OnInsertSelectedItem, OnItemMatch, OnTextInsert, TypeAheadHandler, TypeAheadItem } from '../../types';
+export declare const useItemInsert: (triggerHandler: TypeAheadHandler, editorView: EditorView, items: Array<TypeAheadItem>) => [OnInsertSelectedItem, OnTextInsert, OnItemMatch];

package/dist/types/ui/hooks/use-load-items.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadHandler, TypeAheadItem } from '../../types';
+export declare const useLoadItems: (triggerHandler: TypeAheadHandler, editorView: EditorView, query: string) => Array<TypeAheadItem>;

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

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

package/dist/types/utils.d.ts

@@ -0,0 +1,27 @@
+import type { IntlShape } from 'react-intl-next';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { TypeAheadHandler, TypeAheadItem } from './types';
+export declare const isTypeAheadHandler: (handler: any) => handler is TypeAheadHandler;
+/** Is a typeahead plugin open? */
+export declare const isTypeAheadOpen: (editorState: EditorState) => boolean;
+export declare const getPluginState: (editorState: EditorState) => import("./types").TypeAheadPluginState | undefined;
+export declare const getTypeAheadHandler: (editorState: EditorState) => TypeAheadHandler | undefined;
+export declare const getTypeAheadQuery: (editorState: EditorState) => string | undefined;
+export declare const isTypeAheadAllowed: (state: EditorState) => boolean;
+export declare const findHandler: (id: string, state: EditorState) => TypeAheadHandler | null;
+export declare const findHandlerByTrigger: ({ trigger, editorState, }: {
+    trigger: string;
+    editorState: EditorState;
+}) => TypeAheadHandler | null;
+type MoveSelectedIndexProps = {
+    editorView: EditorView;
+    direction: 'next' | 'previous';
+};
+export declare const moveSelectedIndex: ({ editorView, direction }: MoveSelectedIndexProps) => () => void;
+type TypeAheadAssistiveLabels = {
+    popupAriaLabel: string;
+    listItemAriaLabel?: string;
+};
+export declare const getTypeAheadListAriaLabels: (trigger: string | undefined, intl: IntlShape, item?: TypeAheadItem) => TypeAheadAssistiveLabels;
+export {};

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

@@ -0,0 +1,61 @@
+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 { TypeAheadInputMethod } from './types';
+import type { TypeAheadHandler } 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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const TYPE_AHEAD_DECORATION_KEY = "typeahead_decoration_key";
+export declare const TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE = "typeaheadDecoration";
+export declare const TYPE_AHEAD_POPUP_CONTENT_CLASS = "fabric-editor-typeahead";
+export declare const TYPE_AHEAD_DECORATION_ELEMENT_ID = "typeahaed_decoration_element_id";
+export declare enum CloseSelectionOptions {
+    BEFORE_TEXT_INSERTED = "BEFORE_TEXT_INSERTED",
+    AFTER_TEXT_INSERTED = "AFTER_TEXT_INSERTED"
+}

package/dist/types-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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>;

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

@@ -0,0 +1,14 @@
+import type { IntlShape } from 'react-intl-next';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { PopupMountPointReference, TypeAheadHandler } from '../types';
+type Props = {
+    reactDispatch: Dispatch;
+    popupMountRef: PopupMountPointReference;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    getIntl: () => IntlShape;
+};
+export declare function createPlugin({ reactDispatch, popupMountRef, createAnalyticsEvent, typeAheadHandlers, getIntl, }: Props): SafePlugin;
+export {};

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

@@ -0,0 +1,10 @@
+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;
+    removeDecorations: RemoveTypeAheadDecorations;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+};
+export declare const createReducer: ({ typeAheadHandlers, removeDecorations, createDecorations, }: ReducerOptions) => (tr: ReadonlyTransaction, currentPluginState: TypeAheadPluginState, typeAheadStepOverride: InsertTypeAheadStep | null) => TypeAheadPluginState;