@atlaskit/editor-common 76.9.1 → 76.10.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 type { 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,38 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { 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 using paletteColorTooltipMessages option.
+         */
+        paletteColorTooltipMessages?: PaletteTooltipMessages;
+    };
+}
+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/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,12 @@
+import type { 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;
+};
+export declare const getTokenCSSVariableValue: (variableExpression: string) => string;

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 type { 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/ColorPickerButton/index.d.ts

@@ -0,0 +1,28 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import type { PaletteColor, PaletteTooltipMessages } from '../../ui-color';
+type Props = WithAnalyticsEventsProps & {
+    currentColor?: string;
+    title?: string;
+    onChange?: (color: PaletteColor) => void;
+    colorPalette: PaletteColor[];
+    placement: string;
+    cols?: number;
+    alignX?: 'left' | 'right' | 'center' | 'end';
+    size?: {
+        width: string;
+        height: string;
+    };
+    mountPoint?: HTMLElement;
+    setDisableParentScroll?: (disable: boolean) => void;
+    hexToPaletteColor?: (hexColor: string) => string | undefined;
+    paletteColorTooltipMessages?: PaletteTooltipMessages;
+    /**
+     * After picking the color the default behaviour is to focus the color picker button.
+     * To prevent this use skipFocusButtonAfterPick.
+     */
+    skipFocusButtonAfterPick?: boolean;
+};
+declare const _default: React.ForwardRefExoticComponent<Pick<Omit<Props, keyof WithAnalyticsEventsProps> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "onChange" | "title" | "key" | "size" | "placement" | "alignX" | "currentColor" | "analyticsContext" | "cols" | "hexToPaletteColor" | "paletteColorTooltipMessages" | "colorPalette" | "mountPoint" | "setDisableParentScroll" | "skipFocusButtonAfterPick"> & React.RefAttributes<any>>;
+export default _default;

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

@@ -0,0 +1,44 @@
+import React, { PureComponent } from 'react';
+import type { WithOutsideClickProps } from '../../ui-react/with-react-editor-view-outer-listeners';
+import type { OpenChangedEvent } from '../../ui/DropList';
+import type { ArrowKeyNavigationProviderOptions } from '../ArrowKeyNavigationProvider/types';
+export interface Props {
+    children?: React.ReactNode;
+    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;
+    alignDropdownWithParentElement?: boolean;
+}
+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;
+}
+export type DropdownPropsWithOutsideClickProps = Props & WithOutsideClickProps;
+declare const DropdownWithOuterListeners: React.ComponentType<DropdownPropsWithOutsideClickProps>;
+export default DropdownWithOuterListeners;

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

@@ -0,0 +1,3 @@
+/** @jsx jsx */
+import React from 'react';
+export declare const DropdownContainer: React.NamedExoticComponent<import("../Dropdown").Props & import("../../ui-react/with-react-editor-view-outer-listeners").WithOutsideClickProps>;

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

@@ -0,0 +1,22 @@
+import React, { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+import type { 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;
+}
+export declare const DropdownMenuWithKeyboardNavigation: React.FC<any>;

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/ToolbarArrowKeyNavigationProvider/index.d.ts

@@ -0,0 +1,31 @@
+/** @jsx jsx */
+import type { ReactNode } from 'react';
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { IntlShape } from 'react-intl-next/src/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { EditorAppearance } from '../../types';
+import type { UseStickyToolbarType } from '../../ui';
+export interface KeyDownHandlerContext {
+    handleArrowLeft: () => void;
+    handleArrowRight: () => void;
+    handleTab: () => void;
+}
+export declare const KeyDownHandlerContext: React.Context<KeyDownHandlerContext>;
+/**
+ * This component is a wrapper of main toolbar which listens to keydown events of children
+ * and handles left/right arrow key navigation for all focusable elements
+ * @param
+ * @returns
+ */
+export declare const ToolbarArrowKeyNavigationProvider: ({ children, editorView, childComponentSelector, handleEscape, disableArrowKeyNavigation, isShortcutToFocusToolbar, editorAppearance, useStickyToolbar, intl, }: {
+    children: ReactNode;
+    editorView?: EditorView | undefined;
+    childComponentSelector: string;
+    handleEscape?: ((event: KeyboardEvent) => void) | undefined;
+    disableArrowKeyNavigation?: boolean | undefined;
+    isShortcutToFocusToolbar?: ((event: KeyboardEvent) => boolean) | undefined;
+    editorAppearance?: EditorAppearance | undefined;
+    useStickyToolbar?: UseStickyToolbarType | undefined;
+    intl: IntlShape;
+}) => jsx.JSX.Element;

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

@@ -0,0 +1,57 @@
+/** @jsx jsx */
+import React from 'react';
+import type { ButtonProps } from '@atlaskit/button/types';
+import type { PositionType } from '@atlaskit/tooltip';
+import { TOOLBAR_ACTION_SUBJECT_ID } from '../../analytics';
+import type { 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?: "default" | "none" | "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,11 @@
+export { default as DropdownMenu, DropdownMenuWithKeyboardNavigation, } from './DropdownMenu';
+export type { MenuItem } from './DropdownMenu';
+export { default as ToolbarButton, TOOLBAR_BUTTON } from './ToolbarButton';
+export type { ToolbarButtonRef } from './ToolbarButton';
+export { ArrowKeyNavigationProvider } from './ArrowKeyNavigationProvider';
+export { ToolbarArrowKeyNavigationProvider, KeyDownHandlerContext, } from './ToolbarArrowKeyNavigationProvider';
+export { ArrowKeyNavigationType } from './ArrowKeyNavigationProvider/types';
+export { ColorPaletteArrowKeyNavigationProvider } from './ArrowKeyNavigationProvider/ColorPaletteArrowKeyNavigationProvider';
+export { default as Dropdown } from './Dropdown';
+export { default as ColorPickerButton } from './ColorPickerButton';
+export { DropdownContainer } from './DropdownContainer';

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import { EditorView } from '@atlaskit/editor-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,12 @@
+import type { ComponentClass, StatelessComponent } from 'react';
+import React 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 '@atlaskit/editor-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,50 @@
+import { BreakoutMarkAttrs } from '@atlaskit/adf-schema';
+import { BreakoutMode } from '../types/breakout';
+/**
+ * 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;
+export declare const getNextBreakoutMode: (currentMode?: BreakoutMode) => BreakoutMode;
+export declare const getTitle: (layout?: BreakoutMode) => {
+    id: string;
+    defaultMessage: string;
+    description: string;
+};

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/commands.d.ts

@@ -0,0 +1,48 @@
+import { Fragment, Node as PMNode, ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import { EditorAnalyticsAPI } from '../analytics';
+import type { Command, Predicate } from '../types';
+export type WalkNode = {
+    $pos: ResolvedPos;
+    foundNode: boolean;
+};
+export declare const filter: (predicates: Predicate[] | Predicate, cmd: Command) => Command;
+/**
+ * Walk forwards from a position until we encounter the (inside) start of
+ * the next node, or reach the end of the document.
+ *
+ * @param $startPos Position to start walking from.
+ */
+export declare const walkNextNode: ($startPos: ResolvedPos) => WalkNode;
+/**
+ * Walk backwards from a position until we encounter the (inside) end of
+ * the previous node, or reach the start of the document.
+ *
+ * @param $startPos Position to start walking from.
+ */
+export declare const walkPrevNode: ($startPos: ResolvedPos) => WalkNode;
+export declare function insertNewLine(): Command;
+export declare const insertNewLineWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Command;
+export declare const createNewParagraphAbove: Command;
+export declare const createNewParagraphBelow: Command;
+export declare function createParagraphNear(append?: boolean): Command;
+export declare function atTheEndOfDoc(state: EditorState): boolean;
+export declare function atTheBeginningOfDoc(state: EditorState): boolean;
+/**
+ * If the selection is empty, is inside a paragraph node and `canNextNodeMoveUp` is true then delete current paragraph
+ * and move the node below it up. The selection will be retained, to be placed in the moved node.
+ *
+ * @param canNextNodeMoveUp check if node directly after the selection is able to be brought up to selection
+ * @returns PM Command
+ */
+export declare const deleteEmptyParagraphAndMoveBlockUp: (canNextNodeMoveUp: (nextNode: PMNode) => boolean) => Command;
+export declare const insertContentDeleteRange: (tr: Transaction, getSelectionResolvedPos: (tr: Transaction) => ResolvedPos, insertions: [
+    Fragment,
+    number
+][], deletions: [
+    number,
+    number
+][]) => void;
+export declare const isEmptySelectionAtStart: (state: EditorState) => boolean;
+export declare const isEmptySelectionAtEnd: (state: EditorState) => boolean;
+export { filter as filterCommand };