@atlaskit/editor-common 74.19.2 → 74.20.0

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

@@ -0,0 +1,45 @@
+/** @jsx jsx */
+import { FocusEvent, KeyboardEvent, PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+export interface Props {
+    autoFocus?: boolean | FocusOptions;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    onCancel?: (e: KeyboardEvent) => void;
+    placeholder?: string;
+    onMouseDown?: Function;
+    onKeyDown?: (e: KeyboardEvent<any>) => void;
+    onUndo?: Function;
+    onRedo?: Function;
+    onBlur?: Function;
+    width?: number;
+    maxLength?: number;
+    testId?: string;
+    ariaLabel?: string;
+    describedById?: string;
+    ariaExpanded?: boolean;
+    ariaActiveDescendant?: string;
+    ariaControls?: string;
+    role?: string;
+    ariaAutoComplete?: boolean;
+}
+export interface State {
+    value?: string;
+}
+export default class PanelTextInput extends PureComponent<Props, State> {
+    private input?;
+    private focusTimeoutId;
+    constructor(props: Props);
+    componentDidUpdate(prevProps: Props): void;
+    componentWillUnmount(): void;
+    onMouseDown: () => void;
+    onBlur: (e: FocusEvent<any>) => void;
+    render(): jsx.JSX.Element;
+    focus(): void;
+    private handleChange;
+    private handleKeydown;
+    private isUndoEvent;
+    private isRedoEvent;
+    private handleRef;
+}

package/dist/types/ui/PanelTextInput/styles.d.ts

@@ -0,0 +1,2 @@
+export declare const panelTextInput: import("@emotion/react").SerializedStyles;
+export declare const panelTextInputWithCustomWidth: (width: number) => import("@emotion/react").SerializedStyles;

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

@@ -33,3 +33,6 @@ export type { ResizerState } from './ResizerLegacy';
 export type { EnabledHandles, Props as ResizerProps, } from './ResizerLegacy/types';
 export { snapTo, handleSides, imageAlignmentMap } from './ResizerLegacy/utils';
 export { wrapperStyle } from './ResizerLegacy/styled';
+export { panelTextInput } from './PanelTextInput/styles';
+export { default as PanelTextInput } from './PanelTextInput';
+export { default as Announcer } from './Announcer/announcer';

package/dist/types/utils/commands.d.ts

@@ -0,0 +1,2 @@
+import type { Command, Predicate } from '../types';
+export declare const filter: (predicates: Predicate[] | Predicate, cmd: Command) => Command;

package/dist/types/utils/hyperlink.d.ts

@@ -1,4 +1,5 @@
 import { Schema, Slice } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
 import { AnalyticsEventPayload, InputMethodInsertLink } from '../analytics/types';
 export declare const FILEPATH_REGEXP: RegExp;
 export declare const DONTLINKIFY_REGEXP: RegExp;
@@ -24,4 +25,5 @@ interface filepathMatch {
 export declare const findFilepaths: (text: string, offset?: number) => Array<filepathMatch>;
 export declare const isLinkInMatches: (linkStart: number, matchesList: Array<filepathMatch>) => boolean;
 export declare function getLinkCreationAnalyticsEvent(inputMethod: InputMethodInsertLink, url: string): AnalyticsEventPayload;
+export declare const canLinkBeCreatedInRange: (from: number, to: number) => (state: EditorState) => boolean;
 export {};

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

@@ -47,10 +47,12 @@ export type { UseComponentRenderTrackingArgs } from './performance/hooks/use-com
 export { isOutdatedBrowser } from './outdated-browsers';
 export { isReferencedSource, removeConnectedNodes, getChildrenInfo, getNodeName, } from './referentiality';
 export { getItemCounterDigitsSize, getOrderFromOrderedListNode, resolveOrder, isListNode, isParagraphNode, isListItemNode, isBulletList, } from './list';
-export { isFromCurrentDomain, LinkMatcher, normalizeUrl, linkifyContent, getLinkDomain, findFilepaths, isLinkInMatches, FILEPATH_REGEXP, DONTLINKIFY_REGEXP, getLinkCreationAnalyticsEvent, } from './hyperlink';
+export { isFromCurrentDomain, LinkMatcher, normalizeUrl, linkifyContent, getLinkDomain, findFilepaths, isLinkInMatches, FILEPATH_REGEXP, DONTLINKIFY_REGEXP, getLinkCreationAnalyticsEvent, canLinkBeCreatedInRange, } from './hyperlink';
 export declare const pmHistoryPluginKey = "history$";
 export { gridTypeForLayout } from './grid';
 export { nodesBetweenChanged, getStepRange, isEmptyDocument, processRawValue, hasDocAsParent, bracketTyped, } from './document';
 export { floatingLayouts, isRichMediaInsideOfBlockNode, calculateSnapPoints, alignAttributes, } from './rich-media-utils';
 export { sanitizeNodeForPrivacy } from './filter/privacy-filter';
 export { canRenderDatasource } from './datasource';
+export { filter as filterCommands } from './commands';
+export declare function shallowEqual(obj1?: any, obj2?: any): boolean;

package/dist/types-ts4.5/link/LinkPicker/EditorLinkPicker/index.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { EditorView } from 'prosemirror-view';
+import { LinkPickerProps } from '@atlaskit/link-picker';
+import type { Command, EditorAppearance } from '../../../types';
+/**
+ * Returns a type that matches T but where keys (K) are now optional
+ */
+type OptionalKeys<T extends {}, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export interface EditorLinkPickerProps extends OptionalKeys<LinkPickerProps, 'onCancel'> {
+    view: EditorView;
+    /**
+     * Used for analytics purposes to describe how the link picker was invoked
+     * Should be roughly equivalent to the `inputMethod` analytics value
+     */
+    invokeMethod?: string;
+    editorAppearance?: EditorAppearance;
+    /** Callback to execute on unmount */
+    onClose?: () => void;
+    onEscapeCallback?: Command;
+    onClickAwayCallback?: Command;
+}
+export declare const EditorLinkPicker: ({ view, onCancel, invokeMethod, editorAppearance, onClose, onEscapeCallback, onClickAwayCallback, ...restProps }: EditorLinkPickerProps) => JSX.Element;
+export {};

package/dist/types-ts4.5/link/LinkPicker/EditorLinkPicker/useEscapeClickaway.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const useEscapeClickaway: <T extends HTMLElement>(onEscape: () => void, onClickAway: () => void) => import("react").MutableRefObject<T | null>;

package/dist/types-ts4.5/link/LinkPicker/HyperlinkAddToolbar/HyperlinkAddToolbar.d.ts

@@ -0,0 +1,115 @@
+/** @jsx jsx */
+import React, { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+import { EditorView } from 'prosemirror-view';
+import { WrappedComponentProps } from 'react-intl-next';
+import { ActivityProvider } from '@atlaskit/activity-provider';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import type { HyperlinkState } from '../../../link';
+import type { SearchProvider } from '../../../provider-factory';
+import type { Command, LinkInputType } from '../../../types';
+import { LinkSearchListItemData } from '../../LinkSearch/types';
+/**
+ * Visible only to screenreaders. Use when there is a need
+ * to provide more context to a non-sighted user.
+ */
+export declare const visuallyHiddenStyles: import("@emotion/react").SerializedStyles;
+export declare const RECENT_SEARCH_LIST_SIZE = 5;
+export declare const messages: {
+    displayText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    clearText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    clearLink: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    searchLinkAriaDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    searchLinkResults: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    linkAriaLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+interface BaseProps {
+    onSubmit?: (href: string, title: string | undefined, displayText: string | undefined, inputMethod: LinkInputType) => void;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    autoFocus?: boolean;
+    activityProvider?: Promise<ActivityProvider>;
+    searchProvider?: Promise<SearchProvider>;
+    displayUrl?: string;
+    pluginState: HyperlinkState;
+    view: EditorView;
+    onEscapeCallback?: Command;
+    onClickAwayCallback?: Command;
+}
+interface DefaultProps {
+    displayText: string;
+}
+export type Props = WrappedComponentProps & BaseProps & DefaultProps & WithAnalyticsEventsProps;
+type HyperlinkLinkAddToolbarProps = WrappedComponentProps & BaseProps & Partial<DefaultProps> & WithAnalyticsEventsProps;
+export interface State {
+    activityProvider?: ActivityProvider;
+    searchProvider?: SearchProvider;
+    items: LinkSearchListItemData[];
+    selectedIndex: number;
+    displayUrl: string;
+    isLoading: boolean;
+    displayText: string;
+}
+export declare class HyperlinkLinkAddToolbar extends PureComponent<Props, State> {
+    private submitted;
+    private urlInputContainer;
+    private displayTextInputContainer;
+    private wrapperRef;
+    private handleClearText;
+    private handleClearDisplayText;
+    private debouncedQuickSearch;
+    private fireCustomAnalytics?;
+    private quickSearchQueryVersion;
+    private analyticSource;
+    constructor(props: Props);
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): void;
+    private getRecentItems;
+    private fireAnalytics;
+    private loadInitialLinkSearchResult;
+    private quickSearch;
+    private updateInput;
+    private createClearHandler;
+    private handleClickOutside;
+    private getScreenReaderText;
+    render(): jsx.JSX.Element;
+    private isUrlPopulatedWithSelectedItem;
+    private handleSelected;
+    private handleInsert;
+    private handleMouseEnterResultItem;
+    private handleMouseLeaveResultItem;
+    private handleSubmit;
+    private handleClearTextKeyDown;
+    private handleKeyDown;
+    private updateTextInput;
+    private handleCancel;
+}
+export declare const HyperlinkLinkAddToolbarWithIntl: React.FC<import("react-intl-next").WithIntlProps<HyperlinkLinkAddToolbarProps>> & {
+    WrappedComponent: React.ComponentType<HyperlinkLinkAddToolbarProps>;
+};
+declare const _default: React.ForwardRefExoticComponent<Omit<React.PropsWithChildren<import("react-intl-next").WithIntlProps<HyperlinkLinkAddToolbarProps>>, keyof WithAnalyticsEventsProps> & React.RefAttributes<any>>;
+export default _default;

package/dist/types-ts4.5/link/LinkPicker/HyperlinkAddToolbar/index.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+import { EditorView } from 'prosemirror-view';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { HyperlinkState } from '../../../link';
+import { ProviderFactory } from '../../../provider-factory';
+import type { Command, FeatureFlags, LinkInputType, LinkPickerOptions } from '../../../types';
+import { EditorLinkPickerProps } from '../EditorLinkPicker';
+export interface HyperlinkAddToolbarProps extends Pick<EditorLinkPickerProps, 'onCancel' | 'invokeMethod' | 'onClose'> {
+    view: EditorView;
+    providerFactory: ProviderFactory;
+    onSubmit: (href: string, title: string | undefined, displayText: string | undefined, inputMethod: LinkInputType, analytic?: UIAnalyticsEvent | null | undefined) => void;
+    featureFlags: FeatureFlags;
+    linkPickerOptions?: LinkPickerOptions;
+    displayText?: string;
+    displayUrl?: string;
+    onEscapeCallback?: Command;
+    onClickAwayCallback?: Command;
+}
+export declare function HyperlinkAddToolbar({ linkPickerOptions, onSubmit, displayText, displayUrl, providerFactory, view, onCancel, invokeMethod, featureFlags, onClose, onEscapeCallback, onClickAwayCallback, hyperlinkPluginState, }: HyperlinkAddToolbarProps & {
+    hyperlinkPluginState: HyperlinkState;
+}): JSX.Element;

package/dist/types-ts4.5/link/LinkPicker/HyperlinkAddToolbar/messages.d.ts

@@ -0,0 +1,32 @@
+export declare const utilMessages: {
+    hyperlinkIconIssueLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    hyperlinkIconBugLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    hyperlinkIconStoryLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    hyperlinkIconTaskLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    hyperlinkIconPageLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    hyperlinkIconBlogLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.5/link/LinkPicker/HyperlinkAddToolbar/utils.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { LinkContentType } from '../../../provider-factory';
+export declare function filterUniqueItems<T>(arr: Array<T>, comparator?: (firstItem: T, secondItem: T) => boolean): Array<T>;
+export declare const mapContentTypeToIcon: {
+    [key in LinkContentType]?: React.ReactElement;
+};
+export declare const sha1: (input: string) => string;
+export declare const wordCount: (input: string) => number;

package/dist/types-ts4.5/link/LinkSearch/LinkSearchList.d.ts

@@ -0,0 +1,20 @@
+/** @jsx jsx */
+import { PureComponent } from 'react';
+import { jsx } from '@emotion/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.5/link/LinkSearch/LinkSearchListItem.d.ts

@@ -0,0 +1,22 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { LinkSearchListItemData } from './types';
+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.5/link/LinkSearch/ToolbarComponents.d.ts

@@ -0,0 +1,3 @@
+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.5/link/LinkSearch/index.d.ts

@@ -0,0 +1,59 @@
+import React from 'react';
+import { RecentSearchProps } from './types';
+import { WithActivityProviderProps } from './withActivityProvider';
+declare const _default: {
+    new (props: Readonly<import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>): {
+        renderNode: (providers: import("../../provider-factory").Providers) => JSX.Element;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("../../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("../../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("../../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("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps, context?: any): {
+        renderNode: (providers: import("../../provider-factory").Providers) => JSX.Element;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("../../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("../../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("../../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("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<import("../../utils").Diff<RecentSearchProps & WithActivityProviderProps, WithActivityProviderProps> & import("./withActivityProvider").ExpandedActivityProviderProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<import("../../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.5/link/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.5/link/LinkSearch/transformTimeStamp.d.ts

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

package/dist/types-ts4.5/link/LinkSearch/types.d.ts

@@ -0,0 +1,49 @@
+import { KeyboardEvent } from 'react';
+import { ActivityItem, ActivityProvider } from '@atlaskit/activity-provider';
+import { INPUT_METHOD } from '../../analytics';
+export type RecentSearchInputTypes = INPUT_METHOD.TYPEAHEAD | INPUT_METHOD.MANUAL;
+export interface ChildProps {
+    activityProvider: ActivityProvider | null;
+    inputProps: {
+        onChange(input: string): void;
+        onKeyDown(event: KeyboardEvent<any>): void;
+        onSubmit(): void;
+        value: string;
+    };
+    currentInputMethod?: RecentSearchInputTypes;
+    clearValue(): void;
+    renderRecentList(): React.ReactNode;
+}
+export interface RecentSearchSubmitOptions {
+    text: string;
+    url: string;
+    inputMethod: RecentSearchInputTypes;
+}
+export interface RecentSearchProps {
+    defaultUrl?: string;
+    onSubmit(options: RecentSearchSubmitOptions): void;
+    onBlur(options: RecentSearchSubmitOptions): void;
+    render(state: ChildProps): React.ReactNode;
+    limit?: number;
+}
+export interface RecentSearchState {
+    items: Array<ActivityItem>;
+    selectedIndex: number;
+    isLoading: boolean;
+    url: string;
+}
+export type LinkSearchListItemData = {
+    objectId: string;
+    name: string;
+    container: string;
+    url: string;
+    iconUrl?: string | never;
+    icon?: React.ReactChild | never;
+    lastViewedDate?: Date;
+    lastUpdatedDate?: Date;
+    prefetch?: boolean;
+} & ({
+    iconUrl: string;
+} | {
+    icon: React.ReactChild;
+});

package/dist/types-ts4.5/link/LinkSearch/withActivityProvider.d.ts

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

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

@@ -0,0 +1,16 @@
+export { transformTimeStamp } from './LinkSearch/transformTimeStamp';
+export type { LinkSearchListItemData, ChildProps, RecentSearchInputTypes, RecentSearchSubmitOptions, } from './LinkSearch/types';
+export { container, containerWithProvider, inputWrapper, } from './LinkSearch/ToolbarComponents';
+export { default as LinkSearchListItem } from './LinkSearch/LinkSearchListItem';
+export { default as LinkSearchList } from './LinkSearch/LinkSearchList';
+export { default as RecentSearch } from './LinkSearch';
+export type { InsertState, EditInsertedState, EditState, LinkToolbarState, HyperlinkState, } from './types';
+export { InsertStatus, LinkAction } from './types';
+export { EditorLinkPicker } from './LinkPicker/EditorLinkPicker';
+export type { EditorLinkPickerProps } from './LinkPicker/EditorLinkPicker';
+export { HyperlinkAddToolbar } from './LinkPicker/HyperlinkAddToolbar';
+export { default as HyperlinkLinkAddToolbar, HyperlinkLinkAddToolbarWithIntl, RECENT_SEARCH_LIST_SIZE, } from './LinkPicker/HyperlinkAddToolbar/HyperlinkAddToolbar';
+export type { Props as HyperlinkLinkAddToolbarProps } from './LinkPicker/HyperlinkAddToolbar/HyperlinkAddToolbar';
+export type { HyperlinkAddToolbarProps } from './LinkPicker/HyperlinkAddToolbar';
+export { sha1 } from './LinkPicker/HyperlinkAddToolbar/utils';
+export { isLinkAtPos, isTextAtPos } from './utils';

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

@@ -0,0 +1,40 @@
+import { Node } from 'prosemirror-model';
+import { INPUT_METHOD } from '../analytics';
+import type { EditorAppearance } from '../types';
+export declare enum LinkAction {
+    SHOW_INSERT_TOOLBAR = "SHOW_INSERT_TOOLBAR",
+    HIDE_TOOLBAR = "HIDE_TOOLBAR",
+    SELECTION_CHANGE = "SELECTION_CHANGE",
+    INSERT_LINK_TOOLBAR = "INSERT",
+    EDIT_INSERTED_TOOLBAR = "EDIT_INSERTED_TOOLBAR"
+}
+export declare enum InsertStatus {
+    EDIT_LINK_TOOLBAR = "EDIT",
+    INSERT_LINK_TOOLBAR = "INSERT",
+    EDIT_INSERTED_TOOLBAR = "EDIT_INSERTED"
+}
+export type InsertState = {
+    type: InsertStatus.INSERT_LINK_TOOLBAR;
+    from: number;
+    to: number;
+};
+export type EditInsertedState = {
+    type: InsertStatus.EDIT_INSERTED_TOOLBAR;
+    node: Node;
+    pos: number;
+};
+export type EditState = {
+    type: InsertStatus.EDIT_LINK_TOOLBAR;
+    node: Node;
+    pos: number;
+};
+export type LinkToolbarState = EditState | EditInsertedState | InsertState | undefined;
+export interface HyperlinkState {
+    activeText?: string;
+    activeLinkMark?: LinkToolbarState;
+    timesViewed: number;
+    canInsertLink: boolean;
+    searchSessionId?: string;
+    inputMethod?: INPUT_METHOD;
+    editorAppearance?: EditorAppearance;
+}

package/dist/types-ts4.5/link/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Predicate } from '../types';
+export declare function isTextAtPos(pos: number): Predicate;
+export declare function isLinkAtPos(pos: number): Predicate;

package/dist/types-ts4.5/quick-insert/assets/action.d.ts

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

package/dist/types-ts4.5/quick-insert/assets/code.d.ts

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

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

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

package/dist/types-ts4.5/quick-insert/assets/date.d.ts

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

package/dist/types-ts4.5/quick-insert/assets/decision.d.ts

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

package/dist/types-ts4.5/quick-insert/assets/divider.d.ts

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

package/dist/types-ts4.5/quick-insert/assets/emoji.d.ts

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