@atlaskit/editor-plugin-media 0.2.0 → 0.3.1

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

@@ -0,0 +1,17 @@
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ErrorReporter } from '@atlaskit/editor-common/utils';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView, NodeView } from '@atlaskit/editor-prosemirror/view';
+import type { CustomMediaPicker, getPosHandler, MediaState } from './types';
+export type MediaPluginOptions = {
+    providerFactory: ProviderFactory;
+    nodeViews: {
+        [name: string]: (node: PMNode, view: EditorView, getPos: getPosHandler) => NodeView;
+    };
+    errorReporter?: ErrorReporter;
+    uploadErrorHandler?: (state: MediaState) => void;
+    waitForMediaUpload?: boolean;
+    customDropzoneContainer?: HTMLElement;
+    customMediaPicker?: CustomMediaPicker;
+    allowResizing: boolean;
+};

package/dist/types/next-plugin-type.d.ts

@@ -0,0 +1,33 @@
+import type { NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type { DecorationsPlugin } from '@atlaskit/editor-plugin-decorations';
+import type { EditorDisabledPlugin } from '@atlaskit/editor-plugin-editor-disabled';
+import type { FeatureFlagsPlugin } from '@atlaskit/editor-plugin-feature-flags';
+import type { FloatingToolbarPlugin } from '@atlaskit/editor-plugin-floating-toolbar';
+import type { FocusPlugin } from '@atlaskit/editor-plugin-focus';
+import type { GridPlugin } from '@atlaskit/editor-plugin-grid';
+import type { GuidelinePlugin } from '@atlaskit/editor-plugin-guideline';
+import type { SelectionPlugin } from '@atlaskit/editor-plugin-selection';
+import type { WidthPlugin } from '@atlaskit/editor-plugin-width';
+import type { MediaPluginState } from './pm-plugins/types';
+import type { MediaOptions } from './types';
+import type { InsertMediaAsMediaSingle } from './utils/media-single';
+export type MediaNextEditorPluginType = NextEditorPlugin<'media', {
+    pluginConfiguration: MediaOptions | undefined;
+    dependencies: [
+        FeatureFlagsPlugin,
+        OptionalPlugin<AnalyticsPlugin>,
+        GuidelinePlugin,
+        GridPlugin,
+        WidthPlugin,
+        DecorationsPlugin,
+        FloatingToolbarPlugin,
+        EditorDisabledPlugin,
+        FocusPlugin,
+        SelectionPlugin
+    ];
+    sharedState: MediaPluginState | null;
+    actions: {
+        insertMediaAsMediaSingle: InsertMediaAsMediaSingle;
+    };
+}>;

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

@@ -0,0 +1,24 @@
+export declare class MediaNodeUpdater {
+    static instances: MediaNodeUpdater[];
+    static mockOverrides: {};
+    static mockReset(): void;
+    constructor();
+    static setMock(thisKey: string, value: any): void;
+    updateContextId(): Promise<void>;
+    updateNodeContextId(): Promise<void>;
+    getAttrs(): void;
+    getObjectId(): Promise<void>;
+    getNodeContextId(): void;
+    updateDimensions(): void;
+    getRemoteDimensions(): Promise<void>;
+    isNodeFromDifferentCollection(): Promise<void>;
+    hasDifferentContextId(): Promise<void>;
+    copyNode(): Promise<void>;
+    copyNodeFromPos(): Promise<void>;
+    updateMediaSingleFileAttrs(): Promise<void>;
+    uploadExternalMedia(): Promise<void>;
+    isMediaBlobUrl(): void;
+    copyNodeFromBlobUrl(): void;
+    updateNodeAttrs(): void;
+    handleExternalMedia(): Promise<void>;
+}

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

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+import type { ContextIdentifierProvider, MediaProvider, ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView, NodeView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { MediaNextEditorPluginType } from '../next-plugin-type';
+import type { getPosHandler, MediaOptions } from '../types';
+export type MediaGroupProps = {
+    forwardRef?: (ref: HTMLElement) => void;
+    node: PMNode;
+    view: EditorView;
+    getPos: () => number | undefined;
+    disabled?: boolean;
+    allowLazyLoading?: boolean;
+    mediaProvider: Promise<MediaProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    isCopyPasteEnabled?: boolean;
+    anchorPos: number;
+    headPos: number;
+    mediaOptions: MediaOptions;
+} & WrappedComponentProps;
+export interface MediaGroupState {
+    viewMediaClientConfig?: MediaClientConfig;
+}
+declare const IntlMediaGroup: React.FC<import("react-intl-next").WithIntlProps<MediaGroupProps>> & {
+    WrappedComponent: React.ComponentType<MediaGroupProps>;
+};
+export default IntlMediaGroup;
+export declare const ReactMediaGroupNode: (portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, mediaOptions: MediaOptions | undefined, pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined) => (node: PMNode, view: EditorView, getPos: getPosHandler) => NodeView;

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

@@ -0,0 +1,50 @@
+import React from 'react';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+import type { ContextIdentifierProvider, MediaProvider, ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { SelectionBasedNodeView } from '@atlaskit/editor-common/selection-based-node-view';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView, NodeView } from '@atlaskit/editor-prosemirror/view';
+import type { FileIdentifier } from '@atlaskit/media-client';
+import type { MediaNextEditorPluginType } from '../next-plugin-type';
+import type { MediaPluginState } from '../pm-plugins/types';
+import type { getPosHandler, getPosHandler as ProsemirrorGetPosHandler } from '../types';
+import { MediaNodeUpdater } from './mediaNodeUpdater';
+export interface MediaInlineProps {
+    mediaProvider: Promise<MediaProvider>;
+    identifier: FileIdentifier;
+    node: PMNode;
+    isSelected: boolean;
+    view: EditorView;
+    getPos: ProsemirrorGetPosHandler;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    mediaPluginState: MediaPluginState;
+}
+export declare const createMediaNodeUpdater: (props: MediaInlineProps) => MediaNodeUpdater;
+/**
+ * Handles updating the media inline node attributes
+ * but also handling copy-paste for cross-editor of the same instance
+ * using the contextid
+ *
+ */
+export declare const updateMediaNodeAttributes: (props: MediaInlineProps, mediaNodeUpdater: MediaNodeUpdater) => Promise<void>;
+export declare const handleNewNode: (props: MediaInlineProps) => void;
+export declare const MediaInline: React.FC<MediaInlineProps>;
+export interface MediaInlineNodeViewProps {
+    providerFactory: ProviderFactory;
+    api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+}
+export declare class MediaInlineNodeView extends SelectionBasedNodeView<MediaInlineNodeViewProps> {
+    createDomRef(): HTMLSpanElement;
+    getContentDOM(): {
+        dom: HTMLSpanElement;
+    };
+    ignoreMutation(): boolean;
+    viewShouldUpdate(nextNode: PMNode): boolean;
+    render(props: MediaInlineNodeViewProps): JSX.Element;
+}
+export declare const ReactMediaInlineNode: (portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, api: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined, dispatchAnalyticsEvent?: DispatchAnalyticsEvent) => (node: PMNode, view: EditorView, getPos: getPosHandler) => NodeView;

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

@@ -0,0 +1,45 @@
+import type { MediaADFAttrs } from '@atlaskit/adf-schema';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { ContextIdentifierProvider, MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaTraceContext } from '@atlaskit/media-common';
+import type { MediaOptions, getPosHandler as ProsemirrorGetPosHandler } from '../types';
+export type RemoteDimensions = {
+    id: string;
+    height: number;
+    width: number;
+};
+export interface MediaNodeUpdaterProps {
+    view: EditorView;
+    node: PMNode;
+    mediaProvider?: Promise<MediaProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    isMediaSingle: boolean;
+    mediaOptions?: MediaOptions;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+}
+export declare class MediaNodeUpdater {
+    props: MediaNodeUpdaterProps;
+    constructor(props: MediaNodeUpdaterProps);
+    isMediaBlobUrl(): boolean;
+    updateContextId: () => Promise<void>;
+    updateNodeContextId: (getPos: ProsemirrorGetPosHandler) => Promise<void>;
+    private hasFileAttributesDefined;
+    private getNewFileAttrsForNode;
+    updateMediaSingleFileAttrs: () => Promise<void>;
+    updateNodeAttrs: (getPos: ProsemirrorGetPosHandler) => Promise<void>;
+    getAttrs: () => MediaADFAttrs | undefined;
+    getObjectId: () => Promise<string | null>;
+    uploadExternalMedia: (getPos: ProsemirrorGetPosHandler) => Promise<void>;
+    getNodeContextId: () => string | null;
+    updateDimensions: (dimensions: RemoteDimensions) => void;
+    getRemoteDimensions(): Promise<false | RemoteDimensions>;
+    hasDifferentContextId: () => Promise<boolean>;
+    isNodeFromDifferentCollection: () => Promise<boolean>;
+    handleExternalMedia(getPos: ProsemirrorGetPosHandler): Promise<void>;
+    copyNodeFromBlobUrl: (getPos: ProsemirrorGetPosHandler) => Promise<void>;
+    copyNodeFromPos: (getPos: ProsemirrorGetPosHandler, traceContext?: MediaTraceContext) => Promise<void>;
+    copyNode: (traceContext?: MediaTraceContext) => Promise<void>;
+    private copyFile;
+}

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

@@ -0,0 +1,28 @@
+/// <reference types="react" />
+import type { MediaADFAttrs } from '@atlaskit/adf-schema';
+import type { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+import type { ContextIdentifierProvider, MediaProvider, ProviderFactory, Providers } from '@atlaskit/editor-common/provider-factory';
+import { SelectionBasedNodeView } from '@atlaskit/editor-common/selection-based-node-view';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { WidthPluginState } from '@atlaskit/editor-plugin-width';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { Decoration, EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaNextEditorPluginType } from '../../next-plugin-type';
+import type { getPosHandler, MediaOptions } from '../../types';
+import type { MediaNodeViewProps } from '../types';
+declare class MediaNodeView extends SelectionBasedNodeView<MediaNodeViewProps> {
+    private isSelected;
+    createDomRef(): HTMLElement;
+    viewShouldUpdate(nextNode: PMNode, decorations: Decoration[]): boolean;
+    stopEvent(event: Event): boolean;
+    getAttrs(): MediaADFAttrs;
+    isMediaBlobUrl(): boolean;
+    renderMediaNodeWithState: (mediaProvider?: Promise<MediaProvider>, contextIdentifierProvider?: Promise<ContextIdentifierProvider>) => ({ width: editorWidth }: {
+        width?: import("@atlaskit/editor-common/types").EditorContainerWidth | undefined;
+    }) => JSX.Element;
+    renderMediaNodeWithProviders: ({ mediaProvider, contextIdentifierProvider, }: Providers) => JSX.Element;
+    render(): JSX.Element;
+}
+export declare const ReactMediaNode: (portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, mediaOptions: MediaOptions | undefined, pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined) => (node: PMNode, view: EditorView, getPos: getPosHandler) => MediaNodeView;
+export {};

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

@@ -0,0 +1,44 @@
+import React, { Component } from 'react';
+import type { ContextIdentifierProvider, MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import type { ImageLoaderProps } from '@atlaskit/editor-common/utils';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { CardDimensions, CardOnClickCallback, NumericalCardDimensions } from '@atlaskit/media-card';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { MediaOptions, getPosHandler as ProsemirrorGetPosHandler, ReactNodeProps } from '../../types';
+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>;
+    isLoading?: boolean;
+    mediaOptions?: MediaOptions;
+}
+interface MediaNodeState {
+    viewMediaClientConfig?: MediaClientConfig;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+}
+export declare class MediaNode extends Component<MediaNodeProps, MediaNodeState> {
+    private mediaPluginState;
+    state: MediaNodeState;
+    constructor(props: MediaNodeProps);
+    shouldComponentUpdate(nextProps: MediaNodeProps, nextState: MediaNodeState): boolean;
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: Readonly<MediaNodeProps>): void;
+    private setViewMediaClientConfig;
+    private selectMediaSingleFromCard;
+    private selectMediaSingle;
+    render(): JSX.Element;
+    private onFullscreenChange;
+    private handleNewNode;
+}
+declare const _default: React.ComponentClass<MediaNodeProps & ImageLoaderProps, any>;
+export default _default;

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

@@ -0,0 +1,62 @@
+/** @jsx jsx */
+import type { MouseEvent } from 'react';
+import React, { Component } from 'react';
+import { jsx } from '@emotion/react';
+import type { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+import type { ContextIdentifierProvider, ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import ReactNodeView from '@atlaskit/editor-common/react-node-view';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { Decoration, DecorationSource, EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { CardEvent } from '@atlaskit/media-card';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { MediaNextEditorPluginType } from '../next-plugin-type';
+import type { ForwardRef, getPosHandler } from '../types';
+import type { MediaOptions } from '../types';
+import { MediaNodeUpdater } from './mediaNodeUpdater';
+import type { MediaSingleNodeProps, MediaSingleNodeViewProps } from './types';
+export interface MediaSingleNodeState {
+    width?: number;
+    height?: number;
+    viewMediaClientConfig?: MediaClientConfig;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+    isCopying: boolean;
+}
+export default class MediaSingleNode extends Component<MediaSingleNodeProps, MediaSingleNodeState> {
+    static defaultProps: Partial<MediaSingleNodeProps>;
+    static displayName: string;
+    state: MediaSingleNodeState;
+    mediaSingleWrapperRef: React.RefObject<HTMLDivElement>;
+    captionPlaceHolderRef: React.RefObject<HTMLSpanElement>;
+    createMediaNodeUpdater: (props: MediaSingleNodeProps) => MediaNodeUpdater;
+    UNSAFE_componentWillReceiveProps(nextProps: MediaSingleNodeProps): void;
+    setViewMediaClientConfig: (props: MediaSingleNodeProps) => Promise<void>;
+    updateMediaNodeAttributes: (props: MediaSingleNodeProps) => Promise<void>;
+    componentDidMount(): Promise<void>;
+    selectMediaSingle: ({ event }: CardEvent) => void;
+    updateSize: (width: number | null, layout: MediaSingleLayout) => void;
+    onMediaSingleClicked: (event: MouseEvent) => void;
+    render(): jsx.JSX.Element;
+    private clickPlaceholder;
+}
+declare class MediaSingleNodeView extends ReactNodeView<MediaSingleNodeViewProps> {
+    lastOffsetLeft: number;
+    forceViewUpdate: boolean;
+    selectionType: number | null;
+    createDomRef(): HTMLElement;
+    getContentDOM(): {
+        dom: HTMLDivElement;
+    };
+    viewShouldUpdate(nextNode: PMNode): boolean;
+    checkAndUpdateSelectionType: () => import("@atlaskit/editor-common/utils").SelectedState | null;
+    isNodeSelected: () => boolean;
+    getNodeMediaId(node: PMNode): string | undefined;
+    update(node: PMNode, decorations: readonly Decoration[], _innerDecorations?: DecorationSource, isValidUpdate?: (currentNode: PMNode, newNode: PMNode) => boolean): boolean;
+    render(props: MediaSingleNodeViewProps, forwardRef?: ForwardRef): jsx.JSX.Element;
+    ignoreMutation(): boolean;
+}
+export declare const ReactMediaSingleNode: (portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined, dispatchAnalyticsEvent?: DispatchAnalyticsEvent, mediaOptions?: MediaOptions) => (node: PMNode, view: EditorView, getPos: getPosHandler) => MediaSingleNodeView;
+export {};

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

@@ -0,0 +1,7 @@
+export declare const messages: {
+    mediaGroupDeleteLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

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

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

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

@@ -0,0 +1,42 @@
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { ContextIdentifierProvider, MediaProvider, ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaNextEditorPluginType } from '../next-plugin-type';
+import type { MediaPluginState } from '../pm-plugins/types';
+import type { ForwardRef, MediaOptions, getPosHandler as ProsemirrorGetPosHandler } from '../types';
+export interface MediaSingleNodeProps {
+    view: EditorView;
+    node: PMNode;
+    getPos: ProsemirrorGetPosHandler;
+    eventDispatcher: EventDispatcher;
+    width: number;
+    selected: Function;
+    lineLength: number;
+    mediaOptions: MediaOptions;
+    mediaProvider?: Promise<MediaProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    fullWidthMode?: boolean;
+    mediaPluginState: MediaPluginState;
+    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+    isCopyPasteEnabled?: boolean;
+    forwardRef: ForwardRef;
+    pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+}
+export interface MediaSingleNodeViewProps {
+    eventDispatcher: EventDispatcher;
+    providerFactory: ProviderFactory;
+    mediaOptions: MediaOptions;
+    fullWidthMode?: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    isCopyPasteEnabled?: boolean;
+    pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+}
+export interface MediaNodeViewProps {
+    eventDispatcher: EventDispatcher;
+    providerFactory: ProviderFactory;
+    mediaOptions: MediaOptions;
+    pluginInjectionApi: ExtractInjectionAPI<MediaNextEditorPluginType> | undefined;
+}

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

@@ -0,0 +1,44 @@
+import type { ErrorReportingHandler } from '@atlaskit/editor-common/utils';
+import type { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { UploadEndEventPayload, UploadErrorEventPayload, UploadParams, UploadPreviewUpdateEventPayload } from '@atlaskit/media-picker/types';
+import type { CustomMediaPicker, MediaState, MobileUploadEndEventPayload } from './types';
+export type PickerType = 'clipboard' | 'dropzone' | 'customMediaPicker';
+export type ExtendedComponentConfigs = {
+    customMediaPicker: CustomMediaPicker;
+    dropzone: null;
+    clipboard: null;
+};
+export type PickerFacadeConfig = {
+    mediaClientConfig: MediaClientConfig;
+    errorReporter: ErrorReportingHandler;
+    featureFlags?: MediaFeatureFlags;
+};
+export type MediaStateEvent = MediaState;
+export type MediaStateEventListener = (evt: MediaStateEvent) => void;
+export type MediaStateEventSubscriber = (listener: MediaStateEventListener) => void;
+export type NewMediaEvent = (state: MediaState, onStateChanged: MediaStateEventSubscriber, pickerType?: string) => void;
+export default class PickerFacade {
+    readonly config: PickerFacadeConfig;
+    readonly pickerConfig?: CustomMediaPicker | null | undefined;
+    private picker?;
+    private onDragListeners;
+    private pickerType;
+    private onStartListeners;
+    private eventListeners;
+    private analyticsName;
+    erroredFiles: Set<string>;
+    constructor(pickerType: PickerType, config: PickerFacadeConfig, pickerConfig?: CustomMediaPicker | null | undefined, analyticsName?: string);
+    init(): Promise<PickerFacade>;
+    get type(): PickerType;
+    get mediaPicker(): CustomMediaPicker | undefined;
+    destroy(): void;
+    setUploadParams(params: UploadParams): void;
+    onNewMedia(cb: NewMediaEvent): void;
+    onDrag(cb: (state: 'enter' | 'leave') => any): void;
+    handleUploadPreviewUpdate: (event: UploadPreviewUpdateEventPayload) => void;
+    private subscribeStateChanged;
+    handleUploadError: ({ error, fileId }: UploadErrorEventPayload) => void;
+    handleMobileUploadEnd: (event: MobileUploadEndEventPayload) => void;
+    handleReady: (event: UploadEndEventPayload) => void;
+}

package/dist/types/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { MediaProvider } from '@atlaskit/editor-common/provider-factory';
+import type { MediaNextEditorPluginType } from './next-plugin-type';
+import type { MediaState } from './pm-plugins/main';
+import type { CustomMediaPicker } from './types';
+export type { MediaState, MediaProvider, CustomMediaPicker };
+export { insertMediaSingleNode } from './utils/media-single';
+export declare const mediaPlugin: MediaNextEditorPluginType;

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

@@ -0,0 +1,10 @@
+export type CloseMediaAltTextMenu = {
+    type: 'closeMediaAltTextMenu';
+};
+export type OpenMediaAltTextMenu = {
+    type: 'openMediaAltTextMenu';
+};
+export type UpdateAltText = {
+    type: 'updateAltText';
+};
+export type MediaAltTextAction = OpenMediaAltTextMenu | CloseMediaAltTextMenu | UpdateAltText;

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

@@ -0,0 +1,4 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+export declare const closeMediaAltTextMenu: import("@atlaskit/editor-common/types").Command;
+export declare const openMediaAltTextMenu: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => import("@atlaskit/editor-common/types").Command;
+export declare const updateAltText: (newAltText: string) => import("@atlaskit/editor-common/types").Command;

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

@@ -0,0 +1,7 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { PMPluginFactoryParams } from '@atlaskit/editor-common/types';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export declare const pluginKey: PluginKey<any>;
+declare const createCommand: <A = import("./actions").MediaAltTextAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction, state: import("prosemirror-state").EditorState) => import("prosemirror-state").Transaction) | undefined) => import("@atlaskit/editor-common/types").Command, getPluginState: (state: import("prosemirror-state").EditorState) => import("./types").MediaAltTextState;
+export declare const createPlugin: ({ dispatch, providerFactory, }: PMPluginFactoryParams) => SafePlugin<import("./types").MediaAltTextState>;
+export { createCommand, getPluginState };

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

@@ -0,0 +1,4 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+export default function keymapPlugin(schema: Schema, editorAnalyticsAPI: EditorAnalyticsAPI | undefined): SafePlugin;

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

@@ -0,0 +1,37 @@
+export declare const messages: {
+    altText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    editAltText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    back: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    clear: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    placeholder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    supportText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    validationMessage: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

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

@@ -0,0 +1,4 @@
+import type { MediaAltTextAction } from './actions';
+import type { MediaAltTextState } from './types';
+declare const _default: (state: MediaAltTextState, action: MediaAltTextAction) => MediaAltTextState;
+export default _default;

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

@@ -0,0 +1,3 @@
+export type MediaAltTextState = {
+    isAltTextEditorOpen: boolean;
+};

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

@@ -0,0 +1,41 @@
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+export declare const CONTAINER_WIDTH_IN_PX = 420;
+export declare const MAX_ALT_TEXT_LENGTH = 510;
+type Props = {
+    view: EditorView;
+    value?: string;
+    altTextValidator?: (value: string) => string[];
+    onEscape?: () => void;
+} & WrappedComponentProps & WithAnalyticsEventsProps;
+export type AltTextEditComponentState = {
+    showClearTextButton: boolean;
+    validationErrors: string[] | undefined;
+    lastValue: string | undefined;
+};
+export declare class AltTextEditComponent extends React.Component<Props, AltTextEditComponentState> {
+    private fireCustomAnalytics?;
+    state: {
+        showClearTextButton: boolean;
+        validationErrors: string[];
+        lastValue: string | undefined;
+    };
+    constructor(props: Props);
+    prevValue: string | undefined;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private getValidationErrors;
+    render(): jsx.JSX.Element;
+    private closeMediaAltTextMenu;
+    private fireAnalytics;
+    private dispatchCancelEvent;
+    private updateAltText;
+    private handleOnChange;
+    private handleOnBlur;
+    private handleClearText;
+}
+declare const _default: React.ForwardRefExoticComponent<Omit<React.PropsWithChildren<import("react-intl-next").WithIntlProps<Props>>, keyof WithAnalyticsEventsProps> & React.RefAttributes<any>>;
+export default _default;

package/dist/types/pm-plugins/keymap-media-single.d.ts

@@ -0,0 +1,3 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+export default function keymapPlugin(schema: Schema): SafePlugin;

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

@@ -0,0 +1,6 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { EditorSelectionAPI } from '@atlaskit/editor-plugin-selection';
+import type { MediaOptions } from '../types';
+export declare function keymapPlugin(options: MediaOptions | undefined, editorAnalyticsAPI: EditorAnalyticsAPI | undefined, editorSelectionAPI: EditorSelectionAPI | undefined): SafePlugin;
+export default keymapPlugin;

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

@@ -0,0 +1,20 @@
+export declare enum MediaLinkingActionsTypes {
+    showToolbar = "MEDIA_SHOW_TOOLBAR",
+    hideToolbar = "MEDIA_HIDE_TOOLBAR",
+    setUrl = "MEDIA_SET_LINK_TO",
+    unlink = "MEDIA_LINKING_UNLINK"
+}
+export interface VisibleAction {
+    type: MediaLinkingActionsTypes.showToolbar;
+}
+export interface HideAction {
+    type: MediaLinkingActionsTypes.hideToolbar;
+}
+export interface SetLinkToMedia {
+    type: MediaLinkingActionsTypes.setUrl;
+    payload: string;
+}
+export interface Unlink {
+    type: MediaLinkingActionsTypes.unlink;
+}
+export type MediaLinkingActions = VisibleAction | SetLinkToMedia | HideAction | Unlink;

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

@@ -0,0 +1,10 @@
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import type { MediaLinkingActions } from './actions';
+import type { MediaLinkingState } from './types';
+export declare const mediaLinkingPluginKey: PluginKey<MediaLinkingState>;
+export declare const createMediaLinkingCommand: <A = MediaLinkingActions>(action: A | ((state: Readonly<import("prosemirror-state").EditorState>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction, state: import("prosemirror-state").EditorState) => import("prosemirror-state").Transaction) | undefined) => import("@atlaskit/editor-common/types").Command, getMediaLinkingState: (state: import("prosemirror-state").EditorState) => MediaLinkingState;
+export type { MediaLinkingState } from './types';
+declare const _default: (dispatch: Dispatch) => SafePlugin<MediaLinkingState>;
+export default _default;