@atlaskit/editor-core 148.0.0 → 149.0.3

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

@@ -1,32 +1,6 @@
-import { EditorState, PluginKey } from 'prosemirror-state';
-import { MentionDescription, MentionProvider } from '@atlaskit/mention/resource';
-import { ContextIdentifierProvider } from '@atlaskit/editor-common';
-import { Command, EditorPlugin } from '../../types';
-import { TypeAheadItem } from '../type-ahead/types';
-import { MentionPluginOptions, MentionPluginState } from './types';
-export declare const mentionToTypeaheadItem: (mention: MentionDescription) => TypeAheadItem;
-export declare function memoize<ResultFn extends (mention: MentionDescription) => TypeAheadItem>(fn: ResultFn): {
-    call: ResultFn;
-    clear(): void;
-};
+import { EditorPlugin } from '../../types';
+import { MentionPluginOptions } from './types';
+import { mentionPluginKey } from './pm-plugins/key';
+export { mentionPluginKey };
 declare const mentionsPlugin: (options?: MentionPluginOptions | undefined) => EditorPlugin;
 export default mentionsPlugin;
-/**
- * Actions
- */
-export declare const ACTIONS: {
-    SET_PROVIDER: string;
-    SET_RESULTS: string;
-    SET_CONTEXT: string;
-};
-export declare const setProvider: (provider: MentionProvider | undefined) => Command;
-export declare const setResults: (results: MentionDescription[]) => Command;
-export declare const setContext: (context: ContextIdentifierProvider | undefined) => Command;
-/**
- *
- * ProseMirror Plugin
- *
- */
-export declare const mentionPluginKey: PluginKey<MentionPluginState, any>;
-export declare function getMentionPluginState(state: EditorState): MentionPluginState;
-export declare const shouldKeepInviteItem: (query: string, firstQueryWithoutResults: string) => boolean;

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

@@ -0,0 +1,3 @@
+import { PluginKey } from 'prosemirror-state';
+import { MentionPluginState } from '../types';
+export declare const mentionPluginKey: PluginKey<MentionPluginState, any>;

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

@@ -0,0 +1,8 @@
+import { Plugin } from 'prosemirror-state';
+import { ContextIdentifierProvider, ProviderFactory } from '@atlaskit/editor-common';
+import { Dispatch, EventDispatcher } from '../../../event-dispatcher';
+import { PortalProviderAPI } from '../../../ui/PortalProvider';
+import type { Command } from '../../../types';
+import type { MentionPluginOptions, MentionPluginState } from '../types';
+export declare const setContext: (context: ContextIdentifierProvider | undefined) => Command;
+export declare function createMentionPlugin(dispatch: Dispatch, providerFactory: ProviderFactory, portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, fireEvent: (payload: any) => void, options?: MentionPluginOptions): Plugin<MentionPluginState, import("prosemirror-model").Schema<any, any>>;

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

@@ -0,0 +1,3 @@
+import { EditorState } from 'prosemirror-state';
+import { MentionPluginState } from '../types';
+export declare function getMentionPluginState(state: EditorState): MentionPluginState;

package/dist/types/plugins/mentions/type-ahead/index.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { MentionDescription } from '@atlaskit/mention/resource';
+import type { TypeAheadHandler, TypeAheadItem } from '../../type-ahead/types';
+import type { FireElementsChannelEvent } from '../types';
+export declare const mentionToTypeaheadItem: (mention: MentionDescription) => TypeAheadItem;
+export declare function memoize<ResultFn extends (mention: MentionDescription) => TypeAheadItem>(fn: ResultFn): {
+    call: ResultFn;
+    clear(): void;
+};
+declare type Props = {
+    sanitizePrivateContent?: boolean;
+    mentionInsertDisplayName?: boolean;
+    HighlightComponent?: React.ComponentType;
+    fireEvent: FireElementsChannelEvent;
+};
+export declare const createTypeAheadConfig: ({ sanitizePrivateContent, mentionInsertDisplayName, fireEvent, HighlightComponent, }: Props) => TypeAheadHandler;
+export {};

package/dist/types/plugins/mentions/types.d.ts

@@ -3,6 +3,7 @@ import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { MentionDescription, MentionProvider } from '@atlaskit/mention';
 import { TeamMentionProvider } from '@atlaskit/mention/resource';
 import { ContextIdentifierProvider } from '@atlaskit/editor-common';
+import { AnalyticsEventPayload } from '@atlaskit/analytics-next';
 export interface TeamInfoAttrAnalytics {
     teamId: String;
     includesYou: boolean;
@@ -23,3 +24,4 @@ export declare type MentionPluginState = {
     contextIdentifierProvider?: ContextIdentifierProvider;
     mentions?: Array<MentionDescription>;
 };
+export declare type FireElementsChannelEvent = <T extends AnalyticsEventPayload>(payload: T) => void;

package/dist/types/plugins/mentions/ui/InviteItem/index.d.ts

@@ -4,6 +4,7 @@ import { SyntheticEvent } from 'react';
 export interface OnMentionEvent {
     (mention: MentionDescription, event?: SyntheticEvent<any>): void;
 }
+export declare const INVITE_ITEM_MIN_HEIGHT: number;
 export declare const INVITE_ITEM_DESCRIPTION: {
     id: string;
 };

package/dist/types/plugins/mentions/ui/InviteItem/styles.d.ts

@@ -5,7 +5,9 @@ export interface MentionItemStyleProps {
 export interface NameSectionStyleProps {
     restricted?: boolean;
 }
+export declare const ROW_SIDE_PADDING = 14;
 export declare const RowStyle: ComponentClass<HTMLAttributes<{}>>;
+export declare const AVATAR_HEIGHT = 36;
 export declare const AvatarStyle: ComponentClass<HTMLAttributes<{}>>;
 export declare const NameSectionStyle: ComponentClass<HTMLAttributes<{}> & NameSectionStyleProps>;
 export declare const MentionItemStyle: ComponentClass<HTMLAttributes<{}> & MentionItemStyleProps>;

package/dist/types/plugins/mentions/utils.d.ts

@@ -2,3 +2,7 @@ import { MentionDescription } from '@atlaskit/mention';
 export declare const isTeamType: (userType: any) => Boolean;
 export declare const isTeamStats: (stat: any) => Boolean;
 export declare const isInviteItem: (mention: MentionDescription) => Boolean;
+/**
+ * Actions
+ */
+export declare const shouldKeepInviteItem: (query: string, firstQueryWithoutResults: string) => boolean;

package/dist/types/plugins/panel/nodeviews/panel.d.ts

@@ -1,7 +1,8 @@
 import React from 'react';
-import { EditorView, NodeView } from 'prosemirror-view';
+import { Node } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
 import { PanelType, PanelAttributes } from '@atlaskit/adf-schema';
-import { getPosHandler } from '../../../nodeviews/';
+import { getPosHandlerNode, getPosHandler } from '../../../nodeviews/';
 import { ProviderFactory } from '@atlaskit/editor-common';
 import { PanelPluginOptions } from '../types';
 export declare const panelIcons: {
@@ -15,5 +16,20 @@ interface PanelIconAttributes {
     allowCustomPanel?: boolean;
 }
 export declare const PanelIcon: React.FC<PanelIconAttributes>;
-export declare const getPanelNodeView: (pluginOptions: PanelPluginOptions, providerFactory?: ProviderFactory | undefined) => (node: any, view: EditorView, getPos: getPosHandler) => NodeView;
+declare class PanelNodeView {
+    node: Node;
+    dom: HTMLElement;
+    contentDOM: HTMLElement;
+    icon: HTMLElement;
+    getPos: getPosHandlerNode;
+    view: EditorView;
+    providerFactory?: ProviderFactory;
+    pluginOptions: PanelPluginOptions;
+    constructor(node: Node, view: EditorView, getPos: getPosHandlerNode, pluginOptions: PanelPluginOptions, providerFactory?: ProviderFactory);
+    ignoreMutation(mutation: MutationRecord | {
+        type: 'selection';
+        target: Element;
+    }): boolean;
+}
+export declare const getPanelNodeView: (pluginOptions: PanelPluginOptions, providerFactory?: ProviderFactory | undefined) => (node: any, view: EditorView, getPos: getPosHandler) => PanelNodeView;
 export {};

package/dist/types/plugins/paste/pm-plugins/analytics.d.ts

@@ -6,6 +6,8 @@ import { EditorState } from 'prosemirror-state';
 declare type PasteContext = {
     type: PasteType;
     asPlain?: boolean;
+    /** Has the hyperlink been pasted while text is selected, making the text into a link? */
+    hyperlinkPasteOnText?: boolean;
 };
 export declare function getContent(state: EditorState, slice: Slice): PasteContent;
 export declare function createPasteAnalyticsPayload(view: EditorView, event: ClipboardEvent, slice: Slice, pasteContext: PasteContext): AnalyticsEventPayload;

package/dist/types/plugins/quick-insert/api.d.ts

@@ -0,0 +1,6 @@
+import { EditorView } from 'prosemirror-view';
+import { QuickInsertItem } from '@atlaskit/editor-common/provider-factory';
+import type { QuickInsertPluginOptions } from './types';
+export declare const createQuickInsertTools: (editorView: EditorView) => {
+    getItems: (query: string, options?: QuickInsertPluginOptions | undefined) => QuickInsertItem[];
+};

package/dist/types/plugins/quick-insert/assets/custom-panel.d.ts

@@ -0,0 +1 @@
+export default function IconCustomPanel(): JSX.Element;

package/dist/types/plugins/quick-insert/assets/index.d.ts

@@ -19,6 +19,7 @@ export declare const IconPanelNote: (React.ComponentClass<IconProps, any> & Load
 export declare const IconPanelSuccess: (React.ComponentClass<IconProps, any> & Loadable.LoadableComponent) | (React.FunctionComponent<IconProps> & Loadable.LoadableComponent);
 export declare const IconPanelWarning: (React.ComponentClass<IconProps, any> & Loadable.LoadableComponent) | (React.FunctionComponent<IconProps> & Loadable.LoadableComponent);
 export declare const IconPanel: (React.ComponentClass<IconProps, any> & Loadable.LoadableComponent) | (React.FunctionComponent<IconProps> & Loadable.LoadableComponent);
+export declare const IconCustomPanel: (React.ComponentClass<IconProps, any> & Loadable.LoadableComponent) | (React.FunctionComponent<IconProps> & Loadable.LoadableComponent);
 export declare const IconQuote: (React.ComponentClass<IconProps, any> & Loadable.LoadableComponent) | (React.FunctionComponent<IconProps> & Loadable.LoadableComponent);
 export declare const IconStatus: (React.ComponentClass<IconProps, any> & Loadable.LoadableComponent) | (React.FunctionComponent<IconProps> & Loadable.LoadableComponent);
 export declare const IconTable: (React.ComponentClass<IconProps, any> & Loadable.LoadableComponent) | (React.FunctionComponent<IconProps> & Loadable.LoadableComponent);

package/dist/types/plugins/quick-insert/search.d.ts

@@ -1,4 +1,4 @@
-import { QuickInsertItem } from '@atlaskit/editor-common/src/provider-factory/quick-insert-provider';
+import { QuickInsertItem } from '@atlaskit/editor-common/provider-factory';
 import { QuickInsertPluginState, QuickInsertPluginOptions } from './types';
 export declare function find(query: string, items: QuickInsertItem[]): QuickInsertItem[];
 export declare const searchQuickInsertItems: (quickInsertState: QuickInsertPluginState, options?: QuickInsertPluginOptions | undefined) => (query?: string | undefined, category?: string | undefined) => QuickInsertItem[];

package/dist/types/plugins/quick-insert/types.d.ts

@@ -1,5 +1,6 @@
 import { InjectedIntl } from 'react-intl';
 import { QuickInsertItem, QuickInsertProvider } from '@atlaskit/editor-common/provider-factory';
+import { EmptyStateHandler } from '../../types/empty-state-handler';
 export type { QuickInsertActionInsert, QuickInsertItem, QuickInsertProvider, } from '@atlaskit/editor-common/provider-factory';
 export declare type QuickInsertOptions = boolean | {
     provider: Promise<QuickInsertProvider>;
@@ -13,6 +14,7 @@ export declare type QuickInsertPluginState = {
     lazyDefaultItems: () => QuickInsertItem[];
     providedItems?: QuickInsertItem[];
     provider?: QuickInsertProvider;
+    emptyStateHandler?: EmptyStateHandler;
 };
 export declare type QuickInsertPluginStateKeys = keyof QuickInsertPluginState;
 export interface QuickInsertPluginOptions {
@@ -20,4 +22,5 @@ export interface QuickInsertPluginOptions {
     disableDefaultItems?: boolean;
     enableElementBrowser?: boolean;
     elementBrowserHelpUrl?: string;
+    emptyStateHandler?: EmptyStateHandler;
 }

package/dist/types/plugins/status/actions.d.ts

@@ -4,7 +4,9 @@ import { Command } from '../../types';
 import { TOOLBAR_MENU_TYPE } from '../insert-block/ui/ToolbarInsertBlock/types';
 import { StatusType } from './types';
 export declare const DEFAULT_STATUS: StatusType;
-export declare const createStatus: (showStatusPickerAtOffset?: number) => (insert: (node: Node | Object | string) => Transaction, state: EditorState) => Transaction;
+export declare const createStatus: (showStatusPickerAtOffset?: number) => (insert: (node: Node | Object | string, opts: {
+    selectInlineNode: boolean;
+}) => Transaction, state: EditorState) => Transaction;
 export declare const updateStatus: (status?: StatusType | undefined) => Command;
 export declare const updateStatusWithAnalytics: (inputMethod: TOOLBAR_MENU_TYPE, status?: StatusType | undefined) => Command;
 export declare const setStatusPickerAt: (showStatusPickerAt: number | null) => (state: EditorState, dispatch: (tr: Transaction) => void) => boolean;

package/dist/types/plugins/status/ui/statusPicker.d.ts

@@ -46,5 +46,5 @@ export declare class StatusPickerWithoutAnalytcs extends React.Component<Props,
     private onEnter;
     private handlePopupClick;
 }
-declare const _default: React.ForwardRefExoticComponent<Pick<Props, "target" | "onSelect" | "isNew" | "onTextChanged" | "defaultColor" | "closeStatusPicker" | "onEnter" | "defaultText" | "defaultLocalId"> & React.RefAttributes<any>>;
+declare const _default: React.ForwardRefExoticComponent<Pick<Props, "onSelect" | "target" | "isNew" | "onTextChanged" | "defaultColor" | "closeStatusPicker" | "onEnter" | "defaultText" | "defaultLocalId"> & React.RefAttributes<any>>;
 export default _default;

package/dist/types/plugins/type-ahead/api.d.ts

@@ -0,0 +1,53 @@
+import { EditorView } from 'prosemirror-view';
+import type { TypeAheadItem } from '@atlaskit/editor-common/provider-factory';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { TypeAheadHandler, TypeAheadInputMethod } from './types';
+import { Command } from '../../types/command';
+declare type CloseOptions = {
+    insertCurrentQueryAsRawText: boolean;
+    attachCommand?: Command;
+};
+declare type InsertItemProps = {
+    contentItem: TypeAheadItem;
+    query: string;
+    sourceListItem: TypeAheadItem[];
+};
+export declare const createTypeAheadTools: (editorView: EditorView) => {
+    isOpen: () => TypeAheadHandler | false;
+    currentQuery: () => string;
+    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/plugins/type-ahead/commands/insert-type-ahead-item.d.ts

@@ -0,0 +1,12 @@
+import type { EditorView } from 'prosemirror-view';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { TypeAheadHandler, TypeAheadItem } from '../types';
+declare 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/plugins/type-ahead/commands/update-list-items.d.ts

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

package/dist/types/plugins/type-ahead/commands/update-query.d.ts

@@ -1,2 +1,2 @@
-import { Command } from '../../../types';
-export declare const updateQueryCommand: (query: string) => Command;
+import { Command } from '../../../types/command';
+export declare const updateQuery: (query: string) => Command;

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

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

package/dist/types/plugins/type-ahead/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const TYPE_AHEAD_DECORATION_KEY = "typeahead_decoration_key";
+export declare const TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE = "typeaheadDecoration";
+export declare enum NavigationDirection {
+    LEFT = -1,
+    RIGHT = 1
+}
+export declare enum CloseSelectionOptions {
+    BEFORE_TEXT_INSERTED = "BEFORE_TEXT_INSERTED",
+    AFTER_TEXT_INSERTED = "AFTER_TEXT_INSERTED"
+}

package/dist/types/plugins/type-ahead/index.d.ts

@@ -1,10 +1,11 @@
+import { EditorPlugin } from '../../types/editor-plugin';
 import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
-import { EditorPlugin } from '../../types';
-import { pluginKey as typeAheadPluginKey, TypeAheadPluginState } from './pm-plugins/main';
+import { pluginKey as typeAheadPluginKey } from './pm-plugins/key';
 export declare type TypeAheadPluginOptions = {
+    isMobile?: boolean;
     createAnalyticsEvent?: CreateUIAnalyticsEvent;
 };
 declare const typeAheadPlugin: (options?: TypeAheadPluginOptions | undefined) => EditorPlugin;
-export { typeAheadPluginKey };
-export type { TypeAheadPluginState };
 export default typeAheadPlugin;
+export { typeAheadPluginKey };
+export type { TypeAheadHandler, TypeAheadPluginState } from './types';

package/dist/types/plugins/type-ahead/insert-utils.d.ts

@@ -0,0 +1,18 @@
+import { Transaction } from 'prosemirror-state';
+import { Node as PMNode, Fragment } from 'prosemirror-model';
+declare 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/plugins/type-ahead/pm-plugins/actions.d.ts

@@ -1,8 +1,9 @@
-export declare const ACTIONS: {
-    SELECT_PREV: string;
-    SELECT_NEXT: string;
-    SELECT_CURRENT: string;
-    SET_CURRENT_INDEX: string;
-    SET_QUERY: string;
-    ITEMS_LIST_UPDATED: string;
-};
+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/plugins/type-ahead/pm-plugins/decorations.d.ts

@@ -0,0 +1,24 @@
+import { Selection } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { InjectedIntl } from 'react-intl';
+import type { CreateTypeAheadDecorations, RemoveTypeAheadDecorations, PopupMountPointReference } from '../types';
+declare type FactoryProps = {
+    intl: InjectedIntl;
+    popupMountRef: PopupMountPointReference;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+};
+declare type FactoryReturn = {
+    createDecorations: CreateTypeAheadDecorations;
+    removeDecorations: RemoveTypeAheadDecorations;
+};
+export declare const factoryDecorations: ({ intl, popupMountRef, createAnalyticsEvent, }: FactoryProps) => FactoryReturn;
+export declare const isSelectionInsideTypeAhead: ({ decorationSet, selection, }: {
+    decorationSet?: DecorationSet<any> | undefined;
+    selection: Selection;
+}) => boolean;
+export declare const findDecorationElement: ({ selection, decorationSet, }: {
+    selection: Selection;
+    decorationSet?: DecorationSet<any> | undefined;
+}) => HTMLElement | null;
+export {};

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

@@ -2,6 +2,5 @@ import { Schema } from 'prosemirror-model';
 import { Plugin } from 'prosemirror-state';
 import { TypeAheadHandler } from '../types';
 import type { FeatureFlags } from '../../../types/feature-flags';
-export declare let typeAheadInputRulesPluginKey: string;
 export declare function inputRulePlugin(schema: Schema, typeAheads: TypeAheadHandler[], featureFlags: FeatureFlags): Plugin | undefined;
 export default inputRulePlugin;

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

@@ -0,0 +1,2 @@
+import { Plugin } from 'prosemirror-state';
+export declare function createPlugin(): Plugin;

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

@@ -1,41 +1,14 @@
-import { EditorState, Plugin, Transaction } from 'prosemirror-state';
+import { Plugin } from 'prosemirror-state';
+import { EditorReactContext } from '../../../types/editor-react-context';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
 import { Dispatch } from '../../../event-dispatcher';
-import { TypeAheadItem, TypeAheadItemsLoader, TypeAheadHandler, TypeAheadPluginState } from '../types';
-export { pluginKey } from './plugin-key';
-export { ACTIONS } from './actions';
-export type { TypeAheadPluginState } from '../types';
-export declare function createInitialPluginState(prevActiveState?: boolean, isAllowed?: boolean): TypeAheadPluginState;
-export declare function createPlugin(dispatch: Dispatch, reactContext: () => {
-    [key: string]: any;
-}, typeAhead: Array<TypeAheadHandler>): Plugin;
-/**
- *
- * Action Handlers
- *
- */
-export declare type ActionHandlerParams = {
-    dispatch: Dispatch;
-    pluginState: TypeAheadPluginState;
-    tr: Transaction;
-    params?: {
-        currentIndex?: number;
-        query?: string;
-    };
+import type { PopupMountPointReference, TypeAheadHandler } from '../types';
+declare type Props = {
+    reactDispatch: Dispatch;
+    popupMountRef: PopupMountPointReference;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+    reactContext: () => EditorReactContext;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
 };
-export declare function createItemsLoader(promiseOfItems: Promise<Array<TypeAheadItem>>): TypeAheadItemsLoader;
-export declare function defaultActionHandler({ dispatch, reactContext, typeAhead, pluginState, state, tr, }: {
-    dispatch: Dispatch;
-    reactContext: () => {
-        [key: string]: any;
-    };
-    typeAhead: Array<TypeAheadHandler>;
-    pluginState: TypeAheadPluginState;
-    state: EditorState;
-    tr: Transaction;
-}): TypeAheadPluginState;
-export declare function setCurrentItemIndex({ dispatch, pluginState, params, }: ActionHandlerParams): TypeAheadPluginState;
-export declare function updateQueryHandler({ dispatch, pluginState, params, }: ActionHandlerParams): TypeAheadPluginState;
-export declare function selectPrevActionHandler({ dispatch, pluginState, }: ActionHandlerParams): TypeAheadPluginState;
-export declare function selectNextActionHandler({ dispatch, pluginState, }: ActionHandlerParams): TypeAheadPluginState;
-export declare function itemsListUpdatedActionHandler({ dispatch, pluginState, tr, }: ActionHandlerParams): TypeAheadPluginState;
-export declare function selectCurrentActionHandler({ dispatch, }: ActionHandlerParams): TypeAheadPluginState;
+export declare function createPlugin({ reactDispatch, reactContext, popupMountRef, createAnalyticsEvent, typeAheadHandlers, }: Props): Plugin;
+export {};

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

@@ -0,0 +1,10 @@
+import { Transaction } from 'prosemirror-state';
+import { InsertTypeAheadStep } from '@atlaskit/adf-schema/steps';
+import { CreateTypeAheadDecorations, PopupMountPointReference, RemoveTypeAheadDecorations, TypeAheadHandler, TypeAheadPluginState } from '../types';
+export declare type ReducerOptions = {
+    popupMountRef: PopupMountPointReference;
+    createDecorations: CreateTypeAheadDecorations;
+    removeDecorations: RemoveTypeAheadDecorations;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+};
+export declare const createReducer: ({ typeAheadHandlers, removeDecorations, createDecorations, }: ReducerOptions) => (tr: Transaction, currentPluginState: TypeAheadPluginState, typeAheadStepOverride: InsertTypeAheadStep | null) => TypeAheadPluginState;

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

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

package/dist/types/plugins/type-ahead/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/plugins/type-ahead/transforms/close-type-ahead.d.ts

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

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

@@ -0,0 +1,9 @@
+import { Transaction } from 'prosemirror-state';
+import type { TypeAheadHandler, TypeAheadInputMethod } from '../types';
+declare type Props = {
+    triggerHandler: TypeAheadHandler;
+    inputMethod: TypeAheadInputMethod;
+    query?: string;
+};
+export declare const openTypeAheadAtCursor: ({ triggerHandler, inputMethod, query, }: Props) => (tr: Transaction) => Transaction | null;
+export {};

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

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