@atlaskit/editor-core 148.0.0 → 149.0.3

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

@@ -1,46 +1,111 @@
-import { Node } from 'prosemirror-model';
+import { Node as PMNode, Fragment } from 'prosemirror-model';
+import type { DecorationSet } from 'prosemirror-view';
+import type { TypeAheadItem, TypeAheadItemRenderProps } from '@atlaskit/editor-common/provider-factory';
+import { TypeAheadAvailableNodes } from '@atlaskit/editor-common/type-ahead';
 import { EditorState, Transaction } from 'prosemirror-state';
-import { InjectedIntl } from 'react-intl';
-import { TypeAheadItem } from '@atlaskit/editor-common/provider-factory';
-import { Dispatch } from '../../event-dispatcher';
-export type { TypeAheadItem, TypeAheadItemRenderProps, } from '@atlaskit/editor-common/provider-factory';
-export declare type SelectItemMode = 'shift-enter' | 'enter' | 'space' | 'selected' | 'tab';
-export declare type TypeAheadInsert = (node?: Node | Object | string, opts?: {
+import type { INPUT_METHOD } from '../analytics/types/enums';
+import type { TypeAheadPayload } from '../analytics/types/type-ahead';
+import type { CloseSelectionOptions } from './constants';
+import type { UiComponentFactoryParams } from '../../types/ui-components';
+import type { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+export type { TypeAheadItem, TypeAheadItemRenderProps };
+export declare type TypeAheadInsert = (node?: PMNode | Object | string | Fragment, opts?: {
     selectInlineNode?: boolean;
 }) => Transaction;
+export declare type OnSelectItem = (props: {
+    index: number;
+    item: TypeAheadItem;
+}) => void;
+export interface TypeAheadStats {
+    startedAt: number;
+    endedAt: number;
+    keyCount: {
+        arrowUp: number;
+        arrowDown: number;
+    };
+}
+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 declare type TypeAheadSelectItem = (state: EditorState, item: TypeAheadItem, insert: TypeAheadInsert, meta: {
     mode: SelectItemMode;
+    stats: TypeAheadStats;
+    query: string;
+    sourceListItem: Array<TypeAheadItem>;
 }) => Transaction | false;
+declare type TypeAheadForceSelectProps = {
+    query: string;
+    items: Array<TypeAheadItem>;
+    editorState: EditorState;
+};
+export declare type TypeAheadForceSelect = (props: TypeAheadForceSelectProps) => TypeAheadItem | undefined;
 export declare type TypeAheadHandler = {
+    id: TypeAheadAvailableNodes;
     trigger: string;
     customRegex?: string;
     headless?: boolean;
-    forceSelect?: (query: string, items: Array<TypeAheadItem>) => TypeAheadItem | undefined;
-    getItems: (query: string, editorState: EditorState, intl: InjectedIntl, meta: {
-        prevActive: boolean;
-        queryChanged: boolean;
-    }, tr: Transaction, dipatch: Dispatch) => Array<TypeAheadItem> | Promise<Array<TypeAheadItem>>;
+    forceSelect?: TypeAheadForceSelect;
+    onInvokeAnalytics?: TypeAheadPayload;
+    onOpen?: (editorState: EditorState) => void;
+    getItems: (props: {
+        query: string;
+        editorState: EditorState;
+    }) => Promise<Array<TypeAheadItem>>;
     selectItem: TypeAheadSelectItem;
-    dismiss?: (state: EditorState) => void;
+    dismiss?: (props: {
+        editorState: EditorState;
+        query: string;
+        stats: TypeAheadStats;
+    }) => void;
     getHighlight?: (state: EditorState) => JSX.Element | null;
 };
-export declare type TypeAheadItemsLoader = null | {
-    promise: Promise<Array<TypeAheadItem>>;
-    cancel(): void;
-};
 export declare type TypeAheadPluginState = {
-    isAllowed: boolean;
-    active: boolean;
-    prevActiveState: boolean;
-    query: string | null;
-    trigger: string | null;
-    typeAheadHandler: TypeAheadHandler | null;
+    decorationSet: DecorationSet;
+    decorationElement: HTMLElement | null;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+    query: string;
     items: Array<TypeAheadItem>;
-    itemsLoader: TypeAheadItemsLoader;
-    currentIndex: number;
-    queryMarkPos: number | null;
-    queryStarted: number;
-    upKeyCount: number;
-    downKeyCount: number;
-    highlight?: JSX.Element | null;
+    triggerHandler?: TypeAheadHandler;
+    selectedIndex: number;
+    stats: TypeAheadStatsSerializable | null;
+    inputMethod: TypeAheadInputMethod | null;
+};
+export declare type OnInsertSelectedItemProps = {
+    mode: SelectItemMode;
+    index: number;
+    query: string;
+};
+export declare type OnItemMatchProps = {
+    mode: SelectItemMode;
+    query: string;
+};
+export declare type OnInsertSelectedItem = (props: OnInsertSelectedItemProps) => void;
+export declare type OnItemMatch = (props: OnItemMatchProps) => boolean;
+export declare type OnTextInsertProps = {
+    forceFocusOnEditor: boolean;
+    setSelectionAt: CloseSelectionOptions;
+    text: string;
+};
+export declare type OnTextInsert = (props: OnTextInsertProps) => void;
+export declare type TypeAheadInputMethod = INPUT_METHOD.INSERT_MENU | INPUT_METHOD.KEYBOARD | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.TOOLBAR;
+export declare type InsertionTransactionMeta = (editorState: EditorState) => Transaction | false;
+declare type PopupMountPoints = Pick<UiComponentFactoryParams, 'popupsMountPoint' | 'popupsBoundariesElement' | 'popupsScrollableElement'>;
+export declare type PopupMountPointReference = Record<'current', PopupMountPoints | null>;
+export declare type CreateTypeAheadDecorations = (tr: Transaction, options: {
+    triggerHandler: TypeAheadHandler;
+    inputMethod: TypeAheadInputMethod;
+    reopenQuery?: string;
+}) => {
+    decorationSet: DecorationSet;
+    decorationElement: HTMLElement | null;
+    stats: TypeAheadStatsSerializable | null;
 };
+export declare type RemoveTypeAheadDecorations = (decorationSet?: DecorationSet) => boolean;

package/dist/types/plugins/type-ahead/ui/DynamicHeightListItem.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { TypeAheadItem, OnSelectItem } from '../types';
+declare type ListItemActionsContextProps = {
+    onItemHover: OnSelectItem;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+};
+declare type DynamicHeightListItemProps = {
+    index: number;
+    data: Array<TypeAheadItem>;
+    style: any;
+};
+declare type UpdateListItemHeightContextType = (props: {
+    index: number;
+    height: number;
+}) => void;
+export declare const SelectedIndexContext: React.Context<number>;
+export declare const ListItemActionsContext: React.Context<ListItemActionsContextProps>;
+export declare const UpdateListItemHeightContext: React.Context<UpdateListItemHeightContextType>;
+export declare const DynamicHeightListItem: React.FC<DynamicHeightListItemProps>;
+export {};

package/dist/types/plugins/type-ahead/ui/InputQuery.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { CloseSelectionOptions } from '../constants';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+declare 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;
+};
+export declare const InputQuery: React.FC<InputQueryProps>;
+export {};

package/dist/types/plugins/type-ahead/ui/TypeAheadList.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { TypeAheadItem, OnSelectItem } from '../types';
+declare type TypeAheadListProps = {
+    items: Array<TypeAheadItem>;
+    selectedIndex: number;
+    onItemHover: OnSelectItem;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+};
+export declare const TypeAheadList: React.MemoExoticComponent<({ items, selectedIndex, onItemHover, onItemClick }: TypeAheadListProps) => JSX.Element | null>;
+export {};

package/dist/types/plugins/type-ahead/ui/TypeAheadListItem.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { TypeAheadItem, OnSelectItem } from '../types';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+export declare const ICON_HEIGHT = 40;
+export declare const ICON_WIDTH = 40;
+export declare const ItemIcon: import("styled-components").StyledComponentClass<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, any, React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>>;
+declare type TypeAheadListItemProps = {
+    item: TypeAheadItem;
+    itemIndex: number;
+    selectedIndex: number;
+    onItemHover: OnSelectItem;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+};
+export declare const TypeAheadListItem: React.FC<TypeAheadListItemProps>;
+export {};

package/dist/types/plugins/type-ahead/ui/TypeAheadPopup.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { EditorView, DecorationSet } from 'prosemirror-view';
+import type { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { TypeAheadHandler, TypeAheadItem, OnSelectItem } from '../types';
+import type { FireAnalyticsCallback } from '../../analytics/fire-analytics-event';
+declare 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;
+};
+export declare const TypeAheadPopup: React.FC<TypeAheadPopupProps>;
+export {};

package/dist/types/plugins/type-ahead/ui/WrapperTypeAhead.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { EditorView } from 'prosemirror-view';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { TypeAheadHandler, TypeAheadInputMethod } from '../types';
+declare type WrapperProps = {
+    triggerHandler: TypeAheadHandler;
+    editorView: EditorView;
+    anchorElement: HTMLElement;
+    getDecorationPosition: () => number;
+    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/plugins/type-ahead/ui/hooks/use-dynamic-list-height-calculation.d.ts

@@ -0,0 +1,25 @@
+export declare const calcVisibleListHeight: ({ startIndex, indexHeightMap, limit, listMaxHeight, listItemEstimatedHeight, }: {
+    startIndex: number;
+    indexHeightMap: Array<number>;
+    limit: number;
+    listMaxHeight: number;
+    listItemEstimatedHeight: number;
+}) => number;
+declare type SetListItemHeight = (props: {
+    index: number;
+    height: number;
+}) => void;
+declare type GetListItemHeight = (index: number) => number;
+declare type Props = {
+    redrawListAtIndex: (index: number) => void;
+    getFirstVisibleIndex: () => number;
+    listLength: number;
+    listMaxHeight: number;
+    listItemEstimatedHeight: number;
+};
+export declare const useDynamicListHeightCalculation: ({ redrawListAtIndex, getFirstVisibleIndex, listLength, listMaxHeight, listItemEstimatedHeight, }: Props) => {
+    getListItemHeight: GetListItemHeight;
+    setListItemHeight: SetListItemHeight;
+    renderedListHeight: number | null;
+};
+export {};

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

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

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

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

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

@@ -0,0 +1,11 @@
+import type { EditorView } from 'prosemirror-view';
+import { TypeAheadHandler, TypeAheadItem } from '../../types';
+declare 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/plugins/type-ahead/ui/hooks/use-resize-observer.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="resize-observer-browser" />
+import React from 'react';
+interface ElementResizable extends Element {
+    onResize?: (entry: ResizeObserverEntry) => void;
+}
+export declare const ResizeObserverContext: React.Context<ResizeObserver | null>;
+export declare const ResizeObserverProvider: React.FC;
+export declare const useResizeObserver: <T extends ElementResizable>(targetRef: React.MutableRefObject<T> | null, onResize: (entry: ResizeObserverEntry) => void) => void;
+export {};

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

@@ -0,0 +1,18 @@
+import { EditorState } from 'prosemirror-state';
+import { Decoration, EditorView } from 'prosemirror-view';
+import { TypeAheadAvailableNodes } from '@atlaskit/editor-common/type-ahead';
+import type { TypeAheadHandler, TypeAheadPluginState } from './types';
+export declare const findTypeAheadDecorations: (state: EditorState) => Decoration | null;
+export declare const isTypeAheadHandler: (handler: any) => handler is TypeAheadHandler;
+export declare const isTypeAheadOpen: (editorState: EditorState) => boolean;
+export declare const getPluginState: (editorState: EditorState) => TypeAheadPluginState;
+export declare const getTypeAheadHandler: (editorState: EditorState) => any;
+export declare const getTypeAheadQuery: (editorState: EditorState) => any;
+export declare const isTypeAheadAllowed: (state: EditorState) => boolean;
+export declare const findHandler: (id: TypeAheadAvailableNodes, state: EditorState) => TypeAheadHandler | null;
+declare type MoveSelectedIndexProps = {
+    editorView: EditorView;
+    direction: 'next' | 'previous';
+};
+export declare const moveSelectedIndex: ({ editorView, direction, }: MoveSelectedIndexProps) => () => void;
+export {};

package/dist/types/plugins/view-update-subscription/subscribe/type-ahead-updates.d.ts

@@ -0,0 +1,9 @@
+import { EditorView } from 'prosemirror-view';
+import type { TypeAheadPluginState } from '../../type-ahead/types';
+declare type Props = {
+    oldPluginState: TypeAheadPluginState;
+    newPluginState: TypeAheadPluginState;
+};
+declare type SubscribeTypeAheadUpdates = (editorView: EditorView, cb: (props: Props) => void) => () => void;
+export declare const subscribeTypeAheadUpdates: SubscribeTypeAheadUpdates;
+export {};

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

@@ -4,6 +4,7 @@ import { LightEditorPlugin, LightPMPlugin, LightPMPluginFactoryParams, OnEditorV
 import { Preset } from './labs/next/presets/preset';
 import { Schema } from 'prosemirror-model';
 import { MarkConfig, NodeConfig } from './types/pm-config';
+export { createTypeAheadTools } from './plugins/type-ahead/api';
 export { Preset } from './labs/next/presets/preset';
 export type { LightEditorPlugin } from './create-editor/get-plugins';
 export type { DispatchAnalyticsEvent } from './plugins/analytics/types';
@@ -14,6 +15,7 @@ export interface LightEditorConfig {
     plugins: Array<LightPMPlugin>;
     onEditorViewStateUpdatedCallbacks: Array<OnEditorViewStateUpdated>;
 }
+export declare function getFireAnalytics(editorView: EditorView): any;
 declare type PluginData = {
     plugins: Plugin[];
     schema: Schema;

package/dist/types/types/editor-props.d.ts

@@ -27,6 +27,7 @@ import { PerformanceTracking } from './performance-tracking';
 import { PanelPluginConfig } from './../plugins/panel/types';
 import { EditorPlugin } from './editor-plugin';
 import { MentionPluginConfig } from './../plugins/mentions/types';
+import { EmptyStateHandler } from './empty-state-handler';
 export declare type ReactComponents = ReactElement<any> | ReactElement<any>[];
 declare type ExtensionProviders = (ExtensionProvider | Promise<ExtensionProvider>)[];
 declare type ExtensionProvidersWithEditorAction = (editorActions?: EditorActions) => ExtensionProviders;
@@ -154,6 +155,7 @@ export interface EditorProps {
         showModal?: boolean;
         replacePlusMenu?: boolean;
         helpUrl?: string;
+        emptyStateHandler?: EmptyStateHandler;
     };
     codeBlock?: CodeBlockOptions;
     UNSAFE_allowUndoRedoButtons?: boolean;

package/dist/types/types/empty-state-handler.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare type EmptyStateHandler = (params: EmptyStateHandlerParams) => React.ReactElement<any> | null;
+export declare type EmptyStateHandlerParams = {
+    mode: string;
+    selectedCategory?: string;
+    searchTerm?: string;
+};

package/dist/types/types/feature-flags.d.ts

@@ -234,5 +234,13 @@ export declare type FeatureFlags = {
      * @default false
      */
     enableViewUpdateSubscription?: boolean;
+    /**
+     * @description
+     * Enable scroll-to-telepointer for collab avatars
+     *
+     * @see https://product-fabric.atlassian.net/browse/ED-12460
+     * @default false
+     */
+    collabAvatarScroll?: boolean;
 };
 export declare type FeatureFlagKey = keyof FeatureFlags;

package/dist/types/ui/Appearance/FullPage/StyledComponents.d.ts

@@ -12,7 +12,7 @@ export declare const ScrollContainer: import("styled-components").StyledComponen
     featureFlags?: import("../../..").EditorFeatureFlags | undefined;
 } & {
     className?: string | undefined;
-}, "className" | "theme" | "allowAnnotation"> & import("react").RefAttributes<unknown>, "className" | "ref" | "key" | "allowAnnotation"> & {
+}, "className" | "theme" | "allowAnnotation"> & import("react").RefAttributes<unknown>, "ref" | "key" | "className" | "allowAnnotation"> & {
     theme?: any;
 }>;
 export declare const ContentArea: import("styled-components").StyledComponentClass<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {

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

@@ -14,5 +14,5 @@ declare type Props = WithAnalyticsEventsProps & {
         height: number;
     };
 };
-declare const _default: React.ForwardRefExoticComponent<Pick<Pick<Props, "placement" | "title" | "cols" | "size" | "onChange" | "currentColor" | "alignX" | "colorPalette"> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "placement" | "title" | "cols" | "size" | "onChange" | "analyticsContext" | "key" | "currentColor" | "alignX" | "colorPalette"> & React.RefAttributes<any>>;
+declare const _default: React.ForwardRefExoticComponent<Pick<Pick<Props, "title" | "onChange" | "placement" | "cols" | "size" | "currentColor" | "alignX" | "colorPalette"> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "title" | "key" | "onChange" | "placement" | "cols" | "size" | "analyticsContext" | "currentColor" | "alignX" | "colorPalette"> & React.RefAttributes<any>>;
 export default _default;

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

@@ -15,5 +15,5 @@ declare type Props = {
     errorMessage: string | null;
     isLoading?: boolean;
 } & WithAnalyticsEventsProps;
-declare const _default: React.ForwardRefExoticComponent<Pick<Pick<Props, "autoSave" | "onChange" | "isLoading" | "fields" | "parameters" | "onCancel" | "errorMessage" | "extensionManifest" | "autoSaveTrigger" | "showHeader" | "closeOnEsc"> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "autoSave" | "onChange" | "analyticsContext" | "isLoading" | "key" | "fields" | "parameters" | "onCancel" | "errorMessage" | "extensionManifest" | "autoSaveTrigger" | "showHeader" | "closeOnEsc"> & React.RefAttributes<any>>;
+declare const _default: React.ForwardRefExoticComponent<Pick<Pick<Props, "autoSave" | "onChange" | "isLoading" | "fields" | "parameters" | "onCancel" | "errorMessage" | "extensionManifest" | "autoSaveTrigger" | "showHeader" | "closeOnEsc"> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "key" | "autoSave" | "onChange" | "isLoading" | "fields" | "analyticsContext" | "parameters" | "onCancel" | "errorMessage" | "extensionManifest" | "autoSaveTrigger" | "showHeader" | "closeOnEsc"> & React.RefAttributes<any>>;
 export default _default;

package/dist/types/ui/ConfigPanel/FormErrorBoundary.d.ts

@@ -12,5 +12,5 @@ interface Props {
 export declare const FormErrorBoundaryImpl: React.ComponentClass<Props & WithAnalyticsEventsProps, any> & {
     WrappedComponent: ReactIntl.ComponentConstructor<Props & WithAnalyticsEventsProps & InjectedIntlProps>;
 };
-export declare const FormErrorBoundary: React.ForwardRefExoticComponent<Pick<Pick<Props & WithAnalyticsEventsProps, "children" | "contextIdentifierProvider" | "fields" | "extensionKey"> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "children" | "analyticsContext" | "key" | "contextIdentifierProvider" | "fields" | "extensionKey"> & React.RefAttributes<any>>;
+export declare const FormErrorBoundary: React.ForwardRefExoticComponent<Pick<Pick<Props & WithAnalyticsEventsProps, "contextIdentifierProvider" | "children" | "fields" | "extensionKey"> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "contextIdentifierProvider" | "children" | "key" | "fields" | "extensionKey" | "analyticsContext"> & React.RefAttributes<any>>;
 export {};

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

@@ -1,6 +1,7 @@
 import { PureComponent } from 'react';
 import { QuickInsertItem } from '@atlaskit/editor-common/provider-factory';
 import { Category, Modes } from './types';
+import { EmptyStateHandler } from '../../types/empty-state-handler';
 export interface Props {
     categories?: Category[];
     mode: keyof typeof Modes;
@@ -10,6 +11,7 @@ export interface Props {
     showSearch: boolean;
     showCategories: boolean;
     defaultCategory?: string;
+    emptyStateHandler?: EmptyStateHandler;
 }
 export interface State {
     items: QuickInsertItem[];

package/dist/types/ui/ElementBrowser/ModalElementBrowser.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { InjectedIntlProps } from 'react-intl';
 import { QuickInsertItem } from '@atlaskit/editor-common/provider-factory';
+import { EmptyStateHandler } from '../../types/empty-state-handler';
 export interface State {
     isOpen: boolean;
 }
@@ -10,6 +11,7 @@ export interface Props {
     isOpen?: boolean;
     onClose: () => void;
     helpUrl?: string | undefined;
+    emptyStateHandler?: EmptyStateHandler;
 }
 declare const _default: React.ComponentClass<Props, any> & {
     WrappedComponent: ReactIntl.ComponentConstructor<Props & InjectedIntlProps>;

package/dist/types/ui/ElementBrowser/components/CategoryList.d.ts

@@ -6,5 +6,5 @@ interface Props {
     onSelectCategory: (category: Category) => void;
     selectedCategory?: string;
 }
-declare const MemoizedCategoryListWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Props & WithAnalyticsEventsProps & import("@atlaskit/analytics-next").WithContextProps, "analyticsContext" | "createAnalyticsEvent" | "categories" | "onSelectCategory" | "selectedCategory"> & React.RefAttributes<any>>>;
+declare const MemoizedCategoryListWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Props & WithAnalyticsEventsProps & import("@atlaskit/analytics-next").WithContextProps, "createAnalyticsEvent" | "analyticsContext" | "selectedCategory" | "categories" | "onSelectCategory"> & React.RefAttributes<any>>>;
 export default MemoizedCategoryListWithAnalytics;

package/dist/types/ui/ElementBrowser/components/ElementList/ElementList.d.ts

@@ -2,12 +2,16 @@ import React from 'react';
 import { QuickInsertItem } from '@atlaskit/editor-common/provider-factory';
 import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
 import { Modes, SelectedItemProps } from '../../types';
+import { EmptyStateHandler } from '../../../../types/empty-state-handler';
 export interface Props {
     items: QuickInsertItem[];
     mode: keyof typeof Modes;
     onInsertItem: (item: QuickInsertItem) => void;
     setColumnCount: (columnCount: number) => void;
     setFocusedItemIndex: (index: number) => void;
+    emptyStateHandler?: EmptyStateHandler;
+    selectedCategory?: string;
+    searchTerm?: string;
 }
-declare const MemoizedElementListWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Props & SelectedItemProps & WithAnalyticsEventsProps & import("@atlaskit/analytics-next").WithContextProps, "mode" | "analyticsContext" | "createAnalyticsEvent" | "items" | "selectedItemIndex" | "focusedItemIndex" | "setColumnCount" | "onInsertItem" | "setFocusedItemIndex"> & React.RefAttributes<any>>>;
+declare const MemoizedElementListWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Props & SelectedItemProps & WithAnalyticsEventsProps & import("@atlaskit/analytics-next").WithContextProps, "mode" | "createAnalyticsEvent" | "analyticsContext" | "items" | "selectedItemIndex" | "focusedItemIndex" | "setColumnCount" | "emptyStateHandler" | "selectedCategory" | "searchTerm" | "onInsertItem" | "setFocusedItemIndex"> & React.RefAttributes<any>>>;
 export default MemoizedElementListWithAnalytics;

package/dist/types/ui/ElementBrowser/components/StatelessElementBrowser.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { QuickInsertItem } from '@atlaskit/editor-common/provider-factory';
 import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
 import { Category, Modes } from '../types';
+import { EmptyStateHandler } from '../../../types/empty-state-handler';
 export declare type StatelessElementBrowserProps = {
     categories?: Category[];
     items: QuickInsertItem[];
@@ -14,6 +15,7 @@ export declare type StatelessElementBrowserProps = {
     showCategories: boolean;
     mode: keyof typeof Modes;
     searchTerm?: string;
+    emptyStateHandler?: EmptyStateHandler;
 } & WithAnalyticsEventsProps;
-declare const MemoizedElementBrowser: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Pick<StatelessElementBrowserProps, "mode" | "items" | "onInsertItem" | "categories" | "onSelectCategory" | "selectedCategory" | "onSearch" | "searchTerm" | "onSelectItem" | "showCategories" | "showSearch"> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "mode" | "analyticsContext" | "key" | "items" | "onInsertItem" | "categories" | "onSelectCategory" | "selectedCategory" | "onSearch" | "searchTerm" | "onSelectItem" | "showCategories" | "showSearch"> & React.RefAttributes<any>>>;
+declare const MemoizedElementBrowser: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Pick<StatelessElementBrowserProps, "mode" | "items" | "emptyStateHandler" | "selectedCategory" | "searchTerm" | "onInsertItem" | "categories" | "onSelectCategory" | "onSearch" | "onSelectItem" | "showCategories" | "showSearch"> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "key" | "mode" | "analyticsContext" | "items" | "emptyStateHandler" | "selectedCategory" | "searchTerm" | "onInsertItem" | "categories" | "onSelectCategory" | "onSearch" | "onSelectItem" | "showCategories" | "showSearch"> & React.RefAttributes<any>>>;
 export default MemoizedElementBrowser;