@atlaskit/editor-core 210.1.5 → 210.1.7

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

@@ -7,18 +7,18 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { LightPMPlugin, LightPMPluginFactoryParams, OnEditorViewStateUpdated } from './create-editor/get-plugins';
 export type { LightEditorPlugin } from './create-editor/get-plugins';
 export interface LightEditorConfig {
-    nodes: NodeConfig[];
-    marks: MarkConfig[];
-    plugins: Array<LightPMPlugin>;
     contentComponents: UIComponentFactory[];
-    pluginHooks: ReactHookFactory[];
+    marks: MarkConfig[];
+    nodes: NodeConfig[];
     onEditorViewStateUpdatedCallbacks: Array<OnEditorViewStateUpdated>;
+    pluginHooks: ReactHookFactory[];
+    plugins: Array<LightPMPlugin>;
 }
 type PluginData = {
+    editorConfig: LightEditorConfig;
+    onEditorViewStateUpdatedCallbacks: Array<OnEditorViewStateUpdated>;
     plugins: Plugin[];
     schema: Schema;
-    onEditorViewStateUpdatedCallbacks: Array<OnEditorViewStateUpdated>;
-    editorConfig: LightEditorConfig;
 };
 export declare const createPMSchemaAndPlugins: (inputPreset?: EditorPresetBuilder) => (pluginFactoryParams: Omit<LightPMPluginFactoryParams, "schema"> & {
     pluginInjectionAPI: EditorPluginInjectionAPI;

package/dist/types/types/editor-appearance-component.d.ts

@@ -12,39 +12,39 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type EditorActions from '../actions';
 import type { ContentComponents, PrimaryToolbarComponents, ReactComponents } from '../types/editor-props';
 export interface EditorAppearanceComponentProps<Plugins extends NextEditorPlugin<any, any>[]> {
-    editorAPI: PublicPluginAPI<Plugins> | undefined;
-    appearance?: EditorAppearance;
     __livePage?: boolean;
-    preset?: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>;
-    onSave?: (editorView: EditorView) => void;
-    onCancel?: (editorView: EditorView) => void;
-    providerFactory: ProviderFactory;
+    appearance?: EditorAppearance;
+    collabEdit?: CollabEditOptions;
+    contentComponents?: UIComponentFactory[];
+    contextPanel?: ReactComponents;
+    customContentComponents?: ContentComponents;
+    customPrimaryToolbarComponents?: PrimaryToolbarComponents;
+    customSecondaryToolbarComponents?: ReactComponents;
+    disabled?: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
     editorActions?: EditorActions;
+    editorAPI: PublicPluginAPI<Plugins> | undefined;
     editorDOMElement: JSX.Element;
     editorView?: EditorView;
+    enableToolbarMinWidth?: boolean;
     eventDispatcher?: EventDispatcher;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    extensionHandlers?: ExtensionHandlers;
+    featureFlags: FeatureFlags;
+    innerRef?: RefObject<HTMLDivElement>;
+    insertMenuItems?: MenuItem[];
     maxHeight?: number;
     minHeight?: number;
-    contentComponents?: UIComponentFactory[];
+    onCancel?: (editorView: EditorView) => void;
+    onSave?: (editorView: EditorView) => void;
+    persistScrollGutter?: boolean;
     pluginHooks?: ReactHookFactory[];
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    preset?: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>;
     primaryToolbarComponents?: ToolbarUIComponentFactory[];
     primaryToolbarIconBefore?: ReactElement;
+    providerFactory: ProviderFactory;
     secondaryToolbarComponents?: UIComponentFactory[];
-    customContentComponents?: ContentComponents;
-    customPrimaryToolbarComponents?: PrimaryToolbarComponents;
-    customSecondaryToolbarComponents?: ReactComponents;
-    insertMenuItems?: MenuItem[];
-    contextPanel?: ReactComponents;
-    popupsMountPoint?: HTMLElement;
-    popupsBoundariesElement?: HTMLElement;
-    popupsScrollableElement?: HTMLElement;
-    extensionHandlers?: ExtensionHandlers;
-    disabled?: boolean;
-    collabEdit?: CollabEditOptions;
-    persistScrollGutter?: boolean;
-    enableToolbarMinWidth?: boolean;
-    featureFlags: FeatureFlags;
     useStickyToolbar?: UseStickyToolbarType;
-    innerRef?: RefObject<HTMLDivElement>;
 }

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

@@ -1,21 +1,21 @@
 import type { MarkConfig, NodeConfig, PMPlugin, ReactHookFactory, ToolbarUIComponentFactory, UIComponentFactory } from '@atlaskit/editor-common/types';
 import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
 export type EditorViewStateUpdatedCallbackProps = {
+    readonly newEditorState: Readonly<EditorState>;
+    readonly oldEditorState: Readonly<EditorState>;
     readonly originalTransaction: Readonly<Transaction>;
     readonly transactions: readonly Transaction[];
-    readonly oldEditorState: Readonly<EditorState>;
-    readonly newEditorState: Readonly<EditorState>;
 };
 export interface EditorConfig {
-    nodes: NodeConfig[];
-    marks: MarkConfig[];
-    pmPlugins: Array<PMPlugin>;
     contentComponents: UIComponentFactory[];
-    pluginHooks: ReactHookFactory[];
-    primaryToolbarComponents: ToolbarUIComponentFactory[];
-    secondaryToolbarComponents: UIComponentFactory[];
+    marks: MarkConfig[];
+    nodes: NodeConfig[];
     onEditorViewStateUpdatedCallbacks: Array<{
-        pluginName: string;
         callback: (props: EditorViewStateUpdatedCallbackProps) => void;
+        pluginName: string;
     }>;
+    pluginHooks: ReactHookFactory[];
+    pmPlugins: Array<PMPlugin>;
+    primaryToolbarComponents: ToolbarUIComponentFactory[];
+    secondaryToolbarComponents: UIComponentFactory[];
 }

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

@@ -4,16 +4,16 @@ import type { MenuItem } from '@atlaskit/editor-common/ui-menu';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { OnEditorViewStateUpdated } from '../create-editor/get-plugins';
 export interface EditorInstance {
+    contentComponents: UIComponentFactory[];
+    contentTransformer?: Transformer<string>;
     editorView: EditorView;
     eventDispatcher: EventDispatcher;
-    contentComponents: UIComponentFactory[];
-    pluginHooks: ReactHookFactory[];
-    primaryToolbarComponents: ToolbarUIComponentFactory[];
-    secondaryToolbarComponents: UIComponentFactory[];
+    insertMenuItems?: MenuItem[];
     onEditorViewStateUpdatedCallbacks: {
-        pluginName: string;
         callback: OnEditorViewStateUpdated;
+        pluginName: string;
     }[];
-    contentTransformer?: Transformer<string>;
-    insertMenuItems?: MenuItem[];
+    pluginHooks: ReactHookFactory[];
+    primaryToolbarComponents: ToolbarUIComponentFactory[];
+    secondaryToolbarComponents: UIComponentFactory[];
 }

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

@@ -1,6 +1,5 @@
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 export type EditorOnChangeHandler = (editorView: EditorView, meta: {
-    source: 'local' | 'remote';
     /**
      * Indicates whether or not the change may be unnecessary to listen to (dirty
      * changes can generally be ignored).
@@ -11,4 +10,5 @@ export type EditorOnChangeHandler = (editorView: EditorView, meta: {
      * We still fire these events however to avoid a breaking change.
      */
     isDirtyChange: boolean;
+    source: 'local' | 'remote';
 }) => void;

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

@@ -34,57 +34,34 @@ type ExtensionProviders = (ExtensionProvider | Promise<ExtensionProvider>)[];
 type ExtensionProvidersWithEditorAction = (editorActions?: EditorActions) => ExtensionProviders;
 export type ExtensionProvidersProp = ExtensionProviders | ExtensionProvidersWithEditorAction;
 export type BeforeAndAfterToolbarComponents = {
-    before: ReactComponents;
     after: ReactComponents;
+    before: ReactComponents;
 };
 export type PrimaryToolbarComponents = BeforeAndAfterToolbarComponents | ReactComponents;
 export type BeforeAndAfterContentComponents = {
-    before: ReactComponents;
     after: ReactComponents;
+    before: ReactComponents;
 };
 export type ContentComponents = BeforeAndAfterContentComponents | ReactComponents;
 interface EditorBaseProps {
+    /**
+     * This is required for accessing whether a page is a live page or not when rendering the appearance component.
+     *
+     * All other consumers should use the editorViewModePlugin to access live page and content mode status.
+     *
+     * @default false
+     */
+    __livePage?: boolean;
     appearance?: EditorAppearance;
+    assistiveLabel?: string;
     contentComponents?: ContentComponents;
-    primaryToolbarIconBefore?: ReactElement;
-    secondaryToolbarComponents?: ReactComponents;
-    persistScrollGutter?: boolean;
-    quickInsert?: QuickInsertOptions;
-    shouldFocus?: boolean;
-    disabled?: boolean;
-    contextPanel?: ReactComponents;
-    errorReporterHandler?: ErrorReportingHandler;
     contentTransformerProvider?: (schema: Schema) => Transformer<string>;
-    maxHeight?: number;
-    minHeight?: number;
+    contextPanel?: ReactComponents;
     defaultValue?: Node | string | Object;
-    assistiveLabel?: string;
-    popupsMountPoint?: HTMLElement;
-    popupsBoundariesElement?: HTMLElement;
-    popupsScrollableElement?: HTMLElement;
+    disabled?: boolean;
     editorActions?: EditorActions;
-    onEditorReady?: (editorActions: EditorActions) => void;
-    onDestroy?: () => void;
-    onChange?: EditorOnChangeHandler;
-    onCancel?: (editorView: EditorView) => void;
-    /**
-     * @deprecated do not use, value is hardcoded. Can be mocked for tests. Config exists here: platform/packages/editor/editor-plugin-base/src/pm-plugins/utils/inputTrackingConfig.ts
-     * @description The nth keystroke after which an input time taken event is sent, 0 to disable it
-     * @default 100
-     */
-    inputSamplingLimit?: number;
+    errorReporterHandler?: ErrorReportingHandler;
     extensionProviders?: ExtensionProvidersProp;
-    UNSAFE_useAnalyticsContext?: boolean;
-    /**
-     * @default undefined
-     * @description
-     * Enables the sticky toolbar in the comment/standard editor.
-     * If a boolean is specified and it's `true`, the sticky toolbar will be enabled, sticking to the top of the scroll parent.
-     * Instead a reference can be specified to an existing sticky toolbar on the page that the editor toolbar should stay below (experimental).
-     * if {offsetTop: number} is passed in, the toolbar is sticky and the toolbar's 'top' will be set to the offsetTop
-     * so the toolbar will sticks to `{offsetTop}` below the scroll parent.
-     */
-    useStickyToolbar?: UseStickyToolbarType;
     /**
      * @default undefined
      * @description
@@ -117,32 +94,57 @@ interface EditorBaseProps {
         [featureFlag: string]: string | boolean;
     };
     /**
-     * This is required for accessing whether a page is a live page or not when rendering the appearance component.
-     *
-     * All other consumers should use the editorViewModePlugin to access live page and content mode status.
-     *
-     * @default false
+     * @deprecated do not use, value is hardcoded. Can be mocked for tests. Config exists here: platform/packages/editor/editor-plugin-base/src/pm-plugins/utils/inputTrackingConfig.ts
+     * @description The nth keystroke after which an input time taken event is sent, 0 to disable it
+     * @default 100
      */
-    __livePage?: boolean;
+    inputSamplingLimit?: number;
+    maxHeight?: number;
+    minHeight?: number;
+    onCancel?: (editorView: EditorView) => void;
+    onChange?: EditorOnChangeHandler;
+    onDestroy?: () => void;
+    onEditorReady?: (editorActions: EditorActions) => void;
+    persistScrollGutter?: boolean;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    primaryToolbarIconBefore?: ReactElement;
+    quickInsert?: QuickInsertOptions;
+    secondaryToolbarComponents?: ReactComponents;
+    shouldFocus?: boolean;
     skipValidation?: boolean;
+    UNSAFE_useAnalyticsContext?: boolean;
+    /**
+     * @default undefined
+     * @description
+     * Enables the sticky toolbar in the comment/standard editor.
+     * If a boolean is specified and it's `true`, the sticky toolbar will be enabled, sticking to the top of the scroll parent.
+     * Instead a reference can be specified to an existing sticky toolbar on the page that the editor toolbar should stay below (experimental).
+     * if {offsetTop: number} is passed in, the toolbar is sticky and the toolbar's 'top' will be set to the offsetTop
+     * so the toolbar will sticks to `{offsetTop}` below the scroll parent.
+     */
+    useStickyToolbar?: UseStickyToolbarType;
 }
 export interface EditorSharedPropsWithPlugins {
+    allowUndoRedoButtons?: boolean;
+    collabEdit?: CollabEditOptions;
     onSave?: (editorView: EditorView) => void;
     /**
      * @deprecated do not use, value is hardcoded. Can be mocked for tests. Config exists here: platform/packages/editor/editor-plugin-base/src/pm-plugins/utils/inputTrackingConfig.ts
      * @description Control performance metric measurements and tracking
      */
     performanceTracking?: PerformanceTracking;
-    sanitizePrivateContent?: boolean;
-    collabEdit?: CollabEditOptions;
     primaryToolbarComponents?: PrimaryToolbarComponents;
-    allowUndoRedoButtons?: boolean;
+    sanitizePrivateContent?: boolean;
 }
 export interface EditorProps extends EditorBaseProps, EditorPluginFeatureProps, EditorSharedPropsWithPlugins, EditorProviderProps {
     assistiveDescribedBy?: string;
 }
 export interface EditorNextProps extends EditorBaseProps, EditorSharedPropsWithPlugins, EditorProviderProps {
-    preset: EditorPresetBuilder<AllPluginNames[], AllEditorPresetPluginTypes[]>;
+    assistiveDescribedBy?: string;
+    autoformattingProvider?: Providers['autoformattingProvider'];
+    emojiProvider?: Providers['emojiProvider'];
     /**
      * @deprecated
      * This prop does nothing and will be removed soon.
@@ -175,73 +177,80 @@ export interface EditorNextProps extends EditorBaseProps, EditorSharedPropsWithP
      * ```
      */
     media?: MediaPluginOptions;
-    assistiveDescribedBy?: string;
-    emojiProvider?: Providers['emojiProvider'];
+    preset: EditorPresetBuilder<AllPluginNames[], AllEditorPresetPluginTypes[]>;
     taskDecisionProvider?: Promise<TaskDecisionProvider>;
-    autoformattingProvider?: Providers['autoformattingProvider'];
 }
 export interface EditorProviderProps {
     activityProvider?: Promise<ActivityProvider>;
-    searchProvider?: Promise<SearchProvider>;
     annotationProviders?: AnnotationProviders;
+    autoformattingProvider?: Providers['autoformattingProvider'];
     collabEditProvider?: Providers['collabEditProvider'];
-    presenceProvider?: Promise<any>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
     emojiProvider?: Providers['emojiProvider'];
-    taskDecisionProvider?: Promise<TaskDecisionProvider>;
     legacyImageUploadProvider?: Providers['imageUploadProvider'];
-    mentionProvider?: Promise<MentionProvider>;
-    autoformattingProvider?: Providers['autoformattingProvider'];
     macroProvider?: Providers['macroProvider'];
-    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    mentionProvider?: Promise<MentionProvider>;
+    presenceProvider?: Promise<any>;
+    searchProvider?: Promise<SearchProvider>;
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
 }
 export interface EditorPluginFeatureProps {
-    allowExpand?: boolean | {
-        allowInsertion?: boolean;
-        allowInteractiveExpand?: boolean;
-    };
-    allowNestedTasks?: boolean;
+    allowAnalyticsGASV3?: boolean;
     allowBlockType?: BlockTypePluginOptions['allowBlockType'];
-    allowTasksAndDecisions?: boolean;
-    allowBreakout?: boolean;
-    allowRule?: boolean;
-    allowHelpDialog?: boolean;
-    allowPanel?: boolean | PanelPluginConfig;
-    allowExtension?: boolean | ExtensionConfig;
-    allowConfluenceInlineComment?: boolean;
-    allowTemplatePlaceholders?: boolean | PlaceholderTextPluginOptions;
-    allowDate?: boolean | DatePluginOptions;
-    allowLayouts?: boolean | LayoutPluginOptions;
-    allowStatus?: boolean | {
-        menuDisabled: boolean;
-    };
-    allowTextAlignment?: boolean;
-    allowIndentation?: boolean;
-    showIndentationButtons?: boolean;
-    allowFindReplace?: boolean | FindReplaceOptions;
     /**
      * Enable support for the "border" mark.
      * Refer to ADF Change proposal #65 for more details.
      */
     allowBorderMark?: boolean;
+    allowBreakout?: boolean;
+    allowConfluenceInlineComment?: boolean;
+    allowDate?: boolean | DatePluginOptions;
+    allowExpand?: boolean | {
+        allowInsertion?: boolean;
+        allowInteractiveExpand?: boolean;
+    };
+    allowExtension?: boolean | ExtensionConfig;
+    allowFindReplace?: boolean | FindReplaceOptions;
     /**
      * Enable support for the "fragment" mark.
      * Refer to ADF Change proposal #60 for more details.
      */
     allowFragmentMark?: boolean;
+    allowHelpDialog?: boolean;
+    allowIndentation?: boolean;
+    allowLayouts?: boolean | LayoutPluginOptions;
+    allowNestedTasks?: boolean;
+    allowPanel?: boolean | PanelPluginConfig;
+    allowRule?: boolean;
+    allowStatus?: boolean | {
+        menuDisabled: boolean;
+    };
+    allowTables?: boolean | TablesPluginConfig;
+    allowTasksAndDecisions?: boolean;
+    allowTemplatePlaceholders?: boolean | PlaceholderTextPluginOptions;
+    allowTextAlignment?: boolean;
+    allowTextColor?: boolean | TextColorPluginConfig;
     /**
      * Set this to false to opt out of the default behaviour of auto scrolling into view
      * whenever the document is changed
      */
     autoScrollIntoView?: boolean;
+    codeBlock?: CodeBlockPluginOptions;
     elementBrowser?: {
-        showModal?: boolean;
-        replacePlusMenu?: boolean;
-        helpUrl?: string;
         emptyStateHandler?: EmptyStateHandler;
+        helpUrl?: string;
+        replacePlusMenu?: boolean;
+        showModal?: boolean;
     };
-    maxContentSize?: number;
-    saveOnEnter?: boolean;
+    extensionHandlers?: ExtensionHandlers;
     feedbackInfo?: FeedbackInfo;
+    insertMenuItems?: MenuItem[];
+    /**
+     *  Configure and extend editor linking behaviour
+     */
+    linking?: LinkingOptions;
+    maxContentSize?: number;
+    media?: MediaPluginOptions;
     mention?: MentionPluginConfig;
     /**
      * flag to indicate display name instead of nick name should be inserted for mentions
@@ -249,25 +258,16 @@ export interface EditorPluginFeatureProps {
      * @deprecated Use mention.mentionInsertDisplayName instead
      */
     mentionInsertDisplayName?: boolean;
-    uploadErrorHandler?: (state: MediaState) => void;
-    waitForMediaUpload?: boolean;
-    extensionHandlers?: ExtensionHandlers;
-    allowTextColor?: boolean | TextColorPluginConfig;
-    allowTables?: boolean | TablesPluginConfig;
-    insertMenuItems?: MenuItem[];
-    /** @deprecated Use linking.smartLinks prop instead. */
-    UNSAFE_cards?: CardOptions;
+    placeholder?: string;
+    placeholderBracketHint?: string;
+    saveOnEnter?: boolean;
+    showIndentationButtons?: boolean;
     /** @deprecated Use linking.smartLinks prop instead. */
     smartLinks?: CardOptions;
-    allowAnalyticsGASV3?: boolean;
-    codeBlock?: CodeBlockPluginOptions;
     textFormatting?: TextFormattingPluginOptions;
-    placeholder?: string;
-    placeholderBracketHint?: string;
-    /**
-     *  Configure and extend editor linking behaviour
-     */
-    linking?: LinkingOptions;
-    media?: MediaPluginOptions;
+    /** @deprecated Use linking.smartLinks prop instead. */
+    UNSAFE_cards?: CardOptions;
+    uploadErrorHandler?: (state: MediaState) => void;
+    waitForMediaUpload?: boolean;
 }
 export {};

package/dist/types/types/i18n.d.ts

@@ -1,5 +1,5 @@
 export interface MessageDescriptor {
-    id: string;
-    description: string;
     defaultMessage: string;
+    description: string;
+    id: string;
 }

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

@@ -6,9 +6,9 @@ import React from 'react';
 import { jsx } from '@emotion/react';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 export interface Props {
-    editorView?: EditorView;
     children?: React.ReactNode;
     editorDisabled?: boolean;
+    editorView?: EditorView;
 }
 export declare const ClickAreaBlock: ({ editorView, editorDisabled, children }: Props) => jsx.JSX.Element;
 export default ClickAreaBlock;

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

@@ -8,8 +8,8 @@ import type EditorActions from '../../../actions';
 import type { RenderOnClickHandler } from '../../Addon/types';
 export interface Props {
     children?: React.ReactNode;
-    onClick: (actionOnClick: EditorActions, renderOnClick: RenderOnClickHandler) => void;
     editorActions: EditorActions;
+    onClick: (actionOnClick: EditorActions, renderOnClick: RenderOnClickHandler) => void;
     togglePopup: () => void;
 }
 export default class DropdownWrapper extends React.Component<Props> {

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

@@ -8,8 +8,8 @@ export interface AddonCommonProps extends AddonActions {
     icon: React.ReactElement;
 }
 export interface AddonProps extends AddonCommonProps {
-    onClick?: (actions: AddonActions) => void;
     children?: React.ReactElement[];
+    onClick?: (actions: AddonActions) => void;
 }
 export interface AddonConfiguration extends AddonCommonProps {
     text: string;

package/dist/types/ui/Appearance/Chromeless.d.ts

@@ -9,13 +9,13 @@ import type { EditorViewModePlugin } from '@atlaskit/editor-plugins/editor-viewm
 import type { MaxContentSizePlugin } from '@atlaskit/editor-plugins/max-content-size';
 import type { EditorAppearanceComponentProps } from '../../types';
 export declare const ContentArea: React.ForwardRefExoticComponent<Omit<{
-    theme?: import("@emotion/react").Theme;
+    appearance?: EditorAppearance;
     colorMode?: "light" | "dark";
     featureFlags?: import("@atlaskit/editor-common/types").FeatureFlags;
-    viewMode?: "view" | "edit";
-    typographyTheme?: "typography" | "typography-adg3" | "typography-modernized" | "typography-refreshed";
     isScrollable?: boolean;
-    appearance?: EditorAppearance;
+    theme?: import("@emotion/react").Theme;
+    typographyTheme?: "typography" | "typography-adg3" | "typography-modernized" | "typography-refreshed";
+    viewMode?: "view" | "edit";
 } & React.HTMLProps<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 type AppearanceProps = EditorAppearanceComponentProps<[
     OptionalPlugin<MaxContentSizePlugin>,
@@ -33,10 +33,10 @@ export default class Editor extends React.Component<AppearanceProps> {
     render(): jsx.JSX.Element;
 }
 interface ChromelessEditorContainerProps {
-    maxHeight?: number;
-    minHeight: number;
     children: React.ReactNode;
     containerRef?: (ref: HTMLElement | null) => void;
+    maxHeight?: number;
+    minHeight: number;
 }
 export declare const ChromelessEditorContainer: React.FC<ChromelessEditorContainerProps>;
 export {};

package/dist/types/ui/Appearance/Comment/Toolbar.d.ts

@@ -2,9 +2,9 @@ import React from 'react';
 import { jsx } from '@emotion/react';
 import type { UseStickyToolbarType } from '@atlaskit/editor-common/ui';
 type MainToolbarProps = {
-    useStickyToolbar?: UseStickyToolbarType;
-    twoLineEditorToolbar?: boolean;
     children?: React.ReactNode;
+    twoLineEditorToolbar?: boolean;
+    useStickyToolbar?: UseStickyToolbarType;
 };
 export declare const MainToolbar: ({ useStickyToolbar, twoLineEditorToolbar, children, }: MainToolbarProps) => jsx.JSX.Element;
 export {};

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

@@ -4,11 +4,11 @@
  */
 import React from 'react';
 interface ChildWrapperProps {
-    twoLineEditorToolbar: boolean;
-    children: React.ReactNode;
-    role?: string;
     'aria-label'?: string;
+    children: React.ReactNode;
     'data-testid'?: string;
+    role?: string;
+    twoLineEditorToolbar: boolean;
 }
 export declare const MainToolbarForFirstChildWrapper: React.FC<ChildWrapperProps>;
 export declare const MainToolbarForSecondChildWrapper: React.FC<ChildWrapperProps>;

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

@@ -17,38 +17,38 @@ import type EditorActions from '../../../actions';
 import type { ContentComponents, ReactComponents } from '../../../types';
 import type { ScrollContainerRefs } from './types';
 interface FullPageEditorContentAreaProps {
-    editorAPI: PublicPluginAPI<[OptionalPlugin<ContextPanelPlugin>]> | undefined;
     appearance: EditorAppearance | undefined;
     contentComponents: UIComponentFactory[] | undefined;
-    pluginHooks: ReactHookFactory[] | undefined;
     contextPanel: ReactComponents | undefined;
     customContentComponents: ContentComponents | undefined;
     disabled: boolean | undefined;
     dispatchAnalyticsEvent: DispatchAnalyticsEvent | undefined;
     editorActions: EditorActions | undefined;
+    editorAPI: PublicPluginAPI<[OptionalPlugin<ContextPanelPlugin>]> | undefined;
     editorDOMElement: ReactElement;
     editorView: EditorView;
     eventDispatcher: EventDispatcher | undefined;
-    popupsMountPoint: HTMLElement | undefined;
+    featureFlags?: FeatureFlags;
+    hasHadInteraction?: boolean;
+    isEditorToolbarHidden?: boolean;
+    pluginHooks: ReactHookFactory[] | undefined;
     popupsBoundariesElement: HTMLElement | undefined;
+    popupsMountPoint: HTMLElement | undefined;
     popupsScrollableElement: HTMLElement | undefined;
     providerFactory: ProviderFactory;
-    wrapperElement: HTMLElement | null;
-    hasHadInteraction?: boolean;
-    featureFlags?: FeatureFlags;
     viewMode: ViewMode | undefined;
-    isEditorToolbarHidden?: boolean;
+    wrapperElement: HTMLElement | null;
 }
 export declare const CONTENT_AREA_TEST_ID = "ak-editor-fp-content-area";
 export declare const EDITOR_CONTAINER = "ak-editor-container";
 export declare const ScrollContainer: React.ForwardRefExoticComponent<Omit<{
-    theme?: Theme;
+    appearance?: EditorAppearance;
     colorMode?: "light" | "dark";
     featureFlags?: FeatureFlags;
-    viewMode?: "view" | "edit";
-    typographyTheme?: "typography" | "typography-adg3" | "typography-modernized" | "typography-refreshed";
     isScrollable?: boolean;
-    appearance?: EditorAppearance;
+    theme?: Theme;
+    typographyTheme?: "typography" | "typography-adg3" | "typography-modernized" | "typography-refreshed";
+    viewMode?: "view" | "edit";
 } & React.HTMLProps<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export declare const FullPageContentArea: React.ForwardRefExoticComponent<Omit<import("react-intl-next").WithIntlProps<React.PropsWithChildren<FullPageEditorContentAreaProps & WrappedComponentProps & React.RefAttributes<ScrollContainerRefs>>>, "ref"> & React.RefAttributes<any>> & {
     WrappedComponent: React.ComponentType<FullPageEditorContentAreaProps & WrappedComponentProps & React.RefAttributes<ScrollContainerRefs>>;

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

@@ -30,25 +30,25 @@ export type ToolbarEditorPlugins = [
 ];
 export interface FullPageToolbarProps {
     appearance?: EditorAppearance;
-    providerFactory: ProviderFactory;
+    beforeIcon?: ReactElement;
+    collabEdit?: CollabEditOptions;
+    containerElement: HTMLElement | null;
+    customPrimaryToolbarComponents?: PrimaryToolbarComponents;
+    disabled: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
     editorActions?: EditorActions;
+    editorAPI: PublicPluginAPI<ToolbarEditorPlugins> | undefined;
     editorDOMElement: JSX.Element;
     editorView: EditorView;
     eventDispatcher: EventDispatcher;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
-    primaryToolbarComponents?: ToolbarUIComponentFactory[];
-    customPrimaryToolbarComponents?: PrimaryToolbarComponents;
-    popupsMountPoint?: HTMLElement;
+    featureFlags: FeatureFlags;
+    hasMinWidth?: boolean;
     popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
     popupsScrollableElement?: HTMLElement;
-    disabled: boolean;
-    collabEdit?: CollabEditOptions;
+    primaryToolbarComponents?: ToolbarUIComponentFactory[];
+    providerFactory: ProviderFactory;
     showKeyline: boolean;
-    containerElement: HTMLElement | null;
-    beforeIcon?: ReactElement;
-    hasMinWidth?: boolean;
-    featureFlags: FeatureFlags;
-    editorAPI: PublicPluginAPI<ToolbarEditorPlugins> | undefined;
 }
 export declare const EditorToolbar: React.MemoExoticComponent<(props: FullPageToolbarProps & WrappedComponentProps) => jsx.JSX.Element>;
 export declare const FullPageToolbar: React.FC<import("react-intl-next").WithIntlProps<FullPageToolbarProps & WrappedComponentProps>> & {

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

@@ -9,10 +9,10 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 type FullPageToolbarNextProps = {
     beforeIcon?: React.ReactNode;
     editorAPI?: PublicPluginAPI<[ToolbarPlugin]>;
-    toolbarDockingPosition?: 'top' | 'none';
     editorView?: EditorView;
     popupsMountPoint?: HTMLElement;
     showKeyline: boolean;
+    toolbarDockingPosition?: 'top' | 'none';
 };
 export declare const FullPageToolbarNext: ({ editorAPI, beforeIcon, toolbarDockingPosition, editorView, popupsMountPoint, showKeyline, }: FullPageToolbarNextProps) => JSX.Element;
 export {};