@atlaskit/editor-common 74.0.0 → 74.1.0

package/dist/types-ts4.5/ui-color/ColorPalette/Palettes/panelBackgroundPalette.d.ts

@@ -0,0 +1,4 @@
+import { PaletteColor } from './type';
+/** this is not new usage - old code extracted from editor-core */
+export declare const panelBackgroundPalette: PaletteColor[];
+export declare const panelDarkModeBackgroundPalette: PaletteColor[];

package/dist/types-ts4.5/ui-color/ColorPalette/Palettes/statusColorPalette.d.ts

@@ -0,0 +1,4 @@
+import { PaletteColor } from './type';
+/** this is not new usage - old code extracted from editor-core */
+export declare const lightModeStatusColorPalette: PaletteColor[];
+export declare const darkModeStatusColorPalette: PaletteColor[];

package/dist/types-ts4.5/ui-color/ColorPalette/Palettes/textColorPalette.d.ts

@@ -0,0 +1,2 @@
+import { PaletteColor } from './type';
+export declare const textColorPalette: Array<PaletteColor>;

package/dist/types-ts4.5/ui-color/ColorPalette/Palettes/type.d.ts

@@ -0,0 +1,12 @@
+import { MessageDescriptor } from 'react-intl-next';
+export interface PaletteColor {
+    value: string;
+    label: string;
+    border: string;
+    message?: MessageDescriptor;
+}
+export type Palette = Array<PaletteColor>;
+export type PaletteTooltipMessages = {
+    dark: Record<string, MessageDescriptor>;
+    light: Record<string, MessageDescriptor>;
+};

package/dist/types-ts4.5/ui-color/ColorPalette/index.d.ts

@@ -0,0 +1,50 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { PaletteColor, PaletteTooltipMessages } from './Palettes/type';
+interface Props {
+    selectedColor: string | null;
+    onClick: (value: string, label: string) => void;
+    cols?: number;
+    className?: string;
+    /**
+     * paletteOptions is the prop, where any configuration related to
+     * how palette should look or behave will be added.
+     */
+    paletteOptions: {
+        palette: PaletteColor[];
+        /**
+         * If hexToPaletteColor is passed, it will be called to convert
+         *  hexCodes passed in palette props to DST token.
+         * Different color palette will set different mapping function.
+         * Such as text and background color palette uses different
+         *  mapping function to map tokens.
+         */
+        hexToPaletteColor?: (hexColor: string) => string | undefined;
+        /**
+         * We have pivoted from having logic inside ColorPalette determining
+         *  which tooltip messages should be used to consumer of ColorPalette giving
+         *  tooltip messages. Which is same as palette, where consumer determines which
+         *  colors ColorPalette should render.
+         * Same way now consumer will determine which tooltip messages should
+         *  be used using paletteColorTooltipMessages option.
+         */
+        paletteColorTooltipMessages?: PaletteTooltipMessages;
+        /**
+         * If true then color tooltips in the color picker for all color palettes
+         * such as text, background and table charts will show semantic names.
+         * @default false
+         */
+        showSomewhatSemanticTooltips?: boolean;
+    };
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>; /**
+     * If hexToPaletteColor is passed, it will be called to convert
+     *  hexCodes passed in palette props to DST token.
+     * Different color palette will set different mapping function.
+     * Such as text and background color palette uses different
+     *  mapping function to map tokens.
+     */
+};
+export default _default;

package/dist/types-ts4.5/ui-color/ColorPalette/styles.d.ts

@@ -0,0 +1 @@
+export declare const colorPaletteWrapper: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/ui-color/ColorPalette/utils.d.ts

@@ -0,0 +1,11 @@
+import { PaletteColor } from './Palettes/type';
+export declare const DEFAULT_COLOR_PICKER_COLUMNS = 7;
+export declare function getColorsPerRowFromPalette(palette: PaletteColor[], cols?: number): PaletteColor[][];
+export declare function getSelectedRowAndColumn(colorsPerRow: PaletteColor[][], selectedColor: string | null): {
+    selectedRowIndex: number;
+    selectedColumnIndex: number;
+};
+export declare function getSelectedRowAndColumnFromPalette(palette: PaletteColor[], selectedColor: string | null, cols?: number): {
+    selectedRowIndex: number;
+    selectedColumnIndex: number;
+};

package/dist/types-ts4.5/ui-color/index.d.ts

@@ -0,0 +1,12 @@
+export { default as ColorPalette } from './ColorPalette';
+export { default as Color } from './ColorPalette/Color';
+export { DEFAULT_COLOR_PICKER_COLUMNS, getColorsPerRowFromPalette, getSelectedRowAndColumn, getSelectedRowAndColumnFromPalette, } from './ColorPalette/utils';
+export { default as cellBackgroundColorPalette } from './ColorPalette/Palettes/cellBackgroundColorPalette';
+export { default as colorPaletteMessages } from './ColorPalette/Palettes/paletteMessages';
+export { panelBackgroundPalette, panelDarkModeBackgroundPalette, } from './ColorPalette/Palettes/panelBackgroundPalette';
+export { lightModeStatusColorPalette, darkModeStatusColorPalette, } from './ColorPalette/Palettes/statusColorPalette';
+export { textColorPalette } from './ColorPalette/Palettes/textColorPalette';
+export { backgroundPaletteTooltipMessages, borderPaletteTooltipMessages, chartsColorPaletteTooltipMessages, textPaletteTooltipMessages, } from './ColorPalette/Palettes';
+export { DEFAULT_BORDER_COLOR } from './ColorPalette/Palettes/common';
+export type { PaletteColor, PaletteTooltipMessages, } from './ColorPalette/Palettes/type';
+export { default as borderColorPalette } from './ColorPalette/Palettes/borderColorPalette';

package/dist/types-ts4.5/ui-menu/ArrowKeyNavigationProvider/ColorPaletteArrowKeyNavigationProvider/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { ColorPaletteArrowKeyNavigationProps } from '../types';
+/**
+ * This component is a wrapper for color picker which listens to keydown events of children
+ * and handles arrow key navigation
+ */
+export declare const ColorPaletteArrowKeyNavigationProvider: React.FC<Omit<ColorPaletteArrowKeyNavigationProps, 'type'>>;

package/dist/types-ts4.5/ui-menu/ArrowKeyNavigationProvider/MenuArrowKeyNavigationProvider/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { MenuArrowKeyNavigationProviderProps } from '../types';
+/**
+ * This component is a wrapper of vertical menus which listens to keydown events of children
+ * and handles up/down arrow key navigation
+ */
+export declare const MenuArrowKeyNavigationProvider: React.FC<Omit<MenuArrowKeyNavigationProviderProps, 'type'>>;

package/dist/types-ts4.5/ui-menu/ArrowKeyNavigationProvider/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { ArrowKeyNavigationProviderProps } from './types';
+export declare const ArrowKeyNavigationProvider: React.FC<ArrowKeyNavigationProviderProps>;

package/dist/types-ts4.5/ui-menu/ArrowKeyNavigationProvider/types.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="react" />
+export interface KeyDownHandlerContext {
+    handleArrowRight: () => void;
+    handleArrowLeft: () => void;
+    handleTab: () => void;
+}
+export type SimpleEventHandler<T> = (event: T) => void;
+export declare enum ArrowKeyNavigationType {
+    COLOR = "color",
+    MENU = "menu"
+}
+export type ColorPaletteArrowKeyNavigationOptions = {
+    type: ArrowKeyNavigationType.COLOR;
+    selectedRowIndex: number;
+    selectedColumnIndex: number;
+    isOpenedByKeyboard: boolean;
+    isPopupPositioned: boolean;
+};
+export type ColorPaletteArrowKeyNavigationProps = ColorPaletteArrowKeyNavigationOptions & {
+    handleClose?: SimpleEventHandler<KeyboardEvent>;
+    closeOnTab?: boolean;
+    editorRef: React.RefObject<HTMLDivElement>;
+};
+export type MenuArrowKeyNavigationOptions = {
+    type: ArrowKeyNavigationType.MENU;
+    disableArrowKeyNavigation?: boolean;
+    keyDownHandlerContext?: KeyDownHandlerContext;
+};
+export type MenuArrowKeyNavigationProviderProps = MenuArrowKeyNavigationOptions & {
+    handleClose?: SimpleEventHandler<KeyboardEvent>;
+    onSelection?: (index: number) => void;
+    closeOnTab?: boolean;
+    editorRef: React.RefObject<HTMLDivElement>;
+};
+export type ArrowKeyNavigationProviderOptions = ColorPaletteArrowKeyNavigationOptions | MenuArrowKeyNavigationOptions;
+export type ArrowKeyNavigationProviderProps = Omit<ColorPaletteArrowKeyNavigationProps, 'editorRef'> | Omit<MenuArrowKeyNavigationProviderProps, 'editorRef'>;

package/dist/types-ts4.5/ui-menu/Dropdown/index.d.ts

@@ -0,0 +1,40 @@
+import React, { PureComponent } from 'react';
+import { OpenChangedEvent } from '../../ui/DropList';
+import { ArrowKeyNavigationProviderOptions } from '../ArrowKeyNavigationProvider/types';
+export interface Props {
+    mountTo?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    trigger: React.ReactElement<any>;
+    isOpen?: boolean;
+    onOpenChange?: (attrs: OpenChangedEvent) => void;
+    fitWidth?: number;
+    fitHeight?: number;
+    zIndex?: number;
+    arrowKeyNavigationProviderOptions: ArrowKeyNavigationProviderOptions;
+    dropdownListId?: string;
+}
+export interface State {
+    target?: HTMLElement;
+    popupPlacement: [
+        string,
+        string
+    ];
+}
+/**
+ * Wrapper around @atlaskit/droplist which uses Popup and Portal to render
+ * droplist outside of "overflow: hidden" containers when needed.
+ *
+ * Also it controls popper's placement.
+ */
+export declare class Dropdown extends PureComponent<Props, State> {
+    constructor(props: Props);
+    private handleRef;
+    private updatePopupPlacement;
+    private handleCloseAndFocus;
+    private handleClose;
+    private renderDropdown;
+    render(): JSX.Element;
+}
+declare const DropdownWithOuterListeners: React.FC<Props & import("../../ui-react/with-react-editor-view-outer-listeners").WithOutsideClickProps>;
+export default DropdownWithOuterListeners;

package/dist/types-ts4.5/ui-menu/DropdownMenu/index.d.ts

@@ -0,0 +1,22 @@
+/** @jsx jsx */
+import { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+import { Props, State } from './types';
+export type { MenuItem } from './types';
+/**
+ * Wrapper around @atlaskit/droplist which uses Popup and Portal to render
+ * dropdown-menu outside of "overflow: hidden" containers when needed.
+ *
+ * Also it controls popper's placement.
+ */
+export default class DropdownMenuWrapper extends PureComponent<Props, State> {
+    state: State;
+    private popupRef;
+    private handleRef;
+    private updatePopupPlacement;
+    private handleCloseAndFocus;
+    private handleClose;
+    private renderDropdownMenu;
+    render(): jsx.JSX.Element;
+    componentDidUpdate(previousProps: Props): void;
+}

package/dist/types-ts4.5/ui-menu/DropdownMenu/types.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+import { EditorActionsOptions as EditorActions } from '../../types';
+import { ArrowKeyNavigationProviderOptions } from '../ArrowKeyNavigationProvider/types';
+export interface Props {
+    mountTo?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    isOpen?: boolean;
+    onOpenChange?: (attrs: any) => void;
+    onItemActivated?: (attrs: any) => void;
+    onMouseEnter?: (attrs: any) => void;
+    onMouseLeave?: (attrs: any) => void;
+    fitWidth?: number;
+    fitHeight?: number;
+    offset?: Array<number>;
+    zIndex?: number;
+    items: Array<{
+        items: MenuItem[];
+    }>;
+    shouldUseDefaultRole?: boolean;
+    disableArrowKeyNavigation?: boolean;
+    shouldFocusFirstItem?: () => boolean;
+    arrowKeyNavigationProviderOptions: ArrowKeyNavigationProviderOptions;
+}
+export interface MenuItem {
+    key?: string;
+    content: string | React.ReactChild | React.ReactFragment;
+    value: {
+        name: string;
+    };
+    shortcut?: string;
+    elemBefore?: React.ReactElement<any>;
+    elemAfter?: React.ReactElement<any>;
+    tooltipDescription?: string;
+    tooltipPosition?: string;
+    isActive?: boolean;
+    isDisabled?: boolean;
+    handleRef?: any;
+    className?: string;
+    'aria-label'?: React.AriaAttributes['aria-label'];
+    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
+    'aria-keyshortcuts'?: React.AriaAttributes['aria-keyshortcuts'];
+    onClick?: (editorActions: EditorActions) => void;
+}
+export interface State {
+    target?: HTMLElement;
+    popupPlacement: [
+        string,
+        string
+    ];
+    selectionIndex: number;
+}

package/dist/types-ts4.5/ui-menu/ToolbarButton/index.d.ts

@@ -0,0 +1,57 @@
+/** @jsx jsx */
+import React from 'react';
+import { ButtonProps } from '@atlaskit/button/types';
+import { PositionType } from '@atlaskit/tooltip';
+import { TOOLBAR_ACTION_SUBJECT_ID } from '../../analytics';
+import { MenuItem } from '../DropdownMenu';
+export declare const TOOLBAR_BUTTON: typeof TOOLBAR_ACTION_SUBJECT_ID;
+export type Props = {
+    buttonId?: TOOLBAR_ACTION_SUBJECT_ID;
+    className?: string;
+    disabled?: boolean;
+    hideTooltip?: boolean;
+    href?: string;
+    iconAfter?: React.ReactElement<any>;
+    iconBefore?: React.ReactElement<any>;
+    onClick?: (event: React.MouseEvent<HTMLElement>) => void;
+    onItemClick?: (item: MenuItem) => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLElement>) => void;
+    selected?: boolean;
+    spacing?: 'default' | 'compact' | 'none';
+    target?: string;
+    title?: React.ReactNode;
+    titlePosition?: PositionType;
+    item?: MenuItem;
+    testId?: string;
+    'aria-label'?: React.AriaAttributes['aria-label'];
+    'aria-expanded'?: React.AriaAttributes['aria-expanded'];
+    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
+    'aria-pressed'?: React.AriaAttributes['aria-pressed'];
+    'aria-keyshortcuts'?: React.AriaAttributes['aria-keyshortcuts'];
+} & Pick<ButtonProps, 'aria-label' | 'children'>;
+export type ToolbarButtonRef = HTMLElement;
+declare const ToolbarButton: React.ForwardRefExoticComponent<{
+    buttonId?: TOOLBAR_ACTION_SUBJECT_ID | undefined;
+    className?: string | undefined;
+    disabled?: boolean | undefined;
+    hideTooltip?: boolean | undefined;
+    href?: string | undefined;
+    iconAfter?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+    iconBefore?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+    onClick?: ((event: React.MouseEvent<HTMLElement>) => void) | undefined;
+    onItemClick?: ((item: MenuItem) => void) | undefined;
+    onKeyDown?: ((event: React.KeyboardEvent<HTMLElement>) => void) | undefined;
+    selected?: boolean | undefined;
+    spacing?: "none" | "default" | "compact" | undefined;
+    target?: string | undefined;
+    title?: React.ReactNode;
+    titlePosition?: PositionType | undefined;
+    item?: MenuItem | undefined;
+    testId?: string | undefined;
+    'aria-label'?: React.AriaAttributes['aria-label'];
+    'aria-expanded'?: React.AriaAttributes['aria-expanded'];
+    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
+    'aria-pressed'?: React.AriaAttributes['aria-pressed'];
+    'aria-keyshortcuts'?: React.AriaAttributes['aria-keyshortcuts'];
+} & Pick<ButtonProps, "children" | "aria-label"> & React.RefAttributes<HTMLElement>>;
+export default ToolbarButton;

package/dist/types-ts4.5/ui-menu/ToolbarButton/styles.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ButtonProps } from '@atlaskit/button/standard-button';
+declare const _default: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLElement>>;
+export default _default;

package/dist/types-ts4.5/ui-menu/index.d.ts

@@ -0,0 +1,8 @@
+export { default as DropdownMenu } from '../ui-menu/DropdownMenu';
+export type { MenuItem } from '../ui-menu/DropdownMenu';
+export { default as ToolbarButton, TOOLBAR_BUTTON, } from '../ui-menu/ToolbarButton';
+export type { ToolbarButtonRef } from '../ui-menu/ToolbarButton';
+export { ArrowKeyNavigationProvider } from '../ui-menu/ArrowKeyNavigationProvider';
+export { ArrowKeyNavigationType } from '../ui-menu/ArrowKeyNavigationProvider/types';
+export { ColorPaletteArrowKeyNavigationProvider } from './ArrowKeyNavigationProvider/ColorPaletteArrowKeyNavigationProvider';
+export { default as Dropdown } from './Dropdown';

package/dist/types-ts4.5/ui-react/ReactEditorViewContext.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { EditorView } from 'prosemirror-view';
+type ReactEditorViewContextProps = {
+    editorView?: EditorView;
+    editorRef?: React.RefObject<HTMLDivElement>;
+};
+declare const ReactEditorViewContext: React.Context<ReactEditorViewContextProps>;
+export default ReactEditorViewContext;

package/dist/types-ts4.5/ui-react/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ReactEditorViewContext } from './ReactEditorViewContext';
+export { default as withReactEditorViewOuterListeners } from './with-react-editor-view-outer-listeners';

package/dist/types-ts4.5/ui-react/with-react-editor-view-outer-listeners.d.ts

@@ -0,0 +1,11 @@
+import React, { ComponentClass, StatelessComponent } from 'react';
+type SimpleEventHandler<T> = (event: T) => void;
+export interface WithOutsideClickProps {
+    handleClickOutside?: SimpleEventHandler<MouseEvent>;
+    handleEscapeKeydown?: SimpleEventHandler<KeyboardEvent>;
+    handleEnterKeydown?: SimpleEventHandler<KeyboardEvent>;
+    targetRef?: any;
+    closeOnTab?: boolean;
+}
+export default function withReactEditorViewOuterListeners<P extends {}>(Component: ComponentClass<P> | StatelessComponent<P>): React.FC<P & WithOutsideClickProps>;
+export {};

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

@@ -0,0 +1,29 @@
+import { EDITOR_APPEARANCE_CONTEXT } from '@atlaskit/analytics-namespaced-context';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '../analytics';
+export declare const getAnalyticsAppearance: (appearance?: string) => EDITOR_APPEARANCE_CONTEXT | undefined;
+export declare const getAnalyticsEditorAppearance: (editorAppearance?: string) => string;
+export declare const getAnalyticsEventSeverity: (duration: number, normalThreshold: number, degradedThreshold: number) => SEVERITY;
+export declare enum SEVERITY {
+    NORMAL = "normal",
+    DEGRADED = "degraded",
+    BLOCKING = "blocking"
+}
+export { UNSUPPORTED_CONTENT_LEVEL_SEVERITY, getUnsupportedContentLevelData, UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS, } from './unsupportedContent/get-unsupported-content-level-data';
+export type { UnsupportedContentLevelsTracking } from './unsupportedContent/get-unsupported-content-level-data';
+type AEP<Action, ActionSubject, ActionSubjectID, Attributes, EventType> = {
+    action: Action;
+    actionSubject: ActionSubject;
+    actionSubjectId?: ActionSubjectID;
+    attributes?: Attributes;
+    eventType: EventType;
+};
+type TrackAEP<Action, ActionSubject, ActionSubjectID, Attributes> = AEP<Action, ActionSubject, ActionSubjectID, Attributes, EVENT_TYPE.TRACK>;
+type UnsupportedContentEncounteredAEP = TrackAEP<ACTION.UNSUPPORTED_CONTENT_ENCOUNTERED, ACTION_SUBJECT.DOCUMENT, ACTION_SUBJECT_ID, {
+    unsupportedNode: Record<string, any>;
+    errorCode?: String;
+}>;
+export type UnsupportedContentPayload = UnsupportedContentEncounteredAEP;
+export type UnsupportedContentTooltipPayload = AEP<ACTION.UNSUPPORTED_TOOLTIP_VIEWED, ACTION_SUBJECT.TOOLTIP, ACTION_SUBJECT_ID.ON_UNSUPPORTED_BLOCK | ACTION_SUBJECT_ID.ON_UNSUPPORTED_INLINE, {
+    unsupportedNodeType: string | undefined;
+}, EVENT_TYPE.UI>;
+export declare const analyticsEventKey = "EDITOR_ANALYTICS_EVENT";

package/dist/types-ts4.5/utils/annotation/index.d.ts

@@ -0,0 +1,8 @@
+import { Node as PMNode, Schema } from 'prosemirror-model';
+type Range = {
+    from: number;
+    to: number;
+};
+export declare const canApplyAnnotationOnRange: (rangeSelection: Range, doc: PMNode, schema: Schema) => boolean;
+export declare const getAnnotationIdsFromRange: (rangeSelection: Range, doc: PMNode, schema: Schema) => string[];
+export {};

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

@@ -0,0 +1,43 @@
+import { BreakoutMarkAttrs } from '@atlaskit/adf-schema';
+/**
+ * Variables required to construct a context for breakout ssr inline script.
+ *
+ * TODO: Clean this up after: https://product-fabric.atlassian.net/browse/ED-8942
+ */
+declare const breakoutConsts: any;
+export declare const absoluteBreakoutWidth: (layout: 'full-width' | 'wide' | string, containerWidth: number) => any;
+export { breakoutConsts };
+export declare const calcWideWidth: any;
+export declare const calcBreakoutWidth: any;
+export declare function calculateBreakoutStyles({ mode, widthStateLineLength, widthStateWidth, }: {
+    mode: BreakoutMarkAttrs['mode'];
+    /**
+     * offsetWidth of the content the editor is attached to.
+     * Expected to be retrieved via `WidthState.lineLength`.
+     */
+    widthStateWidth?: number;
+    /**
+     * clientWidth of the content area in the editor (ie. EditorPlugin contentComponents).
+     * Expected to be retrieved via `WidthState.width`.
+     */
+    widthStateLineLength?: number;
+}): {
+    type: "line-length-unknown";
+    width: any;
+    minWidth: number;
+    display: string;
+    justifyContent: string;
+    transform: string;
+    transition: string;
+    marginLeft?: undefined;
+} | {
+    type: "line-length-known";
+    width: any;
+    minWidth: number;
+    transition: string;
+    transform: string;
+    marginLeft: string;
+    display?: undefined;
+    justifyContent?: undefined;
+};
+export declare function calcBreakoutWidthPx(mode: BreakoutMarkAttrs['mode'], widthStateWidth?: number): number;

package/dist/types-ts4.5/utils/browser-extensions.d.ts

@@ -0,0 +1,43 @@
+type UserBrowserExtension = 'grammarly';
+export type UserBrowserExtensionResults = UserBrowserExtension[];
+type BaseOptions = {
+    extensions: UserBrowserExtension[];
+};
+type AsyncOptions = BaseOptions & {
+    async: true;
+    asyncTimeoutMs: number;
+};
+type SyncOptions = BaseOptions & {
+    async?: false;
+    asyncTimeoutMs?: never;
+};
+type Options = BaseOptions & (SyncOptions | AsyncOptions);
+/**
+ * Call this to return a list (or a Promise of a list) of detected browser extensions.
+ *
+ * This function supports a **synchronous** and **asynchronous** mode through options. You
+ * must pass a list of the browser extension names you want to target for detection.
+ * Only UserBrowserExtension extensions are supported, other target names will be silently
+ * ignored.
+ *
+ * If the async option is enabled, you must also pass a final timeout by when it
+ * should stop all detection attempts and return any partially detected extensions.
+ *
+ * Example usage:
+ * ```
+ * // synchronously/immediately check for extensions
+ * const extensions = sniffUserBrowserExtensions({ extensions: ['grammarly', 'requestly'] });
+ * // result will be ['grammarly'] or ['grammarly','requestly'] or ['requestly'] or [];
+ *
+ * // asynchronously check for extensions up to 30s
+ * sniffUserBrowserExtensions({
+ *    extensions: ['grammarly', 'requestly'],
+ *    async: true,
+ *    asyncTimeoutMs: 30000,
+ *  }).then(extensions => {
+ *    // result will be  ['grammarly'] or ['grammarly','requestly'] or ['requestly'] or [];
+ *  })
+ * ```
+ */
+export declare function sniffUserBrowserExtensions<O extends Options>(options: O): O extends AsyncOptions ? Promise<UserBrowserExtensionResults> : UserBrowserExtensionResults;
+export {};

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

@@ -0,0 +1,4 @@
+declare const result: {
+    [key: string]: any;
+};
+export default result;

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

@@ -0,0 +1,2 @@
+import { EditorState } from 'prosemirror-state';
+export declare const getParticipantsCount: (editorState?: EditorState) => any;

package/dist/types-ts4.5/utils/compare-props.d.ts

@@ -0,0 +1,32 @@
+type ChangedData<T> = {
+    key: keyof T;
+    difference?: any;
+    maxDepthReached?: boolean;
+    newValue?: any;
+    oldValue?: any;
+    reactElementChanged?: boolean;
+};
+type Changed<T> = Array<ChangedData<T>>;
+export type PropsDifference<T> = {
+    removed: Array<keyof T>;
+    added: Array<keyof T>;
+    changed: Changed<T>;
+};
+export type ShallowPropsDifference<T> = {
+    removed: Array<keyof T>;
+    added: Array<keyof T>;
+    changed: Array<keyof T>;
+};
+export declare const getKeys: <T>(obj: T) => (keyof T)[];
+export declare const getKeysAddedRemovedCommon: <T>(object1: T, object2: T) => {
+    added: (keyof T & keyof (T & {}))[];
+    common: (keyof T & keyof (T & {}))[];
+    removed: (keyof T & keyof (T & {}))[];
+};
+export declare const serializeValue: <T>(value: T[keyof T]) => string | (T[keyof T] & {}) | {
+    type: string;
+    keys: string[];
+} | undefined;
+export declare const getPropsDifference: <T>(object1: T, object2: T, curDepth?: number, maxDepth?: number, keysToIgnore?: (keyof T)[]) => PropsDifference<T>;
+export declare const getShallowPropsDifference: <T>(object1: T, object2: T) => ShallowPropsDifference<T>;
+export {};

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

@@ -0,0 +1,47 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { CardAttributes } from '@atlaskit/adf-schema';
+import { SortOrder } from '../types';
+export declare enum ContentType {
+    NUMBER = 0,
+    TEXT = 5,
+    MENTION = 10,
+    DATE = 15,
+    STATUS = 20,
+    LINK = 25
+}
+interface CompareOptions {
+    getInlineCardTextFromStore(attrs: CardAttributes): string | null;
+}
+interface NodeMetaGenerator<Type, Value> {
+    type: Type;
+    value: Value;
+}
+type TextNodeMeta = NodeMetaGenerator<ContentType.TEXT, string>;
+type NodeMeta = TextNodeMeta | NodeMetaGenerator<ContentType.NUMBER, number> | NodeMetaGenerator<ContentType.STATUS, string> | NodeMetaGenerator<ContentType.DATE, number> | NodeMetaGenerator<ContentType.MENTION, string> | NodeMetaGenerator<ContentType.LINK, string>;
+export declare function extractMetaFromTextNode(textNode: PMNode): NodeMeta;
+/**
+ * Compare 2 prosemirror nodes and check if it's greater, equal or less than the other node
+ * based on the sort order.
+ *
+ * @param {Node} nodeA
+ * @param {Node} nodeB
+ * @returns {(1 | 0 | -1)}
+ *
+ * For Ascending order:
+ *    1  -> NodeA > NodeB
+ *    0  -> NodeA === NodeB
+ *    -1 -> Node A < NodeB
+ * For Descending order:
+ *   1  -> NodeA < NodeB
+ *   0  -> NodeA === NodeB
+ *   -1 -> Node A > NodeB
+ *
+ * If either node is empty:
+ * The empty node is always treated as lower priority,
+ * irrespective of the order.
+ *
+ * If no order is provided the method defaults to Ascending order,
+ * like a regular JS sort method.
+ */
+export declare const createCompareNodes: (options: CompareOptions, order?: SortOrder) => Function;
+export {};

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

@@ -0,0 +1,30 @@
+/** Helper type for single arg function */
+type Func<A, B> = (a: A) => B;
+/**
+ * Compose 1 to n functions.
+ * @param func first function
+ * @param funcs additional functions
+ */
+export declare function compose<F1 extends Func<any, any>, FN extends Array<Func<any, any>>, R extends FN extends [
+] ? F1 : FN extends [
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    any,
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    any,
+    any,
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : Func<any, ReturnType<F1>>>(func: F1, ...funcs: FN): R;
+export {};