@atlaskit/editor-plugin-media 5.2.13 → 5.2.14

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @atlaskit/editor-plugin-media
 
+## 5.2.14
+
+### Patch Changes
+
+- [`265c1bf0cefa4`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/265c1bf0cefa4) -
+  Sorted type and interface props to improve Atlaskit docs
+- Updated dependencies
+
 ## 5.2.13
 
 ### Patch Changes

package/dist/cjs/pm-plugins/utils/batchMediaNodeAttrs.js

@@ -29,7 +29,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
  * @template T
  * @param {T} func - The function to debounce.
  * @param {number} [wait=0] - The number of milliseconds to delay.
- * @param {Object} [options] - The options object to pass to `debounce`.
+ * @param {object} [options] - The options object to pass to `debounce`.
  * @param {Function} [resolver] - The function to resolve the cache key for memoization.
  * @returns {Function} A new debounced and memoized function.
  *
@@ -115,7 +115,7 @@ var runUpdate = exports.runUpdate = function runUpdate(editorView, cache) {
  * @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/es2019/pm-plugins/utils/batchMediaNodeAttrs.js

@@ -18,7 +18,7 @@ import { batchStepsUpdate } from './batchSteps';
  * @template T
  * @param {T} func - The function to debounce.
  * @param {number} [wait=0] - The number of milliseconds to delay.
- * @param {Object} [options] - The options object to pass to `debounce`.
+ * @param {object} [options] - The options object to pass to `debounce`.
  * @param {Function} [resolver] - The function to resolve the cache key for memoization.
  * @returns {Function} A new debounced and memoized function.
  *
@@ -100,7 +100,7 @@ export const runUpdate = (editorView, cache) => {
  * @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/esm/pm-plugins/utils/batchMediaNodeAttrs.js

@@ -23,7 +23,7 @@ import { batchStepsUpdate } from './batchSteps';
  * @template T
  * @param {T} func - The function to debounce.
  * @param {number} [wait=0] - The number of milliseconds to delay.
- * @param {Object} [options] - The options object to pass to `debounce`.
+ * @param {object} [options] - The options object to pass to `debounce`.
  * @param {Function} [resolver] - The function to resolve the cache key for memoization.
  * @returns {Function} A new debounced and memoized function.
  *
@@ -109,7 +109,7 @@ export var runUpdate = function runUpdate(editorView, cache) {
  * @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/mediaPluginType.d.ts

@@ -38,9 +38,6 @@ export type MediaPluginDependencies = [
     OptionalPlugin<InteractionPlugin>
 ];
 export type MediaNextEditorPluginType = NextEditorPlugin<'media', {
-    pluginConfiguration: MediaOptions | undefined;
-    dependencies: MediaPluginDependencies;
-    sharedState: MediaPluginState | null;
     actions: {
         insertMediaAsMediaSingle: InsertMediaAsMediaSingle;
         /**
@@ -55,8 +52,11 @@ export type MediaNextEditorPluginType = NextEditorPlugin<'media', {
         setProvider: (provider: Promise<MediaProvider>) => boolean;
     };
     commands: {
-        showMediaViewer: (media: MediaADFAttrs) => EditorCommand;
         hideMediaViewer: EditorCommand;
+        showMediaViewer: (media: MediaADFAttrs) => EditorCommand;
         trackMediaPaste: (attrs: MediaADFAttrs) => EditorCommand;
     };
+    dependencies: MediaPluginDependencies;
+    pluginConfiguration: MediaOptions | undefined;
+    sharedState: MediaPluginState | null;
 }>;

package/dist/types/nodeviews/mediaGroupNext.d.ts

@@ -5,33 +5,33 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { MediaOptions } from '../types';
 export declare const MediaGroupNext: React.FC<import("react-intl-next").WithIntlProps<{
-    forwardRef?: (ref: HTMLElement) => void;
-    node: PMNode;
-    view: EditorView;
-    getPos: () => number | undefined;
-    disabled?: boolean;
-    editorViewMode?: boolean;
     allowLazyLoading?: boolean;
-    mediaProvider: Promise<MediaProvider>;
-    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
-    isCopyPasteEnabled?: boolean;
     anchorPos: number;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    disabled?: boolean;
+    editorViewMode?: boolean;
+    forwardRef?: (ref: HTMLElement) => void;
+    getPos: () => number | undefined;
     headPos: number;
+    isCopyPasteEnabled?: boolean;
     mediaOptions: MediaOptions;
+    mediaProvider: Promise<MediaProvider>;
+    node: PMNode;
+    view: EditorView;
 } & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<{
-        forwardRef?: (ref: HTMLElement) => void;
-        node: PMNode;
-        view: EditorView;
-        getPos: () => number | undefined;
-        disabled?: boolean;
-        editorViewMode?: boolean;
         allowLazyLoading?: boolean;
-        mediaProvider: Promise<MediaProvider>;
-        contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
-        isCopyPasteEnabled?: boolean;
         anchorPos: number;
+        contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+        disabled?: boolean;
+        editorViewMode?: boolean;
+        forwardRef?: (ref: HTMLElement) => void;
+        getPos: () => number | undefined;
         headPos: number;
+        isCopyPasteEnabled?: boolean;
         mediaOptions: MediaOptions;
+        mediaProvider: Promise<MediaProvider>;
+        node: PMNode;
+        view: EditorView;
     } & WrappedComponentProps>;
 };

package/dist/types/nodeviews/mediaInline.d.ts

@@ -12,28 +12,28 @@ import type { MediaClientConfig } from '@atlaskit/media-core/auth';
 import type { MediaNextEditorPluginType } from '../mediaPluginType';
 import type { getPosHandler, getPosHandler as ProsemirrorGetPosHandler } from '../types';
 export interface MediaInlineProps {
-    mediaProvider: Promise<MediaProvider>;
-    identifier: FileIdentifier;
-    node: PMNode;
-    isSelected: boolean;
-    view: EditorView;
-    getPos: ProsemirrorGetPosHandler;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    addPendingTask: (promise: Promise<any>) => void;
+    allowInlineImages?: boolean;
     contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    editorViewMode?: boolean;
+    getPos: ProsemirrorGetPosHandler;
     handleMediaNodeMount: (node: PMNode, getPos: ProsemirrorGetPosHandler) => void;
     handleMediaNodeUnmount: (node: PMNode) => void;
-    allowInlineImages?: boolean;
-    addPendingTask: (promise: Promise<any>) => void;
-    selectedMediaContainerNode: () => PMNode | undefined;
+    identifier: FileIdentifier;
+    isSelected: boolean;
     mediaClientConfig: MediaClientConfig;
-    editorViewMode?: boolean;
+    mediaProvider: Promise<MediaProvider>;
+    node: PMNode;
+    selectedMediaContainerNode: () => PMNode | undefined;
+    view: EditorView;
 }
 export declare const handleNewNode: (props: MediaInlineProps) => void;
 export declare const MediaInline: (props: MediaInlineProps) => jsx.JSX.Element;
 interface MediaInlineNodeViewProps {
-    providerFactory: ProviderFactory;
     api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
     dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    providerFactory: ProviderFactory;
 }
 export declare class MediaInlineNodeView extends SelectionBasedNodeView<MediaInlineNodeViewProps> {
     createDomRef(): HTMLSpanElement;

package/dist/types/nodeviews/mediaNodeUpdater.d.ts

@@ -5,18 +5,18 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { MediaTraceContext } from '@atlaskit/media-common';
 import type { MediaOptions, MediaPluginState, getPosHandler as ProsemirrorGetPosHandler, SupportedMediaAttributes } from '../types';
 type RemoteDimensions = {
-    id: string;
     height: number;
+    id: string;
     width: number;
 };
 export interface MediaNodeUpdaterProps {
-    view: EditorView;
-    node: PMNode;
-    mediaProvider?: Promise<MediaProvider>;
     contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
     isMediaSingle: boolean;
     mediaOptions?: MediaOptions;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    mediaProvider?: Promise<MediaProvider>;
+    node: PMNode;
+    view: EditorView;
 }
 export declare class MediaNodeUpdater {
     props: MediaNodeUpdaterProps;

package/dist/types/nodeviews/mediaNodeView/index.d.ts

@@ -12,9 +12,9 @@ import type { MediaNextEditorPluginType } from '../../mediaPluginType';
 import type { getPosHandler, MediaOptions } from '../../types';
 import type { MediaNodeViewProps } from '../types';
 interface MediaNodeWithPluginStateComponentProps {
-    width?: WidthPluginState;
-    mediaProvider?: Promise<MediaProvider>;
     interactionState?: SharedInteractionState['interactionState'];
+    mediaProvider?: Promise<MediaProvider>;
+    width?: WidthPluginState;
 }
 declare class MediaNodeView extends SelectionBasedNodeView<MediaNodeViewProps> {
     private isSelected;
@@ -24,8 +24,8 @@ declare class MediaNodeView extends SelectionBasedNodeView<MediaNodeViewProps> {
     getAttrs(): MediaADFAttrs;
     isMediaBlobUrl(): boolean;
     onExternalImageLoaded: (dimensions: {
-        width: number;
         height: number;
+        width: number;
     }) => void;
     renderMediaNodeWithState: (contextIdentifierProvider?: Promise<ContextIdentifierProvider>) => ({ width: editorWidth, mediaProvider, interactionState, }: MediaNodeWithPluginStateComponentProps) => React.JSX.Element;
     renderMediaNodeWithProviders: ({ contextIdentifierProvider }: Providers) => React.JSX.Element;

package/dist/types/nodeviews/mediaNodeView/media.d.ts

@@ -10,23 +10,23 @@ import type { MediaOptions, getPosHandler as ProsemirrorGetPosHandler, ReactNode
 export declare const MEDIA_HEIGHT = 125;
 export declare const FILE_WIDTH = 156;
 export interface MediaNodeProps extends ReactNodeProps, ImageLoaderProps {
-    view: EditorView;
-    node: PMNode;
-    getPos: ProsemirrorGetPosHandler;
     contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
-    originalDimensions: NumericalCardDimensions;
-    maxDimensions: CardDimensions;
-    isMediaSingle?: boolean;
-    onClick?: CardOnClickCallback;
-    mediaProvider?: Promise<MediaProvider>;
+    getPos: ProsemirrorGetPosHandler;
     isLoading?: boolean;
-    mediaOptions?: MediaOptions;
+    isMediaSingle?: boolean;
     isViewOnly?: boolean;
+    maxDimensions: CardDimensions;
+    mediaOptions?: MediaOptions;
+    mediaProvider?: Promise<MediaProvider>;
+    node: PMNode;
+    onClick?: CardOnClickCallback;
+    originalDimensions: NumericalCardDimensions;
+    view: EditorView;
 }
 interface MediaNodeState {
-    viewMediaClientConfig?: MediaClientConfig;
-    viewAndUploadMediaClientConfig?: MediaClientConfig;
     contextIdentifierProvider?: ContextIdentifierProvider;
+    viewAndUploadMediaClientConfig?: MediaClientConfig;
+    viewMediaClientConfig?: MediaClientConfig;
 }
 export declare class MediaNode extends Component<MediaNodeProps, MediaNodeState> {
     private mediaPluginState;

package/dist/types/nodeviews/mediaSingleNext.d.ts

@@ -8,26 +8,26 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { MediaNextEditorPluginType } from '../mediaPluginType';
 import type { ForwardRef, MediaOptions } from '../types';
 export type MediaSingleNodeNextProps = {
-    view: EditorView;
-    node: PMNode;
-    getPos: () => number | undefined;
+    addPendingTask?: (promise: Promise<any>) => void;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+    editorAppearance?: EditorAppearance;
+    editorDisabled?: boolean;
+    editorViewMode?: boolean;
     eventDispatcher: EventDispatcher;
-    width: number;
-    selected: Function;
+    forwardRef: ForwardRef;
+    fullWidthMode?: boolean;
+    getPos: () => number | undefined;
+    isCopyPasteEnabled?: boolean;
+    isDrafting?: boolean;
     lineLength: number;
     mediaOptions: MediaOptions;
     mediaProvider?: Promise<MediaProvider>;
-    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
-    fullWidthMode?: boolean;
-    addPendingTask?: (promise: Promise<any>) => void;
-    isDrafting?: boolean;
-    targetNodeId?: string;
-    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
-    isCopyPasteEnabled?: boolean;
-    forwardRef: ForwardRef;
+    node: PMNode;
     pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
-    editorViewMode?: boolean;
-    editorDisabled?: boolean;
-    editorAppearance?: EditorAppearance;
+    selected: Function;
+    targetNodeId?: string;
+    view: EditorView;
+    width: number;
 };
 export declare const MediaSingleNodeNext: (mediaSingleNodeNextProps: MediaSingleNodeNextProps) => jsx.JSX.Element;

package/dist/types/nodeviews/styles.d.ts

@@ -7,11 +7,11 @@ import { jsx } from '@emotion/react';
 import type { NumericalCardDimensions } from '@atlaskit/media-card';
 export declare const MediaSingleNodeSelector = "media-single-node";
 type MediaCardWrapperProps = {
-    dimensions: NumericalCardDimensions;
-    children: React.ReactNode;
-    selected?: boolean;
     borderWidth?: number;
+    children: React.ReactNode;
+    dimensions: NumericalCardDimensions;
     onContextMenu?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+    selected?: boolean;
 };
 export declare const MediaCardWrapper: ({ dimensions, children, selected, borderWidth, onContextMenu, }: MediaCardWrapperProps) => jsx.JSX.Element;
 export {};

package/dist/types/nodeviews/toDOM-fixes/mediaSingle.d.ts

@@ -1,25 +1,25 @@
 import type { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema/schema';
 import type { DOMOutputSpec, NodeSpec, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 type MediaWidthCSSCalcProps = {
-    layout: MediaSingleLayout;
-    mediaSingleDimensionWidth: number | undefined;
     baseWidth: number | undefined;
-    isPixelWidth: boolean;
     isExtendedResizeExperience: boolean;
+    isPixelWidth: boolean;
+    layout: MediaSingleLayout;
+    mediaSingleDimensionWidth: number | undefined;
 };
 export declare const mediaWidthCSSCalc: ({ mediaSingleDimensionWidth, layout, baseWidth, isPixelWidth, isExtendedResizeExperience, }: MediaWidthCSSCalcProps) => string;
 type MediaContentWrapperWidthCSSCalcProps = {
-    isMediaWrapped: boolean;
+    childMediaWidth: number | undefined;
     isExternalMedia: boolean;
+    isMediaWrapped: boolean;
     isPixelWidth: boolean;
-    childMediaWidth: number | undefined;
     mediaSingleDimensionWidth: number | undefined;
 };
 export declare const mediaContentWrapperWidthCSSCalc: ({ isMediaWrapped, isExternalMedia, isPixelWidth, childMediaWidth, mediaSingleDimensionWidth, }: MediaContentWrapperWidthCSSCalcProps) => string;
 type MediaProportionalWidthCSSCalcProps = {
-    isPixelWidth: boolean;
     isExtendedResizeExperience: boolean;
     isMediaWrapped: boolean;
+    isPixelWidth: boolean;
     mediaSingleDimensionWidth: number | undefined;
 };
 export declare const mediaProportionalWidthCSSCalc: ({ isPixelWidth, isExtendedResizeExperience, mediaSingleDimensionWidth, isMediaWrapped, }: MediaProportionalWidthCSSCalcProps) => string;
@@ -28,13 +28,13 @@ type MediaJustifyContentCSSProps = {
 };
 export declare const mediaJustifyContentCSS: ({ layout }: MediaJustifyContentCSSProps) => string;
 type PrepareWrapperContentDOMProps = {
-    layout: MediaSingleLayout;
-    dataAttrs: Record<string, unknown>;
-    childMediaWidth: number;
     childMediaHeight: number;
-    mediaSingleDimensionWidth: number;
-    isPixelWidth: boolean;
+    childMediaWidth: number;
+    dataAttrs: Record<string, unknown>;
     isExtendedResizeExperience: boolean;
+    isPixelWidth: boolean;
+    layout: MediaSingleLayout;
+    mediaSingleDimensionWidth: number;
 };
 export declare const prepareWrapperContentDOM: ({ layout, dataAttrs, childMediaWidth, childMediaHeight, mediaSingleDimensionWidth, isPixelWidth, isExtendedResizeExperience, }: PrepareWrapperContentDOMProps) => DOMOutputSpec;
 export declare const getToDom: (allowPixelResizing: boolean) => (node: PMNode) => DOMOutputSpec;

package/dist/types/nodeviews/types.d.ts

@@ -7,41 +7,41 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { MediaNextEditorPluginType } from '../mediaPluginType';
 import type { ForwardRef, MediaOptions, getPosHandler as ProsemirrorGetPosHandler } from '../types';
 export interface MediaSingleNodeProps {
-    view: EditorView;
-    node: PMNode;
-    getPos: ProsemirrorGetPosHandler;
+    addPendingTask?: (promise: Promise<any>) => void;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+    editorAppearance?: EditorAppearance;
+    editorDisabled?: boolean;
+    editorViewMode?: boolean;
     eventDispatcher: EventDispatcher;
-    width: number;
-    selected: Function;
+    forwardRef: ForwardRef;
+    fullWidthMode?: boolean;
+    getPos: ProsemirrorGetPosHandler;
+    isCopyPasteEnabled?: boolean;
+    isDrafting?: boolean;
     lineLength: number;
     mediaOptions: MediaOptions;
     mediaProvider?: Promise<MediaProvider>;
-    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
-    fullWidthMode?: boolean;
-    addPendingTask?: (promise: Promise<any>) => void;
-    isDrafting?: boolean;
-    targetNodeId?: string;
-    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
-    isCopyPasteEnabled?: boolean;
-    forwardRef: ForwardRef;
+    node: PMNode;
     pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
-    editorViewMode?: boolean;
-    editorDisabled?: boolean;
-    editorAppearance?: EditorAppearance;
+    selected: Function;
+    targetNodeId?: string;
+    view: EditorView;
+    width: number;
 }
 export interface MediaSingleNodeViewProps {
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    editorAppearance?: EditorAppearance;
     eventDispatcher: EventDispatcher;
-    providerFactory: ProviderFactory;
-    mediaOptions: MediaOptions;
     fullWidthMode?: boolean;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
     isCopyPasteEnabled?: boolean;
+    mediaOptions: MediaOptions;
     pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
-    editorAppearance?: EditorAppearance;
+    providerFactory: ProviderFactory;
 }
 export interface MediaNodeViewProps {
     eventDispatcher: EventDispatcher;
-    providerFactory: ProviderFactory;
     mediaOptions: MediaOptions;
     pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+    providerFactory: ProviderFactory;
 }

package/dist/types/pm-plugins/alt-text/ui/AltTextEdit.d.ts

@@ -5,18 +5,18 @@ import type { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 export declare const MAX_ALT_TEXT_LENGTH = 510;
 type Props = {
-    view: EditorView;
-    nodeType: 'mediaSingle' | 'mediaInline';
-    mediaType: 'file' | 'image' | 'external';
-    value?: string;
     altTextValidator?: (value: string) => string[];
-    onEscape?: () => void;
+    mediaType: 'file' | 'image' | 'external';
+    nodeType: 'mediaSingle' | 'mediaInline';
     onEnter?: () => void;
+    onEscape?: () => void;
+    value?: string;
+    view: EditorView;
 } & WrappedComponentProps & WithAnalyticsEventsProps;
 export type AltTextEditComponentState = {
+    lastValue: string | undefined;
     showClearTextButton: boolean;
     validationErrors: string[] | undefined;
-    lastValue: string | undefined;
 };
 export declare class AltTextEditComponent extends React.Component<Props, AltTextEditComponentState> {
     private fireCustomAnalytics?;

package/dist/types/pm-plugins/linking/actions.d.ts

@@ -11,8 +11,8 @@ interface HideAction {
     type: MediaLinkingActionsTypes.hideToolbar;
 }
 interface SetLinkToMedia {
-    type: MediaLinkingActionsTypes.setUrl;
     payload: string;
+    type: MediaLinkingActionsTypes.setUrl;
 }
 interface Unlink {
     type: MediaLinkingActionsTypes.unlink;

package/dist/types/pm-plugins/linking/types.d.ts

@@ -1,12 +1,12 @@
 export type InitialState = {
-    visible: false;
     editable: false;
     link: '';
     mediaPos: null;
+    visible: false;
 };
 export type MediaLinkingState = {
-    mediaPos: number | null;
-    link: string;
     editable: boolean;
+    link: string;
+    mediaPos: number | null;
     visible: boolean;
 };

package/dist/types/pm-plugins/picker-facade.d.ts

@@ -5,14 +5,14 @@ import type { UploadEndEventPayload, UploadErrorEventPayload, UploadParams, Uplo
 import type { CustomMediaPicker, MediaState, MediaStateEventSubscriber, MobileUploadEndEventPayload } from '../types';
 type PickerType = 'clipboard' | 'dropzone' | 'customMediaPicker';
 type ExtendedComponentConfigs = {
+    clipboard: null;
     customMediaPicker: CustomMediaPicker;
     dropzone: null;
-    clipboard: null;
 };
 export type PickerFacadeConfig = {
-    mediaClientConfig: MediaClientConfig;
     errorReporter: ErrorReportingHandler;
     featureFlags?: MediaFeatureFlags;
+    mediaClientConfig: MediaClientConfig;
 };
 type NewMediaEvent = (state: MediaState, onStateChanged: MediaStateEventSubscriber, pickerType?: string) => void;
 export default class PickerFacade {

package/dist/types/pm-plugins/pixel-resizing/ui/index.d.ts

@@ -8,12 +8,12 @@ import type { MediaNextEditorPluginType } from '../../../mediaPluginType';
 import type { MediaPluginState } from '../../../types';
 export type Props = {
     editorView: EditorView;
-    selectedMediaSingleNode: ContentNodeWithPos;
-    pluginInjectionApi?: ExtractInjectionAPI<MediaNextEditorPluginType>;
-    intl: IntlShape;
-    pluginState: MediaPluginState;
     hoverDecoration: HoverDecorationHandler | undefined;
+    intl: IntlShape;
     isEditorFullWidthEnabled?: boolean;
+    pluginInjectionApi?: ExtractInjectionAPI<MediaNextEditorPluginType>;
+    pluginState: MediaPluginState;
+    selectedMediaSingleNode: ContentNodeWithPos;
     triggerButtonSelector?: string;
 };
 export declare const PixelEntry: ({ editorView, selectedMediaSingleNode, pluginInjectionApi, intl, pluginState, hoverDecoration, isEditorFullWidthEnabled, triggerButtonSelector, }: Props) => jsx.JSX.Element | null;

package/dist/types/pm-plugins/pixel-resizing/ui/types.d.ts

@@ -6,77 +6,77 @@ export type PixelEntryProps = {
      */
     intl: IntlShape;
     /**
-     * The current pixel width
+     *
      */
-    width: number;
+    isViewMode?: boolean;
     /**
-     * The original media width used to calculate the height
+     * The maximum acceptable width input
      */
-    mediaWidth: number;
+    maxWidth: number;
     /**
      * The original media height used to calculate the width
      */
     mediaHeight: number;
     /**
-     * The minimum acceptable width input
+     * The original media width used to calculate the height
      */
-    minWidth: number;
+    mediaWidth: number;
     /**
-     * The maximum acceptable width input
+     * The minimum acceptable width input
      */
-    maxWidth: number;
+    minWidth: number;
     /**
      *
      * Handler for valid input
      */
     onChange?: (valid: boolean) => void;
     /**
-     * show migration button to convert to pixels for legacy image resize experience
-     */
-    showMigration?: boolean;
-    /**
-     * The submit function that is called when the form is valid and the submit key is pressed
-     */
-    onSubmit?: (value: PixelEntryFormData) => void;
-    /**
-     * An optional validate function that is called before onSubmit is called.
-     * The value passed through the validator currently comes from the width input only.
+     * Called when the Enter key is pressed or close button is clicked
      */
-    validate?: (value: number | '') => boolean;
+    onCloseAndSave?: (data: PixelEntryFormData, setFocus?: boolean) => void;
     /**
      * Migration handler called when the CTA button is clicked
      */
     onMigrate?: () => void;
     /**
-     * Called when the Enter key is pressed or close button is clicked
+     * The submit function that is called when the form is valid and the submit key is pressed
      */
-    onCloseAndSave?: (data: PixelEntryFormData, setFocus?: boolean) => void;
+    onSubmit?: (value: PixelEntryFormData) => void;
     /**
-     *
+     * show migration button to convert to pixels for legacy image resize experience
      */
-    isViewMode?: boolean;
+    showMigration?: boolean;
     /**
      * Selector of a button on the floating toolbar that opens PixelEntry.
      * Used to set focus back to that button once PixelEntry is unmounted due to key press on Esc Or Enter
      */
     triggerButtonSelector?: string;
+    /**
+     * An optional validate function that is called before onSubmit is called.
+     * The value passed through the validator currently comes from the width input only.
+     */
+    validate?: (value: number | '') => boolean;
+    /**
+     * The current pixel width
+     */
+    width: number;
 };
 export type PixelEntryFormValues = {
-    inputWidth: number | '';
     inputHeight: number | '';
+    inputWidth: number | '';
 };
 export type PixelEntryValidation = 'valid' | 'greater-than-max' | 'less-than-min';
 type PixelEntryFormData = {
-    width: number;
     validation: PixelEntryValidation;
+    width: number;
 };
 export type PixelEntryComponentNextProps = {
-    maxWidth: number;
-    computedWidth: number | '';
     computedHeight: number | '';
-    handleFieldChange: (type: string) => (event: ChangeEvent<HTMLInputElement>) => void;
+    computedWidth: number | '';
     formatMessage: IntlShape['formatMessage'];
     handleCloseAndSave: (data: PixelEntryFormValues, setFocus?: boolean) => void;
+    handleFieldChange: (type: string) => (event: ChangeEvent<HTMLInputElement>) => void;
     isViewMode?: boolean;
+    maxWidth: number;
 };
 export {};