@atlaskit/editor-plugin-media 0.2.0 → 0.3.1

package/report.api.md

@@ -15,6 +15,436 @@
 <!--SECTION START: Main Entry Types-->
 
 ```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 { 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,
+    ];
+    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)
 ```
 

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,118 +0,0 @@
-import type { ProviderFactory, Providers } from '@atlaskit/editor-common/provider-factory';
-import type { EditorSelectionAPI } from '@atlaskit/editor-common/selection';
-import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
-import type { NodeType } from '@atlaskit/editor-prosemirror/model';
-import type { EditorView } from '@atlaskit/editor-prosemirror/view';
-import type { FileIdentifier } from '@atlaskit/media-client';
-import type { MediaFeatureFlags } from '@atlaskit/media-common';
-import type { MediaClientConfig } from '@atlaskit/media-core';
-import type { MediaFile, UploadParams } from '@atlaskit/media-picker/types';
-interface PlaceholderTextOptions {
-    allowInserting?: boolean;
-}
-export type MediaStateStatus = 'unknown' | 'ready' | 'cancelled' | 'preview' | 'error' | 'mobile-upload-end';
-export type MediaSingleWithType = 'pixel' | 'percentage';
-export interface MediaOptions {
-    provider?: Providers['mediaProvider'];
-    allowMediaSingle?: boolean | MediaSingleOptions;
-    allowMediaGroup?: boolean;
-    customDropzoneContainer?: HTMLElement;
-    customMediaPicker?: CustomMediaPicker;
-    allowResizing?: boolean;
-    allowResizingInTables?: boolean;
-    allowLinking?: boolean;
-    allowLazyLoading?: boolean;
-    allowBreakoutSnapPoints?: boolean;
-    allowAdvancedToolBarOptions?: boolean;
-    allowMediaSingleEditable?: boolean;
-    allowRemoteDimensionsFetch?: boolean;
-    allowDropzoneDropLine?: boolean;
-    allowMarkingUploadsAsIncomplete?: boolean;
-    fullWidthEnabled?: boolean;
-    uploadErrorHandler?: (state: MediaState) => void;
-    waitForMediaUpload?: boolean;
-    isCopyPasteEnabled?: boolean;
-    allowAltTextOnImages?: boolean;
-    enableDownloadButton?: boolean;
-    altTextValidator?: (value: string) => string[];
-    useForgePlugins?: boolean;
-    allowTemplatePlaceholders?: boolean | PlaceholderTextOptions;
-    alignLeftOnInsert?: boolean;
-    editorSelectionAPI?: EditorSelectionAPI;
-    featureFlags?: MediaFeatureFlags;
-    getEditorFeatureFlags?: GetEditorFeatureFlags;
-    allowCaptions?: boolean;
-}
-export interface MediaSingleOptions {
-    disableLayout?: boolean;
-}
-export interface MediaState {
-    id: string;
-    status?: MediaStateStatus;
-    fileName?: string;
-    fileSize?: number;
-    fileMimeType?: string;
-    collection?: string;
-    dimensions?: {
-        width: number | undefined;
-        height: number | undefined;
-    };
-    scaleFactor?: number;
-    error?: {
-        name: string;
-        description: string;
-    };
-    /** still require to support Mobile */
-    publicId?: string;
-    contextId?: string;
-}
-export type Listener = (data: any) => void;
-export interface CustomMediaPicker {
-    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 = {
-    readonly file: MediaFile & {
-        readonly collectionName?: string;
-        readonly publicId?: string;
-    };
-};
-export type MediaEditorState = {
-    mediaClientConfig?: MediaClientConfig;
-    editor?: {
-        pos: number;
-        identifier: FileIdentifier;
-    };
-};
-export type MediaToolbarBaseConfig = {
-    title: string;
-    getDomRef?: (view: EditorView) => HTMLElement | undefined;
-    nodeType: NodeType | NodeType[];
-};
-export type MediaFloatingToolbarOptions = {
-    providerFactory?: ProviderFactory;
-    allowResizing?: boolean;
-    allowMediaInline?: boolean;
-    allowLinking?: boolean;
-    allowAdvancedToolBarOptions?: boolean;
-    allowResizingInTables?: boolean;
-    allowAltTextOnImages?: boolean;
-    altTextValidator?: (value: string) => string[];
-    getEditorFeatureFlags?: GetEditorFeatureFlags;
-    fullWidthEnabled?: boolean;
-};
-export type MediaDecorationSpec = {
-    type: 'media';
-    selected: boolean;
-};
-export type ProsemirrorGetPosHandler = getPosHandlerNode;
-export type getPosHandler = getPosHandlerNode;
-export type getPosHandlerNode = () => number | undefined;
-export interface ReactNodeProps {
-    selected: boolean;
-}
-export type ForwardRef = (node: HTMLElement | null) => void;
-export {};

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

@@ -1,9 +0,0 @@
-## 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
-
-// (No @packageDocumentation comment for this package)
-
-```