@atlaskit/editor-plugin-media 0.3.1 → 0.3.2

package/dist/types-ts4.5/utils/analytics.d.ts

@@ -0,0 +1,3 @@
+import type { MediaEventPayload, MediaInputResizeTrackAction, MediaResizeTrackAction } from '@atlaskit/editor-common/analytics';
+export declare const getMediaResizeAnalyticsEvent: <T extends MediaResizeTrackAction>(type: string, attributes: T["attributes"]) => MediaEventPayload | void;
+export declare const getMediaInputResizeAnalyticsEvent: <T extends MediaInputResizeTrackAction>(type: string, attributes: T["attributes"]) => MediaEventPayload | void;

package/dist/types-ts4.5/utils/check-media-type.d.ts

@@ -0,0 +1,4 @@
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { MediaType } from '@atlaskit/media-client';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+export declare const checkMediaType: (mediaNode: PMNode, mediaClientConfig: MediaClientConfig) => Promise<MediaType | 'external' | undefined>;

package/dist/types-ts4.5/utils/current-media-node.d.ts

@@ -0,0 +1,9 @@
+import type { BorderMarkAttributes } from '@atlaskit/adf-schema';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+export declare const currentMediaNodeWithPos: (editorState: EditorState) => {
+    node: PMNode;
+    pos: number;
+} | undefined;
+export declare const currentMediaNode: (editorState: EditorState) => PMNode | undefined;
+export declare const currentMediaNodeBorderMark: (editorState: EditorState) => BorderMarkAttributes | undefined;

package/dist/types-ts4.5/utils/is-image.d.ts

@@ -0,0 +1 @@
+export declare const isImage: (fileType?: string) => boolean;

package/dist/types-ts4.5/utils/media-common.d.ts

@@ -0,0 +1,20 @@
+import type { MediaADFAttrs } from '@atlaskit/adf-schema';
+import type { Node as PMNode, ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaState, getPosHandler as ProsemirrorGetPosHandler } from '../types';
+export declare const isMediaBlobUrlFromAttrs: (attrs: MediaADFAttrs) => boolean;
+export declare const posOfMediaGroupNearby: (state: EditorState) => number | undefined;
+export declare const isSelectionNonMediaBlockNode: (state: EditorState) => boolean;
+export declare const isSelectionMediaSingleNode: (state: EditorState) => boolean;
+export declare const posOfPrecedingMediaGroup: (state: EditorState) => number | undefined;
+/**
+ * Determine whether the cursor is inside empty paragraph
+ * or the selection is the entire paragraph
+ */
+export declare const isInsidePotentialEmptyParagraph: (state: EditorState) => boolean;
+export declare const posOfParentMediaGroup: (state: EditorState, $pos?: ResolvedPos, prepend?: boolean) => number | undefined;
+export declare const removeMediaNode: (view: EditorView, node: PMNode, getPos: ProsemirrorGetPosHandler) => void;
+export declare const splitMediaGroup: (view: EditorView) => boolean;
+export declare const copyOptionalAttrsFromMediaState: (mediaState: MediaState, node: PMNode) => void;
+export declare const getMediaNodeFromSelection: (state: EditorState) => PMNode | null;

package/dist/types-ts4.5/utils/media-files.d.ts

@@ -0,0 +1,30 @@
+import type { EditorAnalyticsAPI, InputMethodInsertMedia } from '@atlaskit/editor-common/analytics';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaState } from '../types';
+export interface Range {
+    start: number;
+    end: number;
+}
+export declare const canInsertMediaInline: (state: EditorState) => boolean;
+/**
+ * Create a new media inline to insert the new media.
+ * @param view Editor view
+ * @param mediaState Media file to be added to the editor
+ * @param collection Collection for the media to be added
+ */
+export declare const insertMediaInlineNode: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, mediaState: MediaState, collection: string, inputMethod?: InputMethodInsertMedia) => boolean;
+/**
+ * Insert a media into an existing media group
+ * or create a new media group to insert the new media.
+ * @param view Editor view
+ * @param mediaStates Media files to be added to the editor
+ * @param collection Collection for the media to be added
+ */
+export declare const insertMediaGroupNode: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (view: EditorView, mediaStates: MediaState[], collection: string, inputMethod?: InputMethodInsertMedia) => void;
+/**
+ * Return position of media to be inserted, if it is inside a list
+ * @param content Content to be inserted
+ * @param state Editor State
+ */
+export declare const getPosInList: (state: EditorState) => number | undefined;

package/dist/types-ts4.5/utils/media-single.d.ts

@@ -0,0 +1,20 @@
+import type { EditorAnalyticsAPI, InputMethodInsertMedia } from '@atlaskit/editor-common/analytics';
+import type { WidthPluginState } from '@atlaskit/editor-plugin-width';
+import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { MediaState } from '../types';
+export interface MediaSingleState extends MediaState {
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    scaleFactor?: number;
+    contextId?: string;
+}
+export declare const isMediaSingle: (schema: Schema, fileMimeType?: string) => boolean;
+export type InsertMediaAsMediaSingle = (view: EditorView, node: PMNode, inputMethod: InputMethodInsertMedia) => boolean;
+export declare const insertMediaAsMediaSingle: (view: EditorView, node: PMNode, inputMethod: InputMethodInsertMedia, editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => boolean;
+export declare const insertMediaSingleNode: (view: EditorView, mediaState: MediaState, inputMethod?: InputMethodInsertMedia, collection?: string, alignLeftOnInsert?: boolean, newInsertionBehaviour?: boolean, widthPluginState?: WidthPluginState | undefined, editorAnalyticsAPI?: EditorAnalyticsAPI | undefined) => boolean;
+export declare const createMediaSingleNode: (schema: Schema, collection: string, maxWidth?: number, minWidth?: number, alignLeftOnInsert?: boolean) => (mediaState: MediaSingleState) => PMNode;
+export declare function isCaptionNode(editorView: EditorView): boolean;
+export declare const isVideo: (fileType?: string) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/editor-plugin-media",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Media plugin for @atlaskit/editor-core",
   "author": "Atlassian Pty Ltd",
   "license": "Apache-2.0",
@@ -36,7 +36,7 @@
     "@atlaskit/analytics-namespaced-context": "^6.7.0",
     "@atlaskit/analytics-next": "^9.1.0",
     "@atlaskit/button": "^16.10.0",
-    "@atlaskit/editor-common": "^76.8.0",
+    "@atlaskit/editor-common": "^76.9.0",
     "@atlaskit/editor-palette": "1.5.1",
     "@atlaskit/editor-plugin-analytics": "^0.2.0",
     "@atlaskit/editor-plugin-decorations": "^0.2.0",
@@ -62,7 +62,7 @@
     "@atlaskit/platform-feature-flags": "^0.2.0",
     "@atlaskit/textfield": "^5.6.0",
     "@atlaskit/theme": "^12.6.0",
-    "@atlaskit/tokens": "^1.22.0",
+    "@atlaskit/tokens": "^1.26.0",
     "@atlaskit/tooltip": "^17.8.0",
     "@babel/runtime": "^7.0.0",
     "@emotion/react": "^11.7.1",

package/report.api.md

@@ -43,6 +43,7 @@ import type { OptionalPlugin } from '@atlaskit/editor-common/types';
 import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 import type { Providers } from '@atlaskit/editor-common/provider-factory';
 import type { RichMediaLayout } from '@atlaskit/adf-schema';
+import type { SelectionPlugin } from '@atlaskit/editor-plugin-selection';
 import type { UploadEndEventPayload } from '@atlaskit/media-picker/types';
 import type { UploadErrorEventPayload } from '@atlaskit/media-picker/types';
 import type { UploadParams } from '@atlaskit/media-picker/types';
@@ -164,6 +165,7 @@ export type MediaPlugin = NextEditorPlugin<
       FloatingToolbarPlugin,
       EditorDisabledPlugin,
       FocusPlugin,
+      SelectionPlugin,
     ];
     sharedState: MediaPluginState | null;
     actions: {

package/tmp/api-report-tmp.d.ts

@@ -0,0 +1,392 @@
+## API Report File for "@atlaskit/editor-plugin-media"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import type { DecorationsPlugin } from '@atlaskit/editor-plugin-decorations';
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import type { EditorDisabledPlugin } from '@atlaskit/editor-plugin-editor-disabled';
+import type { EditorSelectionAPI } from '@atlaskit/editor-common/selection';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { ErrorReporter } from '@atlaskit/editor-common/utils';
+import type { ErrorReportingHandler } from '@atlaskit/editor-common/utils';
+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 { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import type { GridPlugin } from '@atlaskit/editor-plugin-grid';
+import type { GuidelinePlugin } from '@atlaskit/editor-plugin-guideline';
+import type { InputMethodInsertMedia } from '@atlaskit/editor-common/analytics';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { MediaFeatureFlags } from '@atlaskit/media-common';
+import type { MediaFeatureFlags as MediaFeatureFlags_2 } from '@atlaskit/media-common/mediaFeatureFlags';
+import type { MediaFile } from '@atlaskit/media-picker/types';
+import type { MediaProvider as MediaProvider_2 } from '@atlaskit/editor-common/provider-factory';
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import type { Node as Node_2 } from '@atlaskit/editor-prosemirror/model';
+import type { NodeView } from '@atlaskit/editor-prosemirror/view';
+import type { OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { Providers } from '@atlaskit/editor-common/provider-factory';
+import type { RichMediaLayout } from '@atlaskit/adf-schema';
+import type { SelectionPlugin } from '@atlaskit/editor-plugin-selection';
+import type { UploadEndEventPayload } from '@atlaskit/media-picker/types';
+import type { UploadErrorEventPayload } from '@atlaskit/media-picker/types';
+import type { UploadParams } from '@atlaskit/media-picker/types';
+import type { UploadPreviewUpdateEventPayload } from '@atlaskit/media-picker/types';
+import type { WidthPlugin } from '@atlaskit/editor-plugin-width';
+
+// @public (undocumented)
+interface CustomMediaPicker {
+    // (undocumented)
+    destroy(): void;
+    // (undocumented)
+    emit(event: string, data: any): void;
+    // (undocumented)
+    on(event: string, cb: Listener): void;
+    // (undocumented)
+    removeAllListeners(event: any): void;
+    // (undocumented)
+    setUploadParams(uploadParams: UploadParams): void;
+}
+
+// @public (undocumented)
+type getPosHandler = getPosHandlerNode;
+
+// @public (undocumented)
+type getPosHandlerNode = () => number | undefined;
+
+// @public (undocumented)
+type InsertMediaAsMediaSingle = (view: EditorView, node: Node_2, inputMethod: InputMethodInsertMedia) => boolean;
+
+// @public (undocumented)
+type Listener = (data: any) => void;
+
+// @public (undocumented)
+interface MediaNodeWithPosHandler {
+    // (undocumented)
+    getPos: ProsemirrorGetPosHandler;
+    // (undocumented)
+    node: Node_2;
+}
+
+// @public (undocumented)
+interface MediaOptions {
+    // (undocumented)
+    alignLeftOnInsert?: boolean;
+    // (undocumented)
+    allowAdvancedToolBarOptions?: boolean;
+    // (undocumented)
+    allowAltTextOnImages?: boolean;
+    // (undocumented)
+    allowBreakoutSnapPoints?: boolean;
+    // (undocumented)
+    allowCaptions?: boolean;
+    // (undocumented)
+    allowDropzoneDropLine?: boolean;
+    // (undocumented)
+    allowLazyLoading?: boolean;
+    // (undocumented)
+    allowLinking?: boolean;
+    // (undocumented)
+    allowMarkingUploadsAsIncomplete?: boolean;
+    // (undocumented)
+    allowMediaGroup?: boolean;
+    // (undocumented)
+    allowMediaSingle?: MediaSingleOptions | boolean;
+    // (undocumented)
+    allowMediaSingleEditable?: boolean;
+    // (undocumented)
+    allowRemoteDimensionsFetch?: boolean;
+    // (undocumented)
+    allowResizing?: boolean;
+    // (undocumented)
+    allowResizingInTables?: boolean;
+    // (undocumented)
+    allowTemplatePlaceholders?: PlaceholderTextOptions | boolean;
+    // (undocumented)
+    altTextValidator?: (value: string) => string[];
+    // (undocumented)
+    customDropzoneContainer?: HTMLElement;
+    // (undocumented)
+    customMediaPicker?: CustomMediaPicker;
+    // (undocumented)
+    editorSelectionAPI?: EditorSelectionAPI;
+    // (undocumented)
+    enableDownloadButton?: boolean;
+    // (undocumented)
+    featureFlags?: MediaFeatureFlags;
+    // (undocumented)
+    fullWidthEnabled?: boolean;
+    // (undocumented)
+    getEditorFeatureFlags?: GetEditorFeatureFlags;
+    // (undocumented)
+    isCopyPasteEnabled?: boolean;
+    // (undocumented)
+    provider?: Providers['mediaProvider'];
+    // (undocumented)
+    uploadErrorHandler?: (state: MediaState) => void;
+    // (undocumented)
+    useForgePlugins?: boolean;
+    // (undocumented)
+    waitForMediaUpload?: boolean;
+}
+
+// @public (undocumented)
+export type MediaPlugin = NextEditorPlugin<'media', {
+    pluginConfiguration: MediaOptions | undefined;
+    dependencies: [
+    FeatureFlagsPlugin,
+    OptionalPlugin<AnalyticsPlugin>,
+    GuidelinePlugin,
+    GridPlugin,
+    WidthPlugin,
+    DecorationsPlugin,
+    FloatingToolbarPlugin,
+    EditorDisabledPlugin,
+    FocusPlugin,
+    SelectionPlugin
+    ];
+    sharedState: MediaPluginState | null;
+    actions: {
+        insertMediaAsMediaSingle: InsertMediaAsMediaSingle;
+    };
+}>;
+
+// @public (undocumented)
+export const mediaPlugin: MediaPlugin;
+
+// @public (undocumented)
+type MediaPluginOptions = {
+    providerFactory: ProviderFactory;
+    nodeViews: {
+        [name: string]: (node: Node_2, view: EditorView, getPos: getPosHandler) => NodeView;
+    };
+    errorReporter?: ErrorReporter;
+    uploadErrorHandler?: (state: MediaState) => void;
+    waitForMediaUpload?: boolean;
+    customDropzoneContainer?: HTMLElement;
+    customMediaPicker?: CustomMediaPicker;
+    allowResizing: boolean;
+};
+
+// @public (undocumented)
+interface MediaPluginState {
+    // (undocumented)
+    addPendingTask: (promise: Promise<any>) => void;
+    // (undocumented)
+    allowsUploads: boolean;
+    // (undocumented)
+    allUploadsFinished: boolean;
+    // (undocumented)
+    clone(): MediaPluginState;
+    // (undocumented)
+    currentMaxWidth?: number;
+    // (undocumented)
+    destroy(): void;
+    // (undocumented)
+    dispatch?: Dispatch;
+    // (undocumented)
+    editingMediaSinglePos?: number;
+    // (undocumented)
+    element?: HTMLElement;
+    // (undocumented)
+    findMediaNode: (id: string) => MediaNodeWithPosHandler | null;
+    // (undocumented)
+    getMediaOptions: () => MediaPluginOptions;
+    // (undocumented)
+    handleDrag: (dragState: 'enter' | 'leave') => void;
+    // (undocumented)
+    handleMediaGroupUpdate: (oldNodes: Node_2[], newNodes: Node_2[]) => void;
+    // (undocumented)
+    handleMediaNodeMount: (node: Node_2, getPos: ProsemirrorGetPosHandler) => void;
+    // (undocumented)
+    handleMediaNodeRemoval: (node: Node_2 | undefined, getPos: ProsemirrorGetPosHandler) => void;
+    // (undocumented)
+    handleMediaNodeUnmount: (oldNode: Node_2) => void;
+    // (undocumented)
+    ignoreLinks: boolean;
+    // (undocumented)
+    insertFile: (mediaState: MediaState, onMediaStateChanged: MediaStateEventSubscriber, pickerType?: string) => void;
+    // (undocumented)
+    isFullscreen: boolean;
+    // (undocumented)
+    isResizing: boolean;
+    // (undocumented)
+    layout: RichMediaLayout;
+    // (undocumented)
+    mediaClientConfig?: MediaClientConfig;
+    // (undocumented)
+    mediaNodes: MediaNodeWithPosHandler[];
+    // (undocumented)
+    mediaOptions?: MediaOptions;
+    // (undocumented)
+    mediaProvider?: MediaProvider_2;
+    // (undocumented)
+    onContextIdentifierProvider: (_name: string, provider?: Promise<ContextIdentifierProvider>) => Promise<void>;
+    // (undocumented)
+    onPopupPickerClose: () => void;
+    // (undocumented)
+    onPopupToggle: (onPopupToogleCallback: (isOpen: boolean) => void) => void;
+    // (undocumented)
+    options: MediaPluginOptions;
+    // (undocumented)
+    pickerPromises: Array<Promise<PickerFacade>>;
+    // (undocumented)
+    pickers: PickerFacade[];
+    // (undocumented)
+    removeSelectedMediaContainer: () => boolean;
+    // (undocumented)
+    resizingWidth: number;
+    // (undocumented)
+    selectedMediaContainerNode: () => Node_2 | undefined;
+    // (undocumented)
+    setBrowseFn: (browseFn: () => void) => void;
+    // (undocumented)
+    setIsResizing(isResizing: boolean): void;
+    // (undocumented)
+    setMediaProvider: (mediaProvider?: Promise<MediaProvider_2>) => Promise<void>;
+    // (undocumented)
+    setResizingWidth(width: number): void;
+    // (undocumented)
+    setView(view: EditorView): void;
+    // (undocumented)
+    showDropzone: boolean;
+    // (undocumented)
+    showEditingDialog?: boolean;
+    // (undocumented)
+    showMediaPicker: () => void;
+    // (undocumented)
+    splitMediaGroup: () => boolean;
+    // (undocumented)
+    updateAndDispatch(props: Partial<Pick<this, 'allUploadsFinished' | 'allowsUploads' | 'isFullscreen'>>): void;
+    // (undocumented)
+    updateElement(): void;
+    // (undocumented)
+    updateMediaSingleNodeAttrs: (id: string, attrs: object) => boolean | undefined;
+    // (undocumented)
+    uploadMediaClientConfig?: MediaClientConfig;
+    // (undocumented)
+    waitForMediaUpload: boolean;
+    // (undocumented)
+    waitForPendingTasks: (timeout?: number, lastTask?: Promise<MediaState | null>) => Promise<MediaState | null>;
+}
+
+// @public (undocumented)
+interface MediaSingleOptions {
+    // (undocumented)
+    disableLayout?: boolean;
+}
+
+// @public (undocumented)
+interface MediaState {
+    // (undocumented)
+    collection?: string;
+    // (undocumented)
+    contextId?: string;
+    // (undocumented)
+    dimensions?: {
+        width: number | undefined;
+        height: number | undefined;
+    };
+    // (undocumented)
+    error?: {
+        name: string;
+        description: string;
+    };
+    // (undocumented)
+    fileMimeType?: string;
+    // (undocumented)
+    fileName?: string;
+    // (undocumented)
+    fileSize?: number;
+    // (undocumented)
+    id: string;
+    publicId?: string;
+    // (undocumented)
+    scaleFactor?: number;
+    // (undocumented)
+    status?: MediaStateStatus;
+}
+
+// @public (undocumented)
+type MediaStateEvent = MediaState;
+
+// @public (undocumented)
+type MediaStateEventListener = (evt: MediaStateEvent) => void;
+
+// @public (undocumented)
+type MediaStateEventSubscriber = (listener: MediaStateEventListener) => void;
+
+// @public (undocumented)
+type MediaStateStatus = 'cancelled' | 'error' | 'mobile-upload-end' | 'preview' | 'ready' | 'unknown';
+
+// @public (undocumented)
+type MobileUploadEndEventPayload = {
+    readonly file: MediaFile & {
+        readonly collectionName?: string;
+        readonly publicId?: string;
+    };
+};
+
+// @public (undocumented)
+type NewMediaEvent = (state: MediaState, onStateChanged: MediaStateEventSubscriber, pickerType?: string) => void;
+
+// @public (undocumented)
+class PickerFacade {
+    constructor(pickerType: PickerType, config: PickerFacadeConfig, pickerConfig?: CustomMediaPicker | null | undefined, analyticsName?: string);
+    // (undocumented)
+    readonly config: PickerFacadeConfig;
+    // (undocumented)
+    destroy(): void;
+    // (undocumented)
+    erroredFiles: Set<string>;
+    // (undocumented)
+    handleMobileUploadEnd: (event: MobileUploadEndEventPayload) => void;
+    // (undocumented)
+    handleReady: (event: UploadEndEventPayload) => void;
+    // (undocumented)
+    handleUploadError: ({ error, fileId }: UploadErrorEventPayload) => void;
+    // (undocumented)
+    handleUploadPreviewUpdate: (event: UploadPreviewUpdateEventPayload) => void;
+    // (undocumented)
+    init(): Promise<PickerFacade>;
+    // (undocumented)
+    get mediaPicker(): CustomMediaPicker | undefined;
+    // (undocumented)
+    onDrag(cb: (state: 'enter' | 'leave') => any): void;
+    // (undocumented)
+    onNewMedia(cb: NewMediaEvent): void;
+    // (undocumented)
+    readonly pickerConfig?: CustomMediaPicker | null | undefined;
+    // (undocumented)
+    setUploadParams(params: UploadParams): void;
+    // (undocumented)
+    get type(): PickerType;
+}
+
+// @public (undocumented)
+type PickerFacadeConfig = {
+    mediaClientConfig: MediaClientConfig;
+    errorReporter: ErrorReportingHandler;
+    featureFlags?: MediaFeatureFlags_2;
+};
+
+// @public (undocumented)
+type PickerType = 'clipboard' | 'customMediaPicker' | 'dropzone';
+
+// @public (undocumented)
+interface PlaceholderTextOptions {
+    // (undocumented)
+    allowInserting?: boolean;
+}
+
+// @public (undocumented)
+type ProsemirrorGetPosHandler = getPosHandlerNode;
+
+// (No @packageDocumentation comment for this package)
+
+```