@atlaskit/editor-core 183.0.0 → 183.0.6

package/dist/types-ts4.0/ui/EditorContext/index.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import EditorActions from '../../actions';
+export declare type EditorContextProps = {
+    editorActions?: EditorActions;
+};
+export declare const useEditorContext: () => EditorContextProps;
+export default class LegacyEditorContext extends React.Component<EditorContextProps, {}> {
+    static childContextTypes: {
+        editorActions: PropTypes.Requireable<object>;
+    };
+    private editorActions;
+    constructor(props: EditorContextProps);
+    getChildContext(): {
+        editorActions: EditorActions<any>;
+    };
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/ui/ElementBrowser/ElementBrowser.d.ts

@@ -0,0 +1,36 @@
+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;
+    getItems: (query?: string, category?: string) => QuickInsertItem[];
+    onSelectItem?: (item: QuickInsertItem) => void;
+    onInsertItem: (item: QuickInsertItem) => void;
+    showSearch: boolean;
+    showCategories: boolean;
+    defaultCategory?: string;
+    emptyStateHandler?: EmptyStateHandler;
+}
+export interface State {
+    items: QuickInsertItem[];
+    categories: Category[];
+    selectedCategory?: string;
+    searchTerm?: string;
+}
+export default class ElementBrowser extends PureComponent<Props, State> {
+    static defaultProps: {
+        defaultCategory: string;
+        onInsertItem: () => void;
+    };
+    state: State;
+    componentDidMount(): void;
+    getCategories: (items?: QuickInsertItem[]) => Category[];
+    filterCategories: (items: QuickInsertItem[], categories?: Category[]) => Category[];
+    fetchItems: (query?: string | undefined, category?: string | undefined) => QuickInsertItem[];
+    componentDidUpdate(prevProps: Props, prevState: State): void;
+    handleSearch: (searchTerm: string) => void;
+    handleCategorySelection: (clickedCategory: Category) => void;
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/ui/ElementBrowser/InsertMenu.d.ts

@@ -0,0 +1,4 @@
+import { jsx } from '@emotion/react';
+import { InsertMenuProps } from './types';
+declare const InsertMenu: ({ editorView, dropdownItems, showElementBrowserLink, onInsert, toggleVisiblity, }: InsertMenuProps) => jsx.JSX.Element;
+export default InsertMenu;

package/dist/types-ts4.0/ui/ElementBrowser/ModalElementBrowser.d.ts

@@ -0,0 +1,17 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { QuickInsertItem } from '@atlaskit/editor-common/provider-factory';
+import { EmptyStateHandler } from '../../types/empty-state-handler';
+export interface Props {
+    getItems: (query?: string, category?: string) => QuickInsertItem[];
+    onInsertItem: (item: QuickInsertItem) => void;
+    isOpen?: boolean;
+    onClose: () => void;
+    helpUrl?: string | undefined;
+    emptyStateHandler?: EmptyStateHandler;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.0/ui/ElementBrowser/categories.d.ts

@@ -0,0 +1,5 @@
+import { IntlShape } from 'react-intl-next';
+export declare function getCategories(intl: IntlShape): {
+    title: string;
+    name: string;
+}[];

package/dist/types-ts4.0/ui/ElementBrowser/components/CategoryList.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import { Category } from '../types';
+interface Props {
+    categories?: Category[];
+    onSelectCategory: (category: Category) => void;
+    selectedCategory?: string;
+}
+declare const MemoizedCategoryListWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Props & WithAnalyticsEventsProps & import("@atlaskit/analytics-next").WithContextProps, "createAnalyticsEvent" | "analyticsContext" | keyof Props> & React.RefAttributes<any>>>;
+export default MemoizedCategoryListWithAnalytics;

package/dist/types-ts4.0/ui/ElementBrowser/components/ElementBrowserLoader.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import Loadable from 'react-loadable';
+import type { Props as ElementBrowserProps } from '../ElementBrowser';
+declare const ElementBrowserLoader: React.ComponentType<ElementBrowserProps> & Loadable.LoadableComponent;
+export default ElementBrowserLoader;

package/dist/types-ts4.0/ui/ElementBrowser/components/ElementList/ElementList.d.ts

@@ -0,0 +1,29 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/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 type ElementItemType = {
+    inlineMode: boolean;
+    item: QuickInsertItem;
+    onInsertItem: (item: QuickInsertItem) => void;
+    selected: boolean;
+    focus: boolean;
+    setFocusedItemIndex: (index: number) => void;
+    index: number;
+};
+export declare function ElementItem({ inlineMode, selected, item, index, onInsertItem, focus, setFocusedItemIndex, }: ElementItemType): jsx.JSX.Element;
+declare const MemoizedElementListWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Props & SelectedItemProps & WithAnalyticsEventsProps & import("@atlaskit/analytics-next").WithContextProps, "createAnalyticsEvent" | "analyticsContext" | keyof Props | keyof SelectedItemProps> & React.RefAttributes<any>>>;
+export default MemoizedElementListWithAnalytics;

package/dist/types-ts4.0/ui/ElementBrowser/components/ElementList/EmptyState.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare type Props = {
+    onExternalLinkClick: () => void;
+};
+export default function EmptyState({ onExternalLinkClick, }: Props): JSX.Element;
+export {};

package/dist/types-ts4.0/ui/ElementBrowser/components/ElementList/NotFoundIllustration.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export default function NotFoundIllustration(): JSX.Element;

package/dist/types-ts4.0/ui/ElementBrowser/components/ElementList/cellSizeAndPositionGetter.d.ts

@@ -0,0 +1,7 @@
+import { CollectionCellSizeAndPositionGetter } from 'react-virtualized/dist/commonjs/Collection';
+/**
+ * Callback responsible for returning size and offset/position information
+ * for a given cell.
+ * https://github.com/bvaughn/react-virtualized/blob/master/docs/Collection.md
+ **/
+export default function cellSizeAndPositionGetter(containerWidth: number, scrollbarWidth: number): CollectionCellSizeAndPositionGetter;

package/dist/types-ts4.0/ui/ElementBrowser/components/ElementList/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function getColumnCount(clientWidth: number): number;
+declare type DatumReturnType = {
+    availableWidth: number;
+    columnCount: number;
+};
+declare type Options = {
+    gutterSize: number;
+    scrollbarWidth: number;
+};
+export declare function generateVirtualizedContainerDatum(containerWidth: number, options: Options): DatumReturnType;
+export declare function getScrollbarWidth(): number;
+export {};

package/dist/types-ts4.0/ui/ElementBrowser/components/ElementSearch.d.ts

@@ -0,0 +1,17 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { Modes } from '../types';
+interface Props {
+    onSearch: (value: string) => void;
+    mode: keyof typeof Modes;
+    focus: boolean;
+    onClick: (e: React.MouseEvent) => void;
+    searchTerm?: string;
+}
+declare const MemoizedElementSearchWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<Props & WrappedComponentProps<"intl">, "intl"> & {
+    forwardedRef?: React.Ref<any> | undefined;
+} & {
+    children?: React.ReactNode;
+} & import("@atlaskit/analytics-next").WithContextProps & React.RefAttributes<any>>>;
+export default MemoizedElementSearchWithAnalytics;

package/dist/types-ts4.0/ui/ElementBrowser/components/StatelessElementBrowser.d.ts

@@ -0,0 +1,22 @@
+/** @jsx jsx */
+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[];
+    onSearch: (searchTerm: string) => void;
+    onSelectCategory: (category: Category) => void;
+    onSelectItem?: (item: QuickInsertItem) => void;
+    onInsertItem: (item: QuickInsertItem) => void;
+    selectedCategory?: string;
+    showSearch: boolean;
+    showCategories: boolean;
+    mode: keyof typeof Modes;
+    searchTerm?: string;
+    emptyStateHandler?: EmptyStateHandler;
+} & WithAnalyticsEventsProps;
+declare const MemoizedElementBrowser: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Omit<StatelessElementBrowserProps, keyof WithAnalyticsEventsProps> & 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;

package/dist/types-ts4.0/ui/ElementBrowser/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const GRID_SIZE: number;
+export declare const DEVICE_BREAKPOINT_NUMBERS: {
+    small: number;
+    medium: number;
+    large: number;
+};
+export declare const FLEX_ITEMS_CONTAINER_BREAKPOINT_NUMBERS: {
+    small: number;
+    medium: number;
+    large: number;
+};
+export declare const SIDEBAR_WIDTH: string;
+export declare const SIDEBAR_HEADING_WRAPPER_HEIGHT: string;
+export declare const SIDEBAR_HEADING_PADDING_LEFT = "12px";
+export declare const INLINE_SIDEBAR_HEIGHT = "54px";
+export declare const SEARCH_ITEM_HEIGHT_WIDTH = "20px";
+export declare const SCROLLBAR_WIDTH = 15;
+export declare const ELEMENT_LIST_PADDING = 2;
+export declare const MODAL_WRAPPER_PADDING = 16;
+export declare const ELEMENT_ITEM_HEIGHT = 75;

package/dist/types-ts4.0/ui/ElementBrowser/hooks/use-container-width.d.ts

@@ -0,0 +1,33 @@
+/** @jsx jsx */
+import React from 'react';
+/**
+ *
+ * Problem:
+ * While using WidthObserver, there's no initial width.
+ * That may cause problems, but not limited to, something like a lag between
+ * renders for conditionally rendered components.
+ *
+ * solution:
+ * useContainerWidth() hook
+ * it pre-measures the width of a parent container on initial mount
+ * and gives you back the containerWidth.
+ *
+ *
+ * Example hook usage:
+ *
+ *  const { containerWidth, ContainerWidthMonitor } = useContainerWidth();
+ *
+ *  return (
+ *   <>
+ *    <ContainerWidthMonitor />
+ *    {containerWidth < 600 ? <MobileComponent /> : <DesktopComponent />}
+ *   </>
+ *  );
+ *
+ */
+declare type useContainerWidthReturnType = {
+    containerWidth: number;
+    ContainerWidthMonitor: React.ElementType;
+};
+export default function useContainerWidth(): useContainerWidthReturnType;
+export {};

package/dist/types-ts4.0/ui/ElementBrowser/hooks/use-focus.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="react" />
+/**
+ * A custom hook that handles focus on a DOM element.
+ * Takes in a boolean value and calls element.focus
+ *
+ * @param {boolean} focus
+ *
+ * Example usage:
+ *******************************************************************************
+ *    const SearchBar = ({ focus }) => {
+ *      const ref = useFocus(focus);
+ *      return <input ref={ref} />
+ *    }
+ *******************************************************************************
+ *    const ItemList = ({ items, focus }) => (
+ *       <ul>
+ *        {items.map((item, index) => (
+ *          <Item key={item.uuid} item={item} focus={focus} />
+ *        ))}
+ *       </ul>
+ *     );
+ *
+ *    const Item = ({ item, focus }) => {
+ *      const ref = useFocus(focus);
+ *      return (
+ *        <li ref={ref}>
+ *          {item.name}
+ *        </li>
+ *      )
+ *    }
+ *******************************************************************************
+ */
+declare type RefType = null | HTMLInputElement | HTMLDivElement;
+export default function useFocus(focus: boolean): import("react").MutableRefObject<RefType>;
+export {};

package/dist/types-ts4.0/ui/ElementBrowser/hooks/use-select-and-focus-on-arrow-navigation.d.ts

@@ -0,0 +1,68 @@
+import React from 'react';
+/**
+ * a custom hook that handles keyboard navigation for Arrow keys based on a
+ * given listSize, and a step (for up and down arrows).
+ *
+ * @param {number} listSize
+ * @param {number} upDownStep
+ *
+ * Example usage:
+ *    const list = ['Confluence','Jira','Atlaskit'];
+ *    const {
+ *      selectedItemIndex,
+ *      focusedItemIndex,
+ *      focusOnSearch,
+ *      setFocusedItemIndex,
+ *      onKeyDown
+ *    } = useSelectAndFocusOnArrowNavigation(list.length - 1, 1);
+ *
+ *    return (
+ *      <div onKeyDown={onKeyDown}>
+ *        <SearchBar onClick={() => setFocusedItemIndex(undefined)} focus={focusOnSearch} />
+ *        {list.map((item, index) => (
+ *           <ListItem
+ *            title={item}
+ *            style={{ ..., color: selected ? 'selectedStateColor' : defaultColor }}
+ *            onClick={() => {
+ *              setFocusedItemIndex(index);
+ *            }
+ *          />
+ *        )}
+ *      </div>
+ *    );
+ *
+ *    const SearchBar = ({ focus }) => {
+ *      const ref = useRefToFocusOrScroll(focus);
+ *      return <input ref={ref} />
+ *    }
+ *
+ */
+declare type ReducerState = {
+    focusOnSearch: boolean;
+    selectedItemIndex: number;
+    focusedItemIndex?: number;
+    listSize: number;
+};
+export declare enum ACTIONS {
+    FOCUS_SEARCH = "focusOnSearch",
+    UPDATE_STATE = "updateState",
+    MOVE = "move"
+}
+export declare type ReducerAction = {
+    type: ACTIONS;
+    payload: Partial<ReducerState> & {
+        positions?: number;
+        step?: number;
+    };
+};
+export declare type useSelectAndFocusReturnType = {
+    selectedItemIndex: number;
+    onKeyDown: (e: React.KeyboardEvent<HTMLDivElement>) => void;
+    focusOnSearch: boolean;
+    focusedItemIndex?: number;
+    setFocusedItemIndex: (index?: number) => void;
+    setFocusOnSearch: () => void;
+};
+declare function useSelectAndFocusOnArrowNavigation(listSize: number, step: number): useSelectAndFocusReturnType;
+export declare const ensureSafeIndex: (index: number, listSize: number) => number;
+export default useSelectAndFocusOnArrowNavigation;

package/dist/types-ts4.0/ui/ElementBrowser/index.d.ts

@@ -0,0 +1,2 @@
+import ElementBrowser from './components/ElementBrowserLoader';
+export default ElementBrowser;

package/dist/types-ts4.0/ui/ElementBrowser/messages.d.ts

@@ -0,0 +1,7 @@
+export declare const messages: {
+    help: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.0/ui/ElementBrowser/types.d.ts

@@ -0,0 +1,31 @@
+import { EditorView } from 'prosemirror-view';
+import { Transaction } from 'prosemirror-state';
+import { BlockMenuItem } from '../../plugins/insert-block/ui/ToolbarInsertBlock/create-items';
+import { MenuItem } from '../DropdownMenu/types';
+declare type SimpleEventHandler<T> = (event?: T) => void;
+export declare type Category = {
+    title: string;
+    name: string;
+};
+export declare enum Modes {
+    full = "full",
+    inline = "inline"
+}
+export declare type SelectedItemProps = {
+    selectedItemIndex: number;
+    focusedItemIndex?: number;
+};
+export interface InsertMenuProps {
+    dropdownItems: BlockMenuItem[];
+    editorView: EditorView;
+    showElementBrowserLink: boolean;
+    toggleVisiblity: SimpleEventHandler<MouseEvent | KeyboardEvent>;
+    onInsert: OnInsert;
+}
+export declare type OnInsert = ({ item }: {
+    item: MenuItem;
+}) => Transaction;
+export declare type SvgGetterParams = {
+    name: string;
+};
+export {};

package/dist/types-ts4.0/ui/ErrorBoundary/index.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { DispatchAnalyticsEvent } from '../../plugins/analytics/types';
+import { ACTION, ErrorEventPayload } from '../../plugins/analytics';
+declare type ErrorCrashPayload = Extract<ErrorEventPayload, {
+    action: ACTION.EDITOR_CRASHED;
+}>;
+interface ErrorBoundaryProps {
+    component: ErrorCrashPayload['actionSubject'];
+    componentId?: ErrorCrashPayload['actionSubjectId'];
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    fallbackComponent?: React.ReactNode;
+}
+interface ErrorBoundaryState {
+    errorCaptured: boolean;
+}
+export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: {
+        errorCaptured: boolean;
+    };
+    hasFallback(): boolean;
+    shouldRecover(): boolean;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+export {};

package/dist/types-ts4.0/ui/FloatingToolbar/index.d.ts

@@ -0,0 +1,26 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { PureComponent } from 'react';
+export declare type Coordinates = {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+};
+export interface Props {
+    zIndex?: number;
+    className?: string;
+    target?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    offset?: number[];
+    fitWidth?: number;
+    fitHeight?: number;
+    alignX?: 'left' | 'center' | 'right';
+    alignY?: 'bottom' | 'top';
+    onPositionCalculated?: (position: Coordinates) => any;
+}
+export { handlePositionCalculatedWith, getOffsetParent, getNearestNonTextNode, } from './utils';
+export default class FloatingToolbar extends PureComponent<Props, any> {
+    render(): jsx.JSX.Element | null;
+}

package/dist/types-ts4.0/ui/FloatingToolbar/styles.d.ts

@@ -0,0 +1 @@
+export declare const container: (height?: number | undefined) => import("@emotion/react").SerializedStyles;

package/dist/types-ts4.0/ui/FloatingToolbar/utils.d.ts

@@ -0,0 +1,13 @@
+export declare const getOffsetParent: (editorViewDom: HTMLElement, popupsMountPoint?: HTMLElement | undefined) => HTMLElement;
+export declare const getNearestNonTextNode: (node: Node) => HTMLElement;
+export declare const handlePositionCalculatedWith: (offsetParent: HTMLElement, node: Node, getCurrentFixedCoordinates: () => any) => (position: {
+    top?: number;
+    left?: number;
+    bottom?: number;
+    right?: number;
+}) => {
+    top?: number | undefined;
+    left?: number | undefined;
+    bottom?: number | undefined;
+    right?: number | undefined;
+};

package/dist/types-ts4.0/ui/LinkSearch/LinkSearchList.d.ts

@@ -0,0 +1,20 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { PureComponent } from 'react';
+import { LinkSearchListItemData } from './types';
+export declare const linkSearchList: import("@emotion/react").SerializedStyles;
+export interface Props {
+    items?: LinkSearchListItemData[];
+    isLoading: boolean;
+    selectedIndex: number;
+    onSelect: (href: string, text: string) => void;
+    onMouseMove?: (objectId: string) => void;
+    onMouseEnter?: (objectId: string) => void;
+    onMouseLeave?: (objectId: string) => void;
+    ariaControls?: string;
+    role?: string;
+    id?: string;
+}
+export default class LinkSearchList extends PureComponent<Props, {}> {
+    render(): jsx.JSX.Element;
+}

package/dist/types-ts4.0/ui/LinkSearch/LinkSearchListItem.d.ts

@@ -0,0 +1,22 @@
+/** @jsx jsx */
+import React from 'react';
+import { LinkSearchListItemData } from './types';
+import { WrappedComponentProps } from 'react-intl-next';
+export declare const container: import("@emotion/react").SerializedStyles;
+export declare const containerSelected: import("@emotion/react").SerializedStyles;
+export declare const nameStyle: import("@emotion/react").SerializedStyles;
+export declare const containerName: import("@emotion/react").SerializedStyles;
+export interface Props {
+    item: LinkSearchListItemData;
+    selected: boolean;
+    onSelect: (href: string, text: string) => void;
+    onMouseMove?: (objectId: string) => void;
+    onMouseEnter?: (objectId: string) => void;
+    onMouseLeave?: (objectId: string) => void;
+    id?: string;
+    role?: string;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.0/ui/LinkSearch/ToolbarComponents.d.ts

@@ -0,0 +1,7 @@
+export declare const RECENT_SEARCH_WIDTH_IN_PX = 420;
+export declare const RECENT_SEARCH_WIDTH_WITHOUT_ITEMS_IN_PX = 360;
+export declare const RECENT_SEARCH_HEIGHT_IN_PX = 360;
+export declare const LINKPICKER_HEIGHT_IN_PX = 570;
+export declare const inputWrapper: import("@emotion/react").SerializedStyles;
+export declare const container: import("@emotion/react").SerializedStyles;
+export declare const containerWithProvider: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.0/ui/LinkSearch/index.d.ts

@@ -0,0 +1,59 @@
+import React from 'react';
+import { WithActivityProviderProps } from './withActivityProvider';
+import { RecentSearchProps } from './types';
+declare const _default: {
+    new (props: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>): {
+        renderNode: (providers: import("@atlaskit/editor-common/provider-factory").Providers) => JSX.Element;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps, context?: any): {
+        renderNode: (providers: import("@atlaskit/editor-common/provider-factory").Providers) => JSX.Element;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("@atlaskit/editor-common/utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/types-ts4.0/ui/LinkSearch/listItemAlts.d.ts

@@ -0,0 +1,2 @@
+import { IntlShape } from 'react-intl-next';
+export declare const getCorrectAltByIconUrl: (iconUrl: string, intl: IntlShape) => string;

package/dist/types-ts4.0/ui/LinkSearch/transformTimeStamp.d.ts

@@ -0,0 +1,10 @@
+import { IntlShape } from 'react-intl-next';
+export declare const transformTimeStamp: (intl: IntlShape, lastViewedDate?: Date | undefined, lastUpdatedDate?: Date | undefined) => {
+    pageAction: string;
+    dateString: string;
+    timeSince?: undefined;
+} | {
+    pageAction: string;
+    dateString: string;
+    timeSince: string;
+} | undefined;