@atlaskit/media-picker 63.0.4 → 63.0.6

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @atlaskit/media-picker
 
+## 63.0.6
+
+### Patch Changes
+
+- [`8cc2f888c83`](https://bitbucket.org/atlassian/atlassian-frontend/commits/8cc2f888c83) - Upgrade Typescript from `4.3.5` to `4.5.5`
+- Updated dependencies
+
+## 63.0.5
+
+### Patch Changes
+
+- [`45b6d35ea96`](https://bitbucket.org/atlassian/atlassian-frontend/commits/45b6d35ea96) - [ME-1327] Added new upload methods to editor mobile bridge to support previews and progress for media cards.
+
 ## 63.0.4
 
 ### Patch Changes

package/dist/cjs/util/analytics.js

@@ -22,7 +22,7 @@ var relevantFlags = {
   memoryCacheLogging: false
 };
 var packageName = "@atlaskit/media-picker";
-var packageVersion = "63.0.4";
+var packageVersion = "63.0.6";
 var LOGGED_FEATURE_FLAGS = (0, _mediaCommon.filterFeatureFlagNames)(relevantFlags);
 exports.LOGGED_FEATURE_FLAGS = LOGGED_FEATURE_FLAGS;
 var LOGGED_FEATURE_FLAG_KEYS = (0, _mediaCommon.filterFeatureFlagKeysAllProducts)(relevantFlags);

package/dist/cjs/util/ufoExperiences.js

@@ -20,7 +20,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 var packageName = "@atlaskit/media-picker";
-var packageVersion = "63.0.4";
+var packageVersion = "63.0.6";
 var ufoExperience;
 
 var initExperience = function initExperience(id, componentName) {

package/dist/cjs/version.json

@@ -1,4 +1,4 @@
 {
 	"name": "@atlaskit/media-picker",
-	"version": "63.0.4"
+	"version": "63.0.6"
 }

package/dist/es2019/util/analytics.js

@@ -12,7 +12,7 @@ const relevantFlags = {
   memoryCacheLogging: false
 };
 const packageName = "@atlaskit/media-picker";
-const packageVersion = "63.0.4";
+const packageVersion = "63.0.6";
 export const LOGGED_FEATURE_FLAGS = filterFeatureFlagNames(relevantFlags);
 export const LOGGED_FEATURE_FLAG_KEYS = filterFeatureFlagKeysAllProducts(relevantFlags);
 export function getPackageAttributes(componentName) {

package/dist/es2019/util/ufoExperiences.js

@@ -2,7 +2,7 @@ import { ConcurrentExperience, ExperiencePerformanceTypes, ExperienceTypes } fro
 import { getMediaEnvironment, getMediaRegion } from '@atlaskit/media-client';
 import { LOGGED_FEATURE_FLAG_KEYS } from './analytics';
 const packageName = "@atlaskit/media-picker";
-const packageVersion = "63.0.4";
+const packageVersion = "63.0.6";
 let ufoExperience;
 
 const initExperience = (id, componentName) => {

package/dist/es2019/version.json

@@ -1,4 +1,4 @@
 {
 	"name": "@atlaskit/media-picker",
-	"version": "63.0.4"
+	"version": "63.0.6"
 }

package/dist/esm/util/analytics.js

@@ -12,7 +12,7 @@ var relevantFlags = {
   memoryCacheLogging: false
 };
 var packageName = "@atlaskit/media-picker";
-var packageVersion = "63.0.4";
+var packageVersion = "63.0.6";
 export var LOGGED_FEATURE_FLAGS = filterFeatureFlagNames(relevantFlags);
 export var LOGGED_FEATURE_FLAG_KEYS = filterFeatureFlagKeysAllProducts(relevantFlags);
 export function getPackageAttributes(componentName) {

package/dist/esm/util/ufoExperiences.js

@@ -8,7 +8,7 @@ import { ConcurrentExperience, ExperiencePerformanceTypes, ExperienceTypes } fro
 import { getMediaEnvironment, getMediaRegion } from '@atlaskit/media-client';
 import { LOGGED_FEATURE_FLAG_KEYS } from './analytics';
 var packageName = "@atlaskit/media-picker";
-var packageVersion = "63.0.4";
+var packageVersion = "63.0.6";
 var ufoExperience;
 
 var initExperience = function initExperience(id, componentName) {

package/dist/esm/version.json

@@ -1,4 +1,4 @@
 {
 	"name": "@atlaskit/media-picker",
-	"version": "63.0.4"
+	"version": "63.0.6"
 }

package/dist/types/types.d.ts

@@ -28,7 +28,9 @@ export declare type UploadsStartEventPayload = {
     readonly files: MediaFile[];
 };
 export declare type UploadPreviewUpdateEventPayload = {
-    readonly file: MediaFile;
+    readonly file: MediaFile & {
+        readonly collectionName?: string;
+    };
     readonly preview: Preview;
 };
 export declare type UploadEndEventPayload = {

package/dist/types-ts4.0/components/browser/browser.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import { BrowserConfig } from '../../types';
+import { LocalUploadComponentReact, LocalUploadComponentBaseProps } from '../localUploadReact';
+export interface BrowserOwnProps {
+    config: BrowserConfig;
+    isOpen?: boolean;
+    onClose?: () => void;
+    /**
+     * This prop will be mainly used for those contexts (like Editor) where there is no react lifecylce and we cannot rerender easily.
+     * Otherwise, isOpen prop is preferred.
+     */
+    onBrowseFn?: (browse: () => void) => void;
+    onCancelFn?: (cancel: (uniqueIdentifier: string) => void) => void;
+    children?: (browse: () => void) => React.ReactChild;
+}
+export declare type BrowseFn = () => void;
+export declare type BrowserProps = LocalUploadComponentBaseProps & BrowserOwnProps;
+export declare class BrowserBase extends LocalUploadComponentReact<BrowserProps> {
+    private browserRef;
+    constructor(props: BrowserProps);
+    static defaultProps: {
+        config: BrowserConfig;
+    };
+    private onFilePicked;
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: BrowserProps): void;
+    browse: BrowseFn;
+    render(): JSX.Element;
+}
+export declare const Browser: React.ForwardRefExoticComponent<Pick<Pick<Omit<BrowserProps, keyof import("@atlaskit/analytics-next").WithAnalyticsEventsProps>, "mediaClient" | "onUploadsStart" | "onPreviewUpdate" | "onEnd" | "onError" | "featureFlags" | "children" | "onCancelFn" | "isOpen" | "onClose" | "onBrowseFn"> & Partial<Pick<Omit<BrowserProps, keyof import("@atlaskit/analytics-next").WithAnalyticsEventsProps>, "config">> & Partial<Pick<{
+    config: BrowserConfig;
+}, never>> & React.RefAttributes<any>, "mediaClient" | "config" | "onUploadsStart" | "onPreviewUpdate" | "onEnd" | "onError" | "featureFlags" | "children" | "onCancelFn" | "key" | "isOpen" | "onClose" | "onBrowseFn"> & React.RefAttributes<any>>;

package/dist/types-ts4.0/components/browser/index.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { BrowserProps } from './browser';
+import { WithMediaClientConfigProps } from '@atlaskit/media-client';
+import { BrowserConfig } from '../../types';
+declare type BrowserWithMediaClientConfigProps = WithMediaClientConfigProps<Omit<BrowserProps, 'config'> & {
+    config?: BrowserConfig;
+}>;
+declare type BrowserWithMediaClientConfigComponent = React.ComponentType<BrowserWithMediaClientConfigProps>;
+declare type State = {
+    Browser?: BrowserWithMediaClientConfigComponent;
+};
+export declare class BrowserLoader extends React.PureComponent<BrowserWithMediaClientConfigProps, State> {
+    private mounted;
+    static displayName: string;
+    static Browser?: BrowserWithMediaClientConfigComponent;
+    state: {
+        Browser: BrowserWithMediaClientConfigComponent | undefined;
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    UNSAFE_componentWillMount(): Promise<void>;
+    render(): JSX.Element | null;
+}
+export {};

package/dist/types-ts4.0/components/clipboard/clipboard.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="react" />
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { LocalUploadComponentReact, LocalUploadComponentBaseProps } from '../localUploadReact';
+import { LocalFileWithSource, UploadService } from '../../service/types';
+import { ClipboardConfig } from '../../types';
+export declare const getFilesFromClipboard: (files: FileList) => File[];
+export interface ClipboardOwnProps {
+    config: ClipboardConfig;
+}
+export declare type ClipboardProps = LocalUploadComponentBaseProps & {
+    config: ClipboardConfig;
+};
+declare class ClipboardImpl {
+    private readonly uploadService;
+    private readonly createAnalyticsEvent?;
+    static instances: ClipboardImpl[];
+    constructor(uploadService: UploadService, createAnalyticsEvent?: CreateUIAnalyticsEvent | undefined);
+    static get latestInstance(): ClipboardImpl | undefined;
+    activate(): void;
+    deactivate(): void;
+    onFilesPasted(files: LocalFileWithSource[]): void;
+    private fireAnalyticsEvent;
+    static handleEvent: (event: ClipboardEvent) => void;
+}
+export declare class ClipboardBase extends LocalUploadComponentReact<ClipboardProps> {
+    clipboard: ClipboardImpl;
+    constructor(props: ClipboardProps);
+    static defaultProps: {
+        config: ClipboardConfig;
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): null;
+}
+export declare const Clipboard: import("react").ForwardRefExoticComponent<Pick<Pick<Omit<ClipboardProps, keyof import("@atlaskit/analytics-next").WithAnalyticsEventsProps>, "mediaClient" | "onUploadsStart" | "onPreviewUpdate" | "onEnd" | "onError" | "featureFlags"> & Partial<Pick<Omit<ClipboardProps, keyof import("@atlaskit/analytics-next").WithAnalyticsEventsProps>, "config">> & Partial<Pick<{
+    config: ClipboardConfig;
+}, never>> & import("react").RefAttributes<any>, "mediaClient" | "config" | "onUploadsStart" | "onPreviewUpdate" | "onEnd" | "onError" | "featureFlags" | "key"> & import("react").RefAttributes<any>>;
+export {};

package/dist/types-ts4.0/components/clipboard/index.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { ClipboardProps } from './clipboard';
+import { ClipboardConfig } from '../../types';
+import { WithMediaClientConfigProps } from '@atlaskit/media-client';
+declare type ClipboardWithMediaClientConfigProps = WithMediaClientConfigProps<Omit<ClipboardProps, 'config'> & {
+    config?: ClipboardConfig;
+}>;
+declare type ClipboardWithMediaClientConfigComponent = React.ComponentType<ClipboardWithMediaClientConfigProps>;
+declare type State = {
+    Clipboard?: ClipboardWithMediaClientConfigComponent;
+};
+export declare class ClipboardLoader extends React.PureComponent<ClipboardWithMediaClientConfigProps, State> {
+    static displayName: string;
+    static Clipboard?: ClipboardWithMediaClientConfigComponent;
+    state: {
+        Clipboard: ClipboardWithMediaClientConfigComponent | undefined;
+    };
+    UNSAFE_componentWillMount(): Promise<void>;
+    render(): JSX.Element | null;
+}
+export {};

package/dist/types-ts4.0/components/component.d.ts

@@ -0,0 +1,17 @@
+import { MediaFile, Preview, MediaError, UploadEventPayloadMap } from '../types';
+import { GenericEventEmitter } from '../util/eventEmitter';
+import { SelectedItem } from '../popup/domain';
+export interface UploadEventEmitter {
+    emitPluginItemsInserted(selectedPluginItems: SelectedItem[]): void;
+    emitUploadsStart(files: MediaFile[]): void;
+    emitUploadPreviewUpdate(file: MediaFile, preview: Preview): void;
+    emitUploadEnd(file: MediaFile): void;
+    emitUploadError(fileId: string, error: MediaError): void;
+}
+export declare class UploadComponent<M extends UploadEventPayloadMap> extends GenericEventEmitter<M> implements UploadEventEmitter {
+    emitPluginItemsInserted(selectedPluginItems: SelectedItem[]): void;
+    emitUploadsStart(files: MediaFile[]): void;
+    emitUploadPreviewUpdate(file: MediaFile, preview: Preview): void;
+    emitUploadEnd(file: MediaFile): void;
+    emitUploadError(fileId: string, error: MediaError): void;
+}

package/dist/types-ts4.0/components/dropzone/dropzone.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="react" />
+import { LocalUploadComponentReact, LocalUploadComponentBaseProps } from '../localUploadReact';
+import { DropzoneConfig } from '../../types';
+import { DropzoneDragEnterEventPayload, DropzoneDragLeaveEventPayload, DropzoneUploadEventPayloadMap } from '../types';
+export declare type DropzoneProps = LocalUploadComponentBaseProps & {
+    config: DropzoneConfig;
+    onDrop?: () => void;
+    onDragEnter?: (payload: DropzoneDragEnterEventPayload) => void;
+    onDragLeave?: (payload: DropzoneDragLeaveEventPayload) => void;
+    onCancelFn?: (cancel: (uniqueIdentifier: string) => void) => void;
+};
+export declare class DropzoneBase extends LocalUploadComponentReact<DropzoneProps, DropzoneUploadEventPayloadMap> {
+    private uiActive;
+    constructor(props: DropzoneProps);
+    private getContainer;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: DropzoneProps): void;
+    private addContainerListeners;
+    private removeContainerListeners;
+    private onDragOver;
+    private onDragLeave;
+    private readonly onFileDropped;
+    private fireAnalyticsForFolders;
+    private getFilesFromDragEvent;
+    private filterFilesAgainstBlacklist;
+    private getDraggedItemsLength;
+    private onDropFolders;
+    private onDrop;
+    private sendAnalyticsAndEmitDragLeave;
+    private emitDragOver;
+    private emitDragLeave;
+    private fireAnalyticsEvent;
+    render(): null;
+}
+export declare const Dropzone: import("react").ForwardRefExoticComponent<Pick<Omit<DropzoneProps, keyof import("@atlaskit/analytics-next").WithAnalyticsEventsProps> & import("react").RefAttributes<any>, "mediaClient" | "config" | "onUploadsStart" | "onPreviewUpdate" | "onEnd" | "onError" | "featureFlags" | "onDrop" | "onDragEnter" | "onDragLeave" | "onCancelFn" | "key"> & import("react").RefAttributes<any>>;

package/dist/types-ts4.0/components/dropzone/index.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { WithMediaClientConfigProps } from '@atlaskit/media-client';
+import { DropzoneProps } from './dropzone';
+import { MediaPickerAnalyticsErrorBoundaryProps } from '../media-picker-analytics-error-boundary';
+export declare type DropzoneWithMediaClientConfigProps = WithMediaClientConfigProps<DropzoneProps>;
+declare type DropzoneWithMediaClientConfigComponent = React.ComponentType<DropzoneWithMediaClientConfigProps>;
+declare type MediaPickerErrorBoundaryComponent = React.ComponentType<MediaPickerAnalyticsErrorBoundaryProps>;
+export declare type State = {
+    Dropzone?: DropzoneWithMediaClientConfigComponent;
+    MediaPickerErrorBoundary?: MediaPickerErrorBoundaryComponent;
+};
+export declare class DropzoneLoader extends React.PureComponent<DropzoneWithMediaClientConfigProps, State> {
+    static displayName: string;
+    static Dropzone?: DropzoneWithMediaClientConfigComponent;
+    static MediaPickerErrorBoundary?: MediaPickerErrorBoundaryComponent;
+    state: {
+        Dropzone: DropzoneWithMediaClientConfigComponent | undefined;
+        MediaPickerErrorBoundary: MediaPickerErrorBoundaryComponent | undefined;
+    };
+    UNSAFE_componentWillMount(): Promise<void>;
+    render(): JSX.Element | null;
+}
+export {};

package/dist/types-ts4.0/components/localUploadReact.d.ts

@@ -0,0 +1,35 @@
+import { Component } from 'react';
+import { MediaClient } from '@atlaskit/media-client';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { UploadService } from '../service/types';
+import { UploadEndEventPayload, UploadErrorEventPayload, UploadPreviewUpdateEventPayload, UploadsStartEventPayload, UploadEventPayloadMap, UploadParams } from '../types';
+import { UploadComponent } from './component';
+import { LocalUploadConfig } from './types';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import { AnalyticsEventPayload } from '../types';
+import { ComponentName } from '../util/analytics';
+export declare type LocalUploadComponentBaseProps = {
+    mediaClient: MediaClient;
+    config: LocalUploadConfig;
+    onUploadsStart?: (payload: UploadsStartEventPayload) => void;
+    onPreviewUpdate?: (payload: UploadPreviewUpdateEventPayload) => void;
+    onEnd?: (payload: UploadEndEventPayload) => void;
+    onError?: (payload: UploadErrorEventPayload) => void;
+    featureFlags?: MediaFeatureFlags;
+} & WithAnalyticsEventsProps;
+export declare class LocalUploadComponentReact<Props extends LocalUploadComponentBaseProps, M extends UploadEventPayloadMap = UploadEventPayloadMap> extends Component<Props, {}> {
+    protected readonly componentName: ComponentName;
+    protected readonly uploadService: UploadService;
+    protected uploadComponent: UploadComponent<UploadEventPayloadMap>;
+    constructor(props: Props, componentName: ComponentName);
+    private fireCommencedEvent;
+    private fireUploadSucceeded;
+    private fireUploadFailed;
+    protected createAndFireAnalyticsEvent: (payload: AnalyticsEventPayload) => void;
+    cancel: (uniqueIdentifier?: string | undefined) => void;
+    setUploadParams(uploadParams: UploadParams): void;
+    private onFilesAdded;
+    private onFilePreviewUpdate;
+    private onFileConverting;
+    private onUploadError;
+}

package/dist/types-ts4.0/components/media-picker-analytics-error-boundary.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export declare type MediaPickerAnalyticsErrorBoundaryProps = {
+    data?: {
+        [k: string]: any;
+    };
+};
+export default class MediaPickerAnalyticsErrorBoundary extends React.Component<MediaPickerAnalyticsErrorBoundaryProps> {
+    static displayName: string;
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/components/types.d.ts

@@ -0,0 +1,18 @@
+import { UploadEventPayloadMap, UploadParams } from '../types';
+import { MediaFeatureFlags } from '@atlaskit/media-common/mediaFeatureFlags';
+export interface LocalUploadConfig {
+    uploadParams: UploadParams;
+    shouldCopyFileToRecents?: boolean;
+    featureFlags?: MediaFeatureFlags;
+}
+export interface DropzoneDragEnterEventPayload {
+    length: number;
+}
+export interface DropzoneDragLeaveEventPayload {
+    length: number;
+}
+export declare type DropzoneUploadEventPayloadMap = UploadEventPayloadMap & {
+    readonly drop: undefined;
+    readonly 'drag-enter': DropzoneDragEnterEventPayload;
+    readonly 'drag-leave': DropzoneDragLeaveEventPayload;
+};

package/dist/types-ts4.0/config.d.ts

@@ -0,0 +1,8 @@
+export interface AppConfig {
+    readonly version: number;
+    readonly html: {
+        readonly redirectUrl: string;
+    };
+}
+declare const _default: AppConfig;
+export default _default;

package/dist/types-ts4.0/domain/plugin.d.ts

@@ -0,0 +1,8 @@
+export interface PluginFile {
+    id: string;
+    metadata: any;
+}
+export interface PluginItemPayload {
+    pluginName: string;
+    pluginFile: PluginFile;
+}

package/dist/types-ts4.0/domain/preview.d.ts

@@ -0,0 +1,2 @@
+import { Preview, ImagePreview } from '../types';
+export declare const isImagePreview: (preview: Preview) => preview is ImagePreview;

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

@@ -0,0 +1,6 @@
+export { isImagePreview } from './domain/preview';
+export type { BrowserConfig, DropzoneConfig, UploadParams, UploadsStartEventPayload, UploadPreviewUpdateEventPayload, UploadEndEventPayload, UploadErrorEventPayload, MediaFile, Preview, NonImagePreview, ImagePreview, MediaError, MediaErrorName, } from './types';
+export type { LocalUploadConfig } from './components/types';
+export { DropzoneLoader as Dropzone } from './components/dropzone';
+export { ClipboardLoader as Clipboard } from './components/clipboard';
+export { BrowserLoader as Browser } from './components/browser';

package/dist/types-ts4.0/popup/domain/index.d.ts

@@ -0,0 +1,14 @@
+export interface ServiceFile {
+    readonly mimeType: string;
+    readonly id: string;
+    readonly name: string;
+    readonly size: number;
+    readonly date: number;
+    readonly occurrenceKey?: string;
+    readonly metadata?: any;
+    readonly createdAt?: number;
+}
+export interface SelectedItem extends ServiceFile {
+    readonly serviceName: string;
+    readonly accountId?: string;
+}

package/dist/types-ts4.0/service/types.d.ts

@@ -0,0 +1,29 @@
+import { UploadEndEventPayload, UploadErrorEventPayload, UploadPreviewUpdateEventPayload, UploadsStartEventPayload, UploadParams } from '../types';
+export declare type UploadServiceEventPayloadTypes = {
+    readonly 'files-added': UploadsStartEventPayload;
+    readonly 'file-preview-update': UploadPreviewUpdateEventPayload;
+    readonly 'file-converting': UploadEndEventPayload;
+    readonly 'file-upload-error': UploadErrorEventPayload;
+    readonly 'file-dropped': DragEvent;
+};
+export declare type UploadServiceEventListener<E extends keyof UploadServiceEventPayloadTypes> = (payload: UploadServiceEventPayloadTypes[E]) => void;
+export declare const MAX_FILE_SIZE_FOR_PREVIEW = 10000000;
+export interface UploadService {
+    setUploadParams(uploadParams: UploadParams): void;
+    addFile(file: File, replaceFileId?: string): void;
+    addFiles(files: File[]): void;
+    addFilesWithSource(files: LocalFileWithSource[]): void;
+    cancel(id?: string): void;
+    on<E extends keyof UploadServiceEventPayloadTypes>(event: E, listener: UploadServiceEventListener<E>): void;
+    off<E extends keyof UploadServiceEventPayloadTypes>(event: E, listener: UploadServiceEventListener<E>): void;
+}
+export declare enum LocalFileSource {
+    PastedFile = "pastedFile",
+    PastedScreenshot = "pastedScreenshot",
+    LocalUpload = "localUpload"
+}
+export interface LocalFileWithSource {
+    file: File;
+    source: LocalFileSource;
+    replaceFileId?: string;
+}

package/dist/types-ts4.0/service/uploadServiceImpl.d.ts

@@ -0,0 +1,33 @@
+import { MediaClient } from '@atlaskit/media-client';
+import { MediaFile, UploadParams } from '../types';
+import { UploadService, UploadServiceEventListener, UploadServiceEventPayloadTypes } from './types';
+import { LocalFileSource, LocalFileWithSource } from '../service/types';
+export interface CancellableFileUpload {
+    mediaFile: MediaFile;
+    file: File;
+    source: LocalFileSource;
+    cancel?: () => void;
+}
+export declare class UploadServiceImpl implements UploadService {
+    private readonly tenantMediaClient;
+    private tenantUploadParams;
+    private readonly shouldCopyFileToRecents;
+    private readonly userMediaClient?;
+    private readonly emitter;
+    private cancellableFilesUploads;
+    constructor(tenantMediaClient: MediaClient, tenantUploadParams: UploadParams, shouldCopyFileToRecents: boolean);
+    setUploadParams(uploadParams: UploadParams): void;
+    private createUploadController;
+    addFiles(files: File[]): void;
+    addFile(file: File, replaceFileId?: string): void;
+    addFilesWithSource(files: LocalFileWithSource[]): void;
+    cancel(id?: string): void;
+    on<E extends keyof UploadServiceEventPayloadTypes>(event: E, listener: UploadServiceEventListener<E>): void;
+    off<E extends keyof UploadServiceEventPayloadTypes>(event: E, listener: UploadServiceEventListener<E>): void;
+    private readonly emit;
+    private emitPreviews;
+    private getMediaTypeFromFile;
+    private releaseCancellableFile;
+    private readonly onFileSuccess;
+    private readonly onFileError;
+}

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

@@ -0,0 +1,120 @@
+import { RequestMetadata } from '@atlaskit/media-client';
+import { UIAttributes, UIEventPayload, OperationalAttributes, SuccessAttributes, FailureAttributes, OperationalEventPayload } from '@atlaskit/media-common';
+import { LocalUploadConfig } from './components/types';
+import { PluginItemPayload } from './domain/plugin';
+export interface UploadParams {
+    collection?: string;
+}
+export declare type MediaFile = {
+    readonly id: string;
+    readonly name: string;
+    readonly size: number;
+    readonly creationDate: number;
+    readonly type: string;
+    readonly occurrenceKey?: string;
+};
+export declare type NonImagePreview = {
+    readonly file?: Blob;
+};
+export declare type ImagePreview = NonImagePreview & {
+    readonly dimensions: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly scaleFactor: number;
+};
+export declare type Preview = NonImagePreview | ImagePreview;
+export declare type UploadsStartEventPayload = {
+    readonly files: MediaFile[];
+};
+export declare type UploadPreviewUpdateEventPayload = {
+    readonly file: MediaFile & {
+        readonly collectionName?: string;
+    };
+    readonly preview: Preview;
+};
+export declare type UploadEndEventPayload = {
+    readonly file: MediaFile;
+};
+export declare type UploadErrorEventPayload = {
+    readonly fileId: string;
+    readonly error: MediaError;
+};
+export declare type UploadEventPayloadMap = {
+    readonly 'plugin-items-inserted': PluginItemPayload[];
+    readonly 'uploads-start': UploadsStartEventPayload;
+    readonly 'upload-preview-update': UploadPreviewUpdateEventPayload;
+    readonly 'upload-end': UploadEndEventPayload;
+    readonly 'upload-error': UploadErrorEventPayload;
+};
+export interface BrowserConfig extends LocalUploadConfig {
+    readonly multiple?: boolean;
+    readonly fileExtensions?: Array<string>;
+    readonly replaceFileId?: string;
+}
+export interface ClipboardConfig extends LocalUploadConfig {
+}
+export interface DropzoneConfig extends LocalUploadConfig {
+    container?: HTMLElement;
+    headless?: boolean;
+}
+export declare type MediaErrorName = 'object_create_fail' | 'metadata_fetch_fail' | 'token_fetch_fail' | 'token_update_fail' | 'token_source_empty' | 'upload_fail' | 'user_token_fetch_fail' | 'remote_upload_fail' | 'invalid_uuid';
+export declare type MediaError = {
+    readonly fileId?: string;
+    readonly name: MediaErrorName;
+    readonly description: string;
+    readonly rawError?: Error;
+};
+export type { PluginItemPayload } from './domain/plugin';
+export type { DropzoneDragEnterEventPayload } from './components/types';
+export declare type ButtonClickedPayload = UIEventPayload<UIAttributes & {
+    fileId?: string;
+    fileCount?: number;
+    collectionName?: string;
+    cloudType?: string;
+    serviceNames?: string[];
+    files?: Array<{
+        serviceName: string;
+        accountId?: string;
+        fileId: string;
+        fileMimetype: string;
+        fileSize: number;
+        fileAge?: string;
+    }>;
+}, 'clicked', 'button'>;
+export declare type ClipboardPastePayload = UIEventPayload<UIAttributes & {
+    fileCount?: number;
+    fileAttributes: Array<{
+        fileMimetype: string;
+        fileSize: number;
+    }>;
+}, 'pasted', 'clipboard'>;
+export declare type DropzoneEventAction = 'draggedOut' | 'draggedInto' | 'droppedInto' | 'folderDroppedInto';
+export declare type DropzoneEventPayload = UIEventPayload<UIAttributes & {
+    fileCount: number;
+}, DropzoneEventAction, 'dropzone'>;
+export declare type MediaUploadType = 'localMedia' | 'cloudMedia';
+export declare type MediaUploadSource = 'local' | 'cloud';
+export declare type MediaUploadCommencedPayload = OperationalEventPayload<OperationalAttributes & {
+    sourceType: MediaUploadSource;
+    serviceName: string;
+}, 'commenced', 'mediaUpload', MediaUploadType>;
+export declare type MediaUploadSuccessPayload = OperationalEventPayload<OperationalAttributes & SuccessAttributes & {
+    sourceType: MediaUploadSource;
+    serviceName: string;
+    uploadDurationMsec: number;
+}, 'succeeded', 'mediaUpload', MediaUploadType>;
+export declare type MediaUploadFailurePayload = OperationalEventPayload<OperationalAttributes & FailureAttributes & {
+    sourceType: MediaUploadSource;
+    serviceName: string;
+    uploadDurationMsec: number;
+    request?: RequestMetadata;
+}, 'failed', 'mediaUpload', MediaUploadType>;
+export declare type UnhandledErrorPayload = OperationalEventPayload<OperationalAttributes & FailureAttributes & {
+    browserInfo: string;
+    info?: string;
+}, 'unhandledError', 'error'>;
+export declare type UUIDValidationErrorPayload = OperationalEventPayload<OperationalAttributes & FailureAttributes & {
+    uuid: string;
+}, 'failed', 'mediaUpload'>;
+export declare type AnalyticsEventPayload = ButtonClickedPayload | ClipboardPastePayload | MediaUploadCommencedPayload | MediaUploadSuccessPayload | MediaUploadFailurePayload | UnhandledErrorPayload | UUIDValidationErrorPayload;

package/dist/types-ts4.0/util/analytics.d.ts

@@ -0,0 +1,7 @@
+import { RequestMetadata } from '@atlaskit/media-client';
+import { PackageAttributes } from '@atlaskit/media-common';
+export declare type ComponentName = 'browser' | 'clipboard' | 'dropzone';
+export declare const LOGGED_FEATURE_FLAGS: (keyof import("@atlaskit/media-common").MediaFeatureFlags)[];
+export declare const LOGGED_FEATURE_FLAG_KEYS: string[];
+export declare function getPackageAttributes(componentName: ComponentName): PackageAttributes;
+export declare function getRequestMetadata(error?: Error): RequestMetadata | undefined;

package/dist/types-ts4.0/util/appendTimestamp.d.ts

@@ -0,0 +1 @@
+export declare const appendTimestamp: (fileName: string, timestamp: number) => string;

package/dist/types-ts4.0/util/eventEmitter.d.ts

@@ -0,0 +1,25 @@
+export declare type EventPayloadMap<P = any> = {
+    readonly [event: string]: P;
+};
+export declare type EventPayloadListener<M extends EventPayloadMap<P>, E extends keyof M, P = any> = (payload: M[E]) => void;
+export interface EventEmitter<M extends EventPayloadMap<P>, P = any> {
+    once<E extends keyof M>(event: E, listener: EventPayloadListener<M, E>): void;
+    on<E extends keyof M>(event: E, listener: EventPayloadListener<M, E>): void;
+    onAny<E extends keyof M>(listener: (event: E, payload: M[E]) => void): void;
+    addListener<E extends keyof M>(event: E, listener: EventPayloadListener<M, E>): void;
+    off<E extends keyof M>(event: E, listener: EventPayloadListener<M, E>): void;
+    removeListener<E extends keyof M>(event: E, handler: EventPayloadListener<M, E>): void;
+    removeAllListeners<E extends keyof M>(event?: E): void;
+    emit<E extends keyof M>(event: E, payload: M[E]): boolean;
+}
+export declare class GenericEventEmitter<M extends EventPayloadMap<P>, P = any> implements EventEmitter<M> {
+    private readonly emitter;
+    once<E extends keyof M>(event: E, listener: EventPayloadListener<M, E>): void;
+    on<E extends keyof M>(event: E, listener: EventPayloadListener<M, E>): void;
+    onAny<E extends keyof M>(listener: (event: E, payload: M[E]) => void): void;
+    addListener<E extends keyof M>(event: E, listener: EventPayloadListener<M, E>): void;
+    off<E extends keyof M>(event: E, listener: EventPayloadListener<M, E>): void;
+    removeListener<E extends keyof M>(event: E, handler: EventPayloadListener<M, E>): void;
+    removeAllListeners<E extends keyof M>(event?: E): void;
+    emit<E extends keyof M>(event: E, payload: M[E]): boolean;
+}

package/dist/types-ts4.0/util/getPreviewFromBlob.d.ts

@@ -0,0 +1,4 @@
+import { MediaType, Dimensions } from '@atlaskit/media-client';
+import { Preview } from '../types';
+export declare const isUnknownDimensions: (dimensions: Dimensions) => boolean;
+export declare function getPreviewFromBlob(mediaType: MediaType, file: Blob): Promise<Preview>;

package/dist/types-ts4.0/util/getPreviewFromImage.d.ts

@@ -0,0 +1,3 @@
+import { Preview } from '../types';
+export declare function getPreviewFromImage(file: File, devicePixelRatio?: number): Promise<Preview>;
+export declare const SCALE_FACTOR_DEFAULT = 1;

package/dist/types-ts4.0/util/ufoExperiences.d.ts

@@ -0,0 +1,13 @@
+import { FileAttributes, WithFileAttributes } from '@atlaskit/media-common';
+import { RequestMetadata } from '@atlaskit/media-client';
+import { ComponentName } from './analytics';
+export declare type UFOFailedEventPayload = {
+    failReason: string;
+    error?: string;
+    errorDetail?: string | undefined;
+    uploadDurationMsec: number;
+    request?: RequestMetadata;
+} & WithFileAttributes;
+export declare const startMediaUploadUfoExperience: (id: string, componentName: ComponentName) => void;
+export declare const succeedMediaUploadUfoExperience: (id: string, properties: FileAttributes) => void;
+export declare const failMediaUploadUfoExperience: (id: string, properties?: UFOFailedEventPayload | undefined) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/media-picker",
-  "version": "63.0.4",
+  "version": "63.0.6",
   "description": "Library for handling file uploads",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -12,6 +12,13 @@
   "module": "dist/esm/index.js",
   "module:es2019": "dist/es2019/index.js",
   "types": "dist/types/index.d.ts",
+  "typesVersions": {
+    ">=4.0 <4.5": {
+      "*": [
+        "dist/types-ts4.0/*"
+      ]
+    }
+  },
   "atlaskit:src": "src/index.ts",
   "af:exports": {
     "./types": "./src/types.ts",
@@ -41,7 +48,7 @@
     "uuid-validate": "^0.0.3"
   },
   "peerDependencies": {
-    "@atlaskit/media-core": "^33.0.2",
+    "@atlaskit/media-core": "^33.0.3",
     "react": "^16.8.0",
     "react-dom": "^16.8.0",
     "react-intl-next": "npm:react-intl@^5.18.1"
@@ -51,13 +58,13 @@
     "@atlaskit/analytics-namespaced-context": "^6.5.0",
     "@atlaskit/button": "^16.3.0",
     "@atlaskit/docs": "*",
-    "@atlaskit/dropdown-menu": "^11.3.0",
+    "@atlaskit/dropdown-menu": "^11.5.0",
     "@atlaskit/media-card": "^74.1.0",
     "@atlaskit/media-core": "^33.0.0",
     "@atlaskit/media-test-helpers": "^30.0.0",
     "@atlaskit/spinner": "^15.0.0",
     "@atlaskit/ssr": "*",
-    "@atlaskit/toggle": "^12.4.0",
+    "@atlaskit/toggle": "^12.5.0",
     "@atlassian/atlassian-frontend-prettier-config-1.0.1": "npm:@atlassian/atlassian-frontend-prettier-config@1.0.1",
     "@atlassian/ufo": "^0.1.12",
     "@emotion/react": "^11.7.1",
@@ -69,7 +76,7 @@
     "react": "^16.8.0",
     "react-dom": "^16.8.0",
     "react-intl-next": "npm:react-intl@^5.18.1",
-    "typescript": "4.3.5",
+    "typescript": "4.5.5",
     "wait-for-expect": "^1.2.0"
   },
   "prettier": "@atlassian/atlassian-frontend-prettier-config-1.0.1"

package/types/package.json

@@ -3,5 +3,12 @@
   "main": "../dist/cjs/types.js",
   "module": "../dist/esm/types.js",
   "module:es2019": "../dist/es2019/types.js",
-  "types": "../dist/types/types.d.ts"
+  "types": "../dist/types/types.d.ts",
+  "typesVersions": {
+    ">=4.0 <4.5": {
+      "*": [
+        "../dist/types-ts4.0/types.d.ts"
+      ]
+    }
+  }
 }