@atlaskit/editor-plugin-media 5.2.13 → 5.3.0

package/dist/types-ts4.5/pm-plugins/types.d.ts

@@ -10,69 +10,69 @@ import type { MediaOptions, MediaState, MediaStateEventSubscriber, ProsemirrorGe
 import type { MediaPluginOptions } from '../types/media-plugin-options';
 import type PickerFacade from './picker-facade';
 export interface MediaNodeWithPosHandler {
-    node: PMNode;
     getPos: ProsemirrorGetPosHandler;
+    node: PMNode;
 }
 export interface MediaPluginState {
+    addPendingTask: (promise: Promise<any>) => void;
+    allowInlineImages?: boolean;
     allowsUploads: boolean;
-    mediaClientConfig?: MediaClientConfig;
-    uploadMediaClientConfig?: MediaClientConfig;
-    ignoreLinks: boolean;
-    waitForMediaUpload: boolean;
     allUploadsFinished: boolean;
-    showDropzone: boolean;
-    isFullscreen: boolean;
-    element?: HTMLElement;
-    videoControlsWrapperRef?: HTMLElement;
-    layout: MediaSingleLayout;
-    mediaNodes: MediaNodeWithPosHandler[];
-    options: MediaPluginOptions;
-    mediaProvider?: MediaProvider;
-    pickers: PickerFacade[];
-    pickerPromises: Array<Promise<PickerFacade>>;
+    clone(): MediaPluginState;
+    currentMaxWidth?: number;
+    destroy(): void;
+    dispatch?: Dispatch;
     editingMediaSinglePos?: number;
-    showEditingDialog?: boolean;
-    mediaOptions?: MediaOptions;
+    element?: HTMLElement;
+    findMediaNode: (id: string) => MediaNodeWithPosHandler | null;
+    getMediaOptions: () => MediaPluginOptions;
+    handleDrag: (dragState: 'enter' | 'leave') => void;
+    handleMediaGroupUpdate: (oldNodes: PMNode[], newNodes: PMNode[]) => void;
+    handleMediaNodeMount: (node: PMNode, getPos: ProsemirrorGetPosHandler) => void;
+    handleMediaNodeRemoval: (node: PMNode | undefined, getPos: ProsemirrorGetPosHandler) => void;
+    handleMediaNodeUnmount: (oldNode: PMNode) => void;
+    ignoreLinks: boolean;
+    insertFile: (mediaState: MediaState, onMediaStateChanged: MediaStateEventSubscriber, pickerType?: string, insertMediaVia?: InsertMediaVia) => void;
+    isFullscreen: boolean;
+    isIdentifierInEditorScope: (identifier: Identifier) => boolean;
+    isMediaViewerVisible?: boolean;
     isResizing: boolean;
-    resizingWidth: number;
-    currentMaxWidth?: number;
-    allowInlineImages?: boolean;
     lastAddedMediaSingleFileIds: {
         id: string;
         selectionPosition: number;
     }[];
-    dispatch?: Dispatch;
-    setMediaProvider: (mediaProvider?: Promise<MediaProvider>) => Promise<void>;
-    getMediaOptions: () => MediaPluginOptions;
-    insertFile: (mediaState: MediaState, onMediaStateChanged: MediaStateEventSubscriber, pickerType?: string, insertMediaVia?: InsertMediaVia) => void;
-    addPendingTask: (promise: Promise<any>) => void;
-    splitMediaGroup: () => boolean;
+    layout: MediaSingleLayout;
+    mediaClientConfig?: MediaClientConfig;
+    mediaNodes: MediaNodeWithPosHandler[];
+    mediaOptions?: MediaOptions;
+    mediaProvider?: MediaProvider;
+    mediaViewerSelectedMedia?: MediaADFAttrs;
     onPopupPickerClose: () => void;
-    showMediaPicker: () => void;
-    setBrowseFn: (browseFn: () => void) => void;
     onPopupToggle: (onPopupToogleCallback: (isOpen: boolean) => void) => void;
-    waitForPendingTasks: (timeout?: number, lastTask?: Promise<MediaState | null>) => Promise<MediaState | null>;
-    handleMediaNodeRemoval: (node: PMNode | undefined, getPos: ProsemirrorGetPosHandler) => void;
-    handleMediaNodeMount: (node: PMNode, getPos: ProsemirrorGetPosHandler) => void;
-    handleMediaNodeUnmount: (oldNode: PMNode) => void;
-    handleMediaGroupUpdate: (oldNodes: PMNode[], newNodes: PMNode[]) => void;
-    findMediaNode: (id: string) => MediaNodeWithPosHandler | null;
-    updateMediaSingleNodeAttrs: (id: string, attrs: object) => undefined | boolean;
+    options: MediaPluginOptions;
+    pickerPromises: Array<Promise<PickerFacade>>;
+    pickers: PickerFacade[];
     removeSelectedMediaContainer: () => boolean;
+    resizingWidth: number;
     selectedMediaContainerNode: () => PMNode | undefined;
-    handleDrag: (dragState: 'enter' | 'leave') => void;
-    isIdentifierInEditorScope: (identifier: Identifier) => boolean;
-    trackOutOfScopeIdentifier: (identifier: Identifier) => void;
-    updateElement(): void;
+    setBrowseFn: (browseFn: () => void) => void;
     setIsResizing(isResizing: boolean): void;
+    setMediaProvider: (mediaProvider?: Promise<MediaProvider>) => Promise<void>;
     setResizingWidth(width: number): void;
     setView(view: EditorView): void;
-    destroy(): void;
-    updateAndDispatch(props: Partial<Pick<this, 'allowsUploads' | 'allUploadsFinished' | 'isFullscreen' | 'videoControlsWrapperRef'>>): void;
-    clone(): MediaPluginState;
+    showDropzone: boolean;
+    showEditingDialog?: boolean;
+    showMediaPicker: () => void;
+    splitMediaGroup: () => boolean;
     subscribeToUploadInProgressState(fn: (isUploading: boolean) => void): void;
+    trackOutOfScopeIdentifier: (identifier: Identifier) => void;
     unsubscribeFromUploadInProgressState(fn: (isUploading: boolean) => void): void;
-    isMediaViewerVisible?: boolean;
-    mediaViewerSelectedMedia?: MediaADFAttrs;
+    updateAndDispatch(props: Partial<Pick<this, 'allowsUploads' | 'allUploadsFinished' | 'isFullscreen' | 'videoControlsWrapperRef'>>): void;
+    updateElement(): void;
+    updateMediaSingleNodeAttrs: (id: string, attrs: object) => undefined | boolean;
+    uploadMediaClientConfig?: MediaClientConfig;
+    videoControlsWrapperRef?: HTMLElement;
+    waitForMediaUpload: boolean;
+    waitForPendingTasks: (timeout?: number, lastTask?: Promise<MediaState | null>) => Promise<MediaState | null>;
 }
 export type EventInput = 'keyboard' | 'mouse' | 'floatingToolBar';

package/dist/types-ts4.5/pm-plugins/utils/batchMediaNodeAttrs.d.ts

@@ -29,7 +29,7 @@ export declare const runUpdate: (editorView: EditorView, cache: MediaAttributesC
  * @type {Function}
  * @param {Function} runUpdate - The function to be debounced.
  * @param {number} debouncedTime - The debounce delay in milliseconds.
- * @param {Object} [options] - The debounce options. Defaults to {leading: false, trailing: true}.
+ * @param {object} [options] - The debounce options. Defaults to {leading: false, trailing: true}.
  * @param {Function} keyResolver - A function that returns the key to be used for memoization. In this case, it returns the editor view instance.
  *
  * This function performs the following steps:

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

@@ -16,47 +16,41 @@ export type MediaStateStatus = 'unknown' | 'ready' | 'cancelled' | 'preview' | '
 export type MediaSingleWithType = 'pixel' | 'percentage';
 export type MediaCopyScope = 'editor' | 'context';
 export interface MediaPluginOptions {
-    provider?: Providers['mediaProvider'];
-    syncProvider?: MediaProvider;
+    alignLeftOnInsert?: boolean;
+    allowAdvancedToolBarOptions?: boolean;
+    allowAltTextOnImages?: boolean;
+    allowBreakoutSnapPoints?: boolean;
+    allowCaptions?: boolean;
+    allowCommentsOnMedia?: boolean;
+    allowDropzoneDropLine?: boolean;
+    allowImagePreview?: boolean;
+    allowLazyLoading?: boolean;
+    allowLinking?: boolean;
+    allowMarkingUploadsAsIncomplete?: boolean;
+    allowMediaGroup?: boolean;
     /**
      * @experimental
      * Still under development. Use with caution.
      */
     allowMediaInlineImages?: boolean;
     allowMediaSingle?: boolean | MediaSingleOptions;
-    allowMediaGroup?: boolean;
-    customDropzoneContainer?: HTMLElement;
-    customMediaPicker?: CustomMediaPicker;
-    allowResizing?: boolean;
-    allowResizingInTables?: boolean;
-    allowLinking?: boolean;
-    allowLazyLoading?: boolean;
-    allowBreakoutSnapPoints?: boolean;
-    allowAdvancedToolBarOptions?: boolean;
     allowMediaSingleEditable?: boolean;
+    allowPixelResizing?: boolean;
     allowRemoteDimensionsFetch?: boolean;
-    allowDropzoneDropLine?: boolean;
-    allowMarkingUploadsAsIncomplete?: boolean;
-    allowImagePreview?: boolean;
-    fullWidthEnabled?: boolean;
-    uploadErrorHandler?: (state: MediaState) => void;
-    waitForMediaUpload?: boolean;
-    isCopyPasteEnabled?: boolean;
-    allowAltTextOnImages?: boolean;
-    enableDownloadButton?: boolean;
-    altTextValidator?: (value: string) => string[];
-    useForgePlugins?: boolean;
+    allowResizing?: boolean;
+    allowResizingInTables?: boolean;
     allowTemplatePlaceholders?: boolean | PlaceholderTextOptions;
-    alignLeftOnInsert?: boolean;
+    altTextValidator?: (value: string) => string[];
+    customDropzoneContainer?: HTMLElement;
+    customMediaPicker?: CustomMediaPicker;
+    editorAppearance?: EditorAppearance;
     editorSelectionAPI?: EditorSelectionAPI;
+    enableDownloadButton?: boolean;
     featureFlags?: MediaFeatureFlags;
-    getEditorFeatureFlags?: GetEditorFeatureFlags;
-    allowCaptions?: boolean;
-    allowCommentsOnMedia?: boolean;
-    editorAppearance?: EditorAppearance;
     forceHandlePositioning?: HandlePositioning;
-    mediaShallowCopyScope?: MediaCopyScope;
-    allowPixelResizing?: boolean;
+    fullWidthEnabled?: boolean;
+    getEditorFeatureFlags?: GetEditorFeatureFlags;
+    isCopyPasteEnabled?: boolean;
     /**
      * Enabling this will prevent this plugin from automatically trying to upload external images to the Media service.
      * This can be used in conjunction with the `isOnlyExternalLinks` config for `media-insert-plugin` to limit images
@@ -74,7 +68,13 @@ export interface MediaPluginOptions {
      * ```
      */
     isExternalMediaUploadDisabled?: boolean;
+    mediaShallowCopyScope?: MediaCopyScope;
     onCommentButtonMount?: () => void;
+    provider?: Providers['mediaProvider'];
+    syncProvider?: MediaProvider;
+    uploadErrorHandler?: (state: MediaState) => void;
+    useForgePlugins?: boolean;
+    waitForMediaUpload?: boolean;
 }
 /**
  * @private
@@ -86,31 +86,31 @@ export interface MediaSingleOptions {
     disableLayout?: boolean;
 }
 export interface MediaState {
-    id: string;
-    status?: MediaStateStatus;
-    fileName?: string;
-    fileSize?: number;
-    fileMimeType?: string;
     collection?: string;
+    contextId?: string;
     dimensions?: {
-        width: number | undefined;
         height: number | undefined;
+        width: number | undefined;
     };
-    scaleFactor?: number;
     error?: {
-        name: string;
         description: string;
+        name: string;
     };
+    fileMimeType?: string;
+    fileName?: string;
+    fileSize?: number;
+    id: string;
     /** still require to support Mobile */
     publicId?: string;
-    contextId?: string;
+    scaleFactor?: number;
+    status?: MediaStateStatus;
 }
 export type Listener = (data: any) => void;
 export interface CustomMediaPicker {
+    destroy(): void;
+    emit(event: string, data: any): void;
     on(event: string, cb: Listener): void;
     removeAllListeners(event: any): void;
-    emit(event: string, data: any): void;
-    destroy(): void;
     setUploadParams(uploadParams: UploadParams): void;
 }
 export type MobileUploadEndEventPayload = {
@@ -120,37 +120,37 @@ export type MobileUploadEndEventPayload = {
     };
 };
 export type MediaEditorState = {
-    mediaClientConfig?: MediaClientConfig;
     editor?: {
-        pos: number;
         identifier: FileIdentifier;
+        pos: number;
     };
+    mediaClientConfig?: MediaClientConfig;
 };
 export type MediaToolbarBaseConfig = {
-    title: string;
     getDomRef?: (view: EditorView) => HTMLElement | undefined;
     nodeType: NodeType | NodeType[];
+    title: string;
 };
 export type MediaFloatingToolbarOptions = {
-    providerFactory?: ProviderFactory;
-    allowResizing?: boolean;
-    allowMediaInline?: boolean;
-    allowMediaInlineImages?: boolean;
-    allowLinking?: boolean;
     allowAdvancedToolBarOptions?: boolean;
-    allowResizingInTables?: boolean;
     allowAltTextOnImages?: boolean;
+    allowCommentsOnMedia?: boolean;
     allowImagePreview?: boolean;
+    allowLinking?: boolean;
+    allowMediaInline?: boolean;
+    allowMediaInlineImages?: boolean;
+    allowPixelResizing?: boolean;
+    allowResizing?: boolean;
+    allowResizingInTables?: boolean;
     altTextValidator?: (value: string) => string[];
     fullWidthEnabled?: boolean;
-    allowCommentsOnMedia?: boolean;
     isViewOnly?: boolean;
-    allowPixelResizing?: boolean;
     onCommentButtonMount?: () => void;
+    providerFactory?: ProviderFactory;
 };
 export type MediaDecorationSpec = {
-    type: 'media';
     selected: boolean;
+    type: 'media';
 };
 export type SupportedMediaAttributes = MediaADFAttrs | MediaInlineAttributes;
 export type ProsemirrorGetPosHandler = getPosHandlerNode;

package/dist/types-ts4.5/types/media-plugin-options.d.ts

@@ -3,14 +3,14 @@ import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 import type { ErrorReporter } from '@atlaskit/editor-common/utils';
 import type { CustomMediaPicker, MediaState } from './index';
 export type MediaPluginOptions = {
-    providerFactory: ProviderFactory;
+    allowResizing: boolean;
+    customDropzoneContainer?: HTMLElement;
+    customMediaPicker?: CustomMediaPicker;
+    errorReporter?: ErrorReporter;
     nodeViews: {
         [name: string]: NodeViewConstructor;
     };
-    errorReporter?: ErrorReporter;
+    providerFactory: ProviderFactory;
     uploadErrorHandler?: (state: MediaState) => void;
     waitForMediaUpload?: boolean;
-    customDropzoneContainer?: HTMLElement;
-    customMediaPicker?: CustomMediaPicker;
-    allowResizing: boolean;
 };

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

@@ -6,9 +6,9 @@ import React from 'react';
 type CaptionPlaceholderProps = {
     onClick: () => void;
     placeholderMessage?: {
-        id: string;
         defaultMessage: string;
         description: string;
+        id: string;
     };
 };
 export declare const CaptionPlaceholder: React.ForwardRefExoticComponent<CaptionPlaceholderProps & React.RefAttributes<HTMLSpanElement>>;

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

@@ -7,13 +7,13 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { MediaNextEditorPluginType } from '../../mediaPluginType';
 import type { getPosHandler } from '../../types';
 type CommentBadgeProps = {
-    intl: IntlShape;
     api: ExtractInjectionAPI<MediaNextEditorPluginType>;
-    mediaNode: PMNode | null;
-    view: EditorView;
+    badgeOffsetRight?: string;
     getPos: getPosHandler;
+    intl: IntlShape;
     isDrafting: boolean;
-    badgeOffsetRight?: string;
+    mediaNode: PMNode | null;
+    view: EditorView;
 };
 export declare const CommentBadge: React.FC<import("react-intl-next").WithIntlProps<CommentBadgeProps>> & {
     WrappedComponent: React.ComponentType<CommentBadgeProps>;
@@ -24,13 +24,13 @@ export declare const CommentBadge: React.FC<import("react-intl-next").WithIntlPr
  * when clean up platform_editor_add_media_from_url_rollout feature flag
  */
 type CommentBadgeNextWrapperProps = {
-    mediaSingleElement?: HTMLElement | null;
-    marks?: AnnotationMarkDefinition[];
-    isDrafting?: boolean;
     api: ExtractInjectionAPI<MediaNextEditorPluginType>;
+    getPos: getPosHandler;
+    isDrafting?: boolean;
+    marks?: AnnotationMarkDefinition[];
     mediaNode: PMNode | null;
+    mediaSingleElement?: HTMLElement | null;
     view: EditorView;
-    getPos: getPosHandler;
 };
 export declare const CommentBadgeNextWrapper: ({ api, mediaNode, view, getPos, isDrafting, }: CommentBadgeNextWrapperProps) => React.JSX.Element | null;
 export {};

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

@@ -2,10 +2,10 @@ import { jsx } from '@emotion/react';
 import type { IntlShape } from 'react-intl-next';
 import type { BorderMarkAttributes } from '@atlaskit/adf-schema';
 export interface ImageBorderProps {
-    intl: IntlShape;
-    toggleBorder: () => void;
     borderMark?: BorderMarkAttributes;
+    intl: IntlShape;
     setBorder: (attrs: Partial<BorderMarkAttributes>) => void;
+    toggleBorder: () => void;
 }
 declare const ImageBorder: ({ intl: { formatMessage }, toggleBorder, borderMark, setBorder, }: ImageBorderProps) => jsx.JSX.Element;
 export default ImageBorder;

package/dist/types-ts4.5/ui/MediaLinkingToolbar.d.ts

@@ -8,19 +8,19 @@ import type { IntlShape, WrappedComponentProps } from 'react-intl-next';
 import type { RecentSearchInputTypes } from '@atlaskit/editor-common/link';
 import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 type Props = {
-    intl: IntlShape;
-    providerFactory: ProviderFactory;
+    displayUrl?: string;
     editing: boolean;
+    intl: IntlShape;
     onBack: (url: string, meta: {
         inputMethod?: RecentSearchInputTypes;
     }, setFocus?: boolean) => void;
-    onUnlink: (setFocus?: boolean) => void;
-    onCancel: () => void;
     onBlur: (href: string) => void;
+    onCancel: () => void;
     onSubmit: (href: string, meta: {
         inputMethod: RecentSearchInputTypes;
     }, setFocus?: boolean) => void;
-    displayUrl?: string;
+    onUnlink: (setFocus?: boolean) => void;
+    providerFactory: ProviderFactory;
 };
 declare class LinkAddToolbar extends React.PureComponent<Props & WrappedComponentProps> {
     state: {

package/dist/types-ts4.5/ui/MediaPicker/BrowserWrapper.d.ts

@@ -4,9 +4,9 @@ import type { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags
 import type { MediaNextEditorPluginType } from '../../mediaPluginType';
 type Props = {
     api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+    featureFlags?: MediaFeatureFlags;
     isOpen?: boolean;
     onBrowseFn: (browse: () => void) => void;
-    featureFlags?: MediaFeatureFlags;
 };
 export declare const BrowserWrapper: ({ api, isOpen, onBrowseFn, featureFlags }: Props) => React.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/MediaPicker/ClipboardWrapper.d.ts

@@ -4,8 +4,8 @@ import type { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags
 import type { MediaNextEditorPluginType } from '../../mediaPluginType';
 type Props = {
     api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
-    featureFlags?: MediaFeatureFlags;
     container?: HTMLElement;
+    featureFlags?: MediaFeatureFlags;
 };
 export declare const ClipboardWrapper: ({ api, container, featureFlags }: Props) => React.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/MediaPicker/DropzoneWrapper.d.ts

@@ -4,10 +4,10 @@ import type { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags
 import type { MediaNextEditorPluginType } from '../../mediaPluginType';
 type Props = {
     api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
-    isActive: boolean;
-    featureFlags?: MediaFeatureFlags;
-    editorDomElement: Element;
     appearance: EditorAppearance;
+    editorDomElement: Element;
+    featureFlags?: MediaFeatureFlags;
+    isActive: boolean;
 };
 export declare const DropzoneWrapper: ({ api, isActive, featureFlags, editorDomElement, appearance, }: Props) => React.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/MediaPicker/PickerFacadeProvider.d.ts

@@ -10,8 +10,8 @@ interface ChildrenProps {
     pickerFacadeInstance: PickerFacade;
 }
 export type Props = {
-    api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
     analyticsName: string;
+    api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
     children: (props: ChildrenProps) => React.ReactElement | null;
 };
 export default function PickerFacadeProvider({ api, analyticsName, children }: Props): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;

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

@@ -2,9 +2,9 @@ import React from 'react';
 import type { EditorAppearance, ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import type { MediaNextEditorPluginType } from '../../mediaPluginType';
 type Props = {
-    editorDomElement: Element;
-    appearance: EditorAppearance;
     api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+    appearance: EditorAppearance;
+    editorDomElement: Element;
     onPopupToggle: (onPopupToggle: (isPopupOpened: boolean) => void) => void;
     setBrowseFn: (nativeBrowseFn: () => void) => void;
 };

package/dist/types-ts4.5/ui/MediaViewer/MediaViewerContainer.d.ts

@@ -7,13 +7,13 @@ import { jsx } from '@emotion/react';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { MediaClientConfig } from '@atlaskit/media-core/auth';
 type MediaViewerContainerProps = {
-    mediaNode: PMNode;
-    selectedMediaContainerNode: () => PMNode | undefined;
-    mediaClientConfig: MediaClientConfig;
+    children?: React.ReactNode;
     isEditorViewMode?: boolean;
-    isSelected?: boolean;
     isInline?: boolean;
-    children?: React.ReactNode;
+    isSelected?: boolean;
+    mediaClientConfig: MediaClientConfig;
+    mediaNode: PMNode;
+    selectedMediaContainerNode: () => PMNode | undefined;
 };
 export declare const MediaViewerContainer: ({ mediaNode, selectedMediaContainerNode, mediaClientConfig, isEditorViewMode, isSelected, isInline, children, }: MediaViewerContainerProps) => jsx.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/MediaViewer/PortalWrapper.d.ts

@@ -2,10 +2,10 @@ import React from 'react';
 import type { MediaADFAttrs } from '@atlaskit/adf-schema';
 import type { Identifier, MediaClientConfig } from '@atlaskit/media-client';
 interface RenderMediaViewerProps {
+    items?: Identifier[];
     mediaClientConfig: MediaClientConfig;
     onClose: () => void;
     selectedNodeAttrs: MediaADFAttrs;
-    items?: Identifier[];
 }
 export declare const RenderMediaViewer: ({ mediaClientConfig, onClose, selectedNodeAttrs, items, }: RenderMediaViewerProps) => React.ReactPortal;
 export {};

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

@@ -8,8 +8,8 @@ import type { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema'
 import type { MediaClientConfig } from '@atlaskit/media-core';
 import type { Props } from './types';
 type State = {
-    offsetLeft: number;
     isVideoFile: boolean;
+    offsetLeft: number;
     resizedPctWidth?: number;
 };
 export default class ResizableMediaSingle extends React.Component<Props, State> {

package/dist/types-ts4.5/ui/ResizableMediaSingle/types.d.ts

@@ -12,19 +12,19 @@ export type EnabledHandles = {
     right?: boolean;
 };
 export type Props = MediaSingleProps & {
-    updateSize: (width: number | null, layout: MediaSingleLayout) => void;
-    getPos: getPosHandler;
-    view: EditorView;
-    lineLength: number;
-    gridSize: number;
-    containerWidth: number;
     allowBreakoutSnapPoints?: boolean;
-    selected: boolean;
-    viewMediaClientConfig?: MediaClientConfig;
-    fullWidthMode?: boolean;
+    containerWidth: number;
+    disableHandles?: boolean;
     dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+    forceHandlePositioning?: HandlePositioning;
+    fullWidthMode?: boolean;
+    getPos: getPosHandler;
+    gridSize: number;
+    lineLength: number;
     mediaSingleWidth?: number;
     pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
-    disableHandles?: boolean;
-    forceHandlePositioning?: HandlePositioning;
+    selected: boolean;
+    updateSize: (width: number | null, layout: MediaSingleLayout) => void;
+    view: EditorView;
+    viewMediaClientConfig?: MediaClientConfig;
 };

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

@@ -3,9 +3,9 @@ import type { WrappedComponentProps } from 'react-intl-next';
 import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import type { MediaNextEditorPluginType } from '../../mediaPluginType';
 interface Props {
+    api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
     isDisabled?: boolean;
     isReducedSpacing?: boolean;
-    api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
 }
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<Props & WrappedComponentProps>;

package/dist/types-ts4.5/ui/toolbar/layout-group.d.ts

@@ -5,9 +5,9 @@
 import { jsx } from '@emotion/react';
 import type { Command, FloatingToolbarItem } from '@atlaskit/editor-common/types';
 type Props = {
-    layoutButtons: FloatingToolbarItem<Command>[];
     dispatchCommand: (command: Command) => void;
     hide: () => void;
+    layoutButtons: FloatingToolbarItem<Command>[];
 };
 export declare const LayoutGroup: ({ layoutButtons, dispatchCommand, hide }: Props) => jsx.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/toolbar/linking-toolbar-appearance.d.ts

@@ -10,11 +10,11 @@ import type { MediaLinkingState } from '../../pm-plugins/linking/types';
 export interface LinkingToolbarProps {
     editorState: EditorState;
     intl: IntlShape;
+    isInlineNode?: boolean;
+    isViewOnly?: boolean;
     mediaLinkingState: MediaLinkingState;
     onAddLink: React.MouseEventHandler;
     onEditLink: React.MouseEventHandler;
     onOpenLink: React.MouseEventHandler;
-    isInlineNode?: boolean;
-    isViewOnly?: boolean;
 }
 export declare const LinkToolbarAppearance: ({ editorState, mediaLinkingState, intl, onAddLink, onEditLink, onOpenLink, isInlineNode, isViewOnly, }: LinkingToolbarProps) => jsx.JSX.Element | null;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-media",
-	"version": "5.2.13",
+	"version": "5.3.0",
 	"description": "Media plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -41,20 +41,20 @@
 		"@atlaskit/editor-plugin-analytics": "^3.0.0",
 		"@atlaskit/editor-plugin-annotation": "^3.3.0",
 		"@atlaskit/editor-plugin-connectivity": "^3.1.0",
-		"@atlaskit/editor-plugin-decorations": "^3.0.0",
+		"@atlaskit/editor-plugin-decorations": "^3.1.0",
 		"@atlaskit/editor-plugin-editor-disabled": "^3.0.0",
 		"@atlaskit/editor-plugin-editor-viewmode": "^5.0.0",
-		"@atlaskit/editor-plugin-floating-toolbar": "^5.1.0",
+		"@atlaskit/editor-plugin-floating-toolbar": "^5.2.0",
 		"@atlaskit/editor-plugin-focus": "^2.0.0",
 		"@atlaskit/editor-plugin-grid": "^3.1.0",
 		"@atlaskit/editor-plugin-guideline": "^3.0.0",
 		"@atlaskit/editor-plugin-interaction": "^5.0.0",
-		"@atlaskit/editor-plugin-selection": "^3.1.0",
+		"@atlaskit/editor-plugin-selection": "^3.2.0",
 		"@atlaskit/editor-plugin-width": "^4.0.0",
 		"@atlaskit/editor-prosemirror": "7.0.0",
 		"@atlaskit/editor-shared-styles": "^3.6.0",
 		"@atlaskit/editor-tables": "^2.9.0",
-		"@atlaskit/form": "^12.1.0",
+		"@atlaskit/form": "^12.2.0",
 		"@atlaskit/icon": "^28.0.0",
 		"@atlaskit/icon-lab": "^5.6.0",
 		"@atlaskit/media-card": "^79.5.0",
@@ -69,7 +69,7 @@
 		"@atlaskit/primitives": "^14.11.0",
 		"@atlaskit/textfield": "^8.0.0",
 		"@atlaskit/theme": "^19.0.0",
-		"@atlaskit/tmp-editor-statsig": "^11.3.0",
+		"@atlaskit/tmp-editor-statsig": "^11.6.0",
 		"@atlaskit/tokens": "^6.0.0",
 		"@atlaskit/tooltip": "^20.4.0",
 		"@babel/runtime": "^7.0.0",
@@ -81,7 +81,7 @@
 		"uuid": "^3.1.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^107.26.0",
+		"@atlaskit/editor-common": "^107.29.0",
 		"@atlaskit/media-core": "^37.0.0",
 		"react": "^18.2.0",
 		"react-dom": "^18.2.0",