@atlaskit/media-client 23.2.0 → 24.0.0

package/dist/es2019/client/file-fetcher/index.js

@@ -7,7 +7,7 @@ import uuid from 'uuid/v4';
 import 'setimmediate';
 import { authToOwner } from '@atlaskit/media-core';
 import { downloadUrl } from '@atlaskit/media-common/downloadUrl';
-import { MediaStore } from '../media-store';
+import { MediaStore as MediaApi } from '../media-store';
 import { isErrorFileState, isFinalFileState, isProcessingFileState, mapMediaFileToFileState, mapMediaItemToFileState } from '../../models/file-state';
 import { FileFetcherError } from './error';
 import { uploadFile } from '../../uploader';
@@ -26,9 +26,29 @@ import { isMimeTypeSupportedByBrowser, getMediaTypeFromMimeType } from '@atlaski
 import { shouldFetchRemoteFileStates } from '../../utils/shouldFetchRemoteFileStates';
 import { PollingFunction } from '../../utils/polling';
 import { isEmptyFile } from '../../utils/detectEmptyFile';
+import { mediaStore } from '@atlaskit/media-state';
 export { isFileFetcherError, FileFetcherError } from './error';
 export class FileFetcherImpl {
-  constructor(mediaStore) {
+  constructor(mediaApi, store = mediaStore) {
+    _defineProperty(this, "getErrorFileState", (error, id, occurrenceKey) => typeof error === 'string' ? {
+      status: 'error',
+      id,
+      reason: error,
+      occurrenceKey,
+      message: error
+    } : {
+      status: 'error',
+      id,
+      reason: error === null || error === void 0 ? void 0 : error.reason,
+      details: error === null || error === void 0 ? void 0 : error.attributes,
+      occurrenceKey,
+      message: error === null || error === void 0 ? void 0 : error.message
+    });
+    _defineProperty(this, "setFileState", (id, fileState) => {
+      this.store.setState(state => {
+        state.files[id] = fileState;
+      });
+    });
     // TODO: ----- ADD TICKET TO PASS TRACE ID to this.dataloader.load
     _defineProperty(this, "createDownloadFileStream", (id, collectionName, occurrenceKey) => {
       const subject = createMediaSubject();
@@ -105,8 +125,9 @@ export class FileFetcherImpl {
         preview
       };
     });
-    this.mediaStore = mediaStore;
-    this.dataloader = createFileDataloader(mediaStore);
+    this.mediaApi = mediaApi;
+    this.store = store;
+    this.dataloader = createFileDataloader(mediaApi);
   }
   getFileState(id, options = {}) {
     const {
@@ -115,25 +136,47 @@ export class FileFetcherImpl {
     } = options;
     if (!isValidId(id)) {
       const subject = createMediaSubject();
-      subject.error(new FileFetcherError('invalidFileId', id, {
+      const err = new FileFetcherError('invalidFileId', id, {
         collectionName,
         occurrenceKey
-      }));
+      });
+      const errorFileState = {
+        status: 'error',
+        id,
+        reason: err === null || err === void 0 ? void 0 : err.reason,
+        message: err === null || err === void 0 ? void 0 : err.message,
+        occurrenceKey,
+        details: err === null || err === void 0 ? void 0 : err.attributes
+      };
+      subject.error(err);
+      this.setFileState(id, errorFileState);
       return fromObservable(subject);
     }
-    return fromObservable(getFileStreamsCache().getOrInsert(id, () => this.createDownloadFileStream(id, collectionName)));
+    return fromObservable(getFileStreamsCache().getOrInsert(id, () => {
+      const subject = this.createDownloadFileStream(id, collectionName);
+      subject.subscribe({
+        next: fileState => {
+          this.setFileState(id, fileState);
+        },
+        error: err => {
+          const errorFileState = this.getErrorFileState(err, id, occurrenceKey);
+          this.setFileState(id, errorFileState);
+        }
+      });
+      return subject;
+    }));
   }
   getCurrentState(id, options) {
     return toPromise(this.getFileState(id, options));
   }
   getArtifactURL(artifacts, artifactName, collectionName) {
-    return this.mediaStore.getArtifactURL(artifacts, artifactName, collectionName);
+    return this.mediaApi.getArtifactURL(artifacts, artifactName, collectionName);
   }
   getFileBinaryURL(id, collectionName) {
-    return this.mediaStore.getFileBinaryURL(id, collectionName);
+    return this.mediaApi.getFileBinaryURL(id, collectionName);
   }
   touchFiles(descriptors, collection, traceContext) {
-    return this.mediaStore.touchFiles({
+    return this.mediaApi.touchFiles({
       descriptors
     }, {
       collection
@@ -189,6 +232,7 @@ export class FileFetcherImpl {
     subject.next(fileState);
     // we save it into the cache as soon as possible, in case someone subscribes
     getFileStreamsCache().set(id, subject);
+    this.setFileState(id, fileState);
     return new Promise(async (resolve, reject) => {
       const blob = await deferredBlob;
       if (!blob) {
@@ -240,15 +284,19 @@ export class FileFetcherImpl {
     const subject = createMediaSubject();
     getFileStreamsCache().set(id, subject);
     const onProgress = progress => {
-      subject.next({
+      const fileState = {
         status: 'uploading',
         ...stateBase,
         progress
-      });
+      };
+      subject.next(fileState);
+      this.setFileState(id, fileState);
     };
     let processingSubscription = new Subscription();
     const onUploadFinish = error => {
       if (error) {
+        const errorFileState = this.getErrorFileState(error, id, occurrenceKey);
+        this.setFileState(id, errorFileState);
         return subject.error(error);
       }
       processingSubscription = this.createDownloadFileStream(id, collection, occurrenceKey).pipe(map(remoteFileState => ({
@@ -256,11 +304,22 @@ export class FileFetcherImpl {
         ...stateBase,
         ...remoteFileState,
         ...overrideMediaTypeIfUnknown(remoteFileState, stateBase.mediaType)
-      }))).subscribe(subject);
+      }))).subscribe({
+        next: fileState => {
+          subject.next(fileState);
+          this.setFileState(id, fileState);
+        },
+        error: err => {
+          const errorFileState = this.getErrorFileState(err, id, occurrenceKey);
+          subject.error(err);
+          this.setFileState(id, errorFileState);
+        },
+        complete: subject.complete
+      });
     };
     const {
       cancel
-    } = uploadFile(file, this.mediaStore, upfrontId, {
+    } = uploadFile(file, this.mediaApi, upfrontId, {
       onUploadFinish,
       onProgress
     }, traceContext);
@@ -276,10 +335,8 @@ export class FileFetcherImpl {
     setTimeout(onProgress, 0, 0);
     return fromObservable(subject);
   }
-
-  // TODO: ----- ADD TICKET
   async downloadBinary(id, name = 'download', collectionName) {
-    const url = await this.mediaStore.getFileBinaryURL(id, collectionName);
+    const url = await this.mediaApi.getFileBinaryURL(id, collectionName);
     downloadUrl(url, {
       name
     });
@@ -305,7 +362,7 @@ export class FileFetcherImpl {
       preview,
       mimeType
     } = options;
-    const mediaStore = destination.mediaStore || new MediaStore({
+    const mediaStore = destination.mediaStore || new MediaApi({
       authProvider: destinationAuthProvider
     });
     const owner = authToOwner(await authProvider({
@@ -359,25 +416,37 @@ export class FileFetcherImpl {
       // mimeType should always be returned by "copyFileWithToken"
       // but in case it's not, we don't want to penalize "copyFile"
       copiedMimeType && (await shouldFetchRemoteFileStates(mediaType, copiedMimeType, preview))) {
-        subject.next({
+        const fileState = {
           ...copiedFileState,
           ...overrideMediaTypeIfUnknown(copiedFileState, mediaType),
           ...previewOverride
-        });
+        };
+        subject.next(fileState);
+        this.setFileState(copiedId, fileState);
         processingSubscription = this.createDownloadFileStream(copiedId, destinationCollectionName, occurrenceKey).subscribe({
-          next: remoteFileState => subject.next({
-            ...remoteFileState,
-            ...overrideMediaTypeIfUnknown(remoteFileState, mediaType),
-            ...(!isErrorFileState(remoteFileState) && previewOverride)
-          }),
-          error: err => subject.error(err),
+          next: remoteFileState => {
+            const fileState = {
+              ...remoteFileState,
+              ...overrideMediaTypeIfUnknown(remoteFileState, mediaType),
+              ...(!isErrorFileState(remoteFileState) && previewOverride)
+            };
+            this.setFileState(copiedId, fileState);
+            return subject.next(fileState);
+          },
+          error: err => {
+            const errorFileState = this.getErrorFileState(err, id, occurrenceKey);
+            this.setFileState(copiedId, errorFileState);
+            return subject.error(err);
+          },
           complete: () => subject.complete()
         });
       } else if (!isProcessingFileState(copiedFileState)) {
-        subject.next({
+        const fileState = {
           ...copiedFileState,
           ...(!isErrorFileState(copiedFileState) && previewOverride)
-        });
+        };
+        subject.next(fileState);
+        this.setFileState(copiedId, fileState);
       }
       if (!cache.has(copiedId)) {
         getFileStreamsCache().set(copiedId, subject);
@@ -389,12 +458,16 @@ export class FileFetcherImpl {
       }
       if (replaceFileId) {
         const fileCache = cache.get(replaceFileId);
+        const replaceFileState = this.store.getState().files[replaceFileId];
         if (fileCache) {
           fileCache.error(error);
         } else {
           // Create a new subject with the error state for new subscriptions
           cache.set(id, createMediaSubject(error));
         }
+        const key = replaceFileState ? replaceFileId : id;
+        const errorFileState = this.getErrorFileState(error, id, occurrenceKey);
+        this.setFileState(key, errorFileState);
       }
       throw error;
     }

package/dist/es2019/client/media-client.js

@@ -1,24 +1,32 @@
 import { EventEmitter2 } from 'eventemitter2';
-import { MediaStore } from './media-store';
+import { MediaStore as MediaApi } from './media-store';
 import { FileFetcherImpl } from './file-fetcher';
 import { StargateClient } from './stargate-client';
+import { mediaStore } from '@atlaskit/media-state';
 export class MediaClient {
   // mobile upload is lazily loaded
 
   // Deprecated value introduced for backward compatibility with Context
 
-  constructor(mediaClientConfig, featureFlags) {
+  constructor(mediaClientConfig, store = mediaStore, mediaApi) {
     this.mediaClientConfig = mediaClientConfig;
-    this.featureFlags = featureFlags;
-    this.mediaStore = new MediaStore({
+    this.store = store;
+    this.mediaStore = mediaApi !== null && mediaApi !== void 0 ? mediaApi : new MediaApi({
       authProvider: mediaClientConfig.authProvider,
       initialAuth: mediaClientConfig.initialAuth
-    }, featureFlags);
+    });
     this.config = mediaClientConfig;
-    this.file = new FileFetcherImpl(this.mediaStore);
+    this.file = new FileFetcherImpl(this.mediaStore, this.store);
     this.eventEmitter = new EventEmitter2();
     this.stargate = new StargateClient(mediaClientConfig.stargateBaseUrl);
   }
+
+  /**
+   * @internal
+   */
+  __DO_NOT_USE__getMediaStore() {
+    return this.store;
+  }
   getImage(id, params, controller, fetchMaxRes, traceContext) {
     return this.mediaStore.getImage(id, params, controller, fetchMaxRes, traceContext);
   }
@@ -36,7 +44,7 @@ export class MediaClient {
       return this.mobileUpload;
     }
     const module = await import( /* webpackChunkName: "@atlaskit-internal_media-client-mobile-upload" */'./mobile-upload');
-    this.mobileUpload = new module.MobileUploadImpl(this.mediaStore);
+    this.mobileUpload = new module.MobileUploadImpl(this.mediaStore, this.store);
     return this.mobileUpload;
   }
   async removeFileFromCollection(id, collectionName, occurrenceKey, traceContext) {

package/dist/es2019/client/media-store/index.js

@@ -28,11 +28,10 @@ const jsonHeaders = {
   'Content-Type': 'application/json'
 };
 export class MediaStore {
-  constructor(config, featureFlags) {
+  constructor(config) {
     _defineProperty(this, "resolveAuth", authContext => resolveAuth(this.config.authProvider, authContext));
     _defineProperty(this, "resolveInitialAuth", () => resolveInitialAuth(this.config.initialAuth));
     this.config = config;
-    this.featureFlags = featureFlags;
   }
   async removeCollectionFile(id, collectionName, occurrenceKey, traceContext) {
     const metadata = {

package/dist/es2019/client/mobile-upload.js

@@ -1,10 +1,32 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { getMediaTypeFromMimeType } from '@atlaskit/media-common';
+import { mediaStore } from '@atlaskit/media-state';
 import { getFileStreamsCache } from '../file-streams-cache';
 import { createFileDataloader } from '../utils/createFileDataLoader';
 import { createServicesCache, createMobileUploadStateMachine, createMobileUploadService, createMobileFileStateSubject } from '../utils/mobileUpload';
 export class MobileUploadImpl {
-  constructor(mediaStore) {
-    this.dataloader = createFileDataloader(mediaStore);
+  constructor(mediaApi, store = mediaStore) {
+    _defineProperty(this, "getErrorFileState", (error, id, occurrenceKey) => typeof error === 'string' ? {
+      status: 'error',
+      id,
+      reason: error,
+      occurrenceKey,
+      message: error
+    } : {
+      status: 'error',
+      id,
+      reason: error === null || error === void 0 ? void 0 : error.reason,
+      details: error === null || error === void 0 ? void 0 : error.attributes,
+      occurrenceKey,
+      message: error === null || error === void 0 ? void 0 : error.message
+    });
+    _defineProperty(this, "setFileState", (id, fileState) => {
+      this.store.setState(state => {
+        state.files[id] = fileState;
+      });
+    });
+    this.store = store;
+    this.dataloader = createFileDataloader(mediaApi);
     this.servicesCache = createServicesCache();
   }
   notifyUploadStart(event) {
@@ -33,6 +55,15 @@ export class MobileUploadImpl {
     };
     const service = createMobileUploadService(createMobileUploadStateMachine(this.dataloader, initialState, collectionName));
     const subject = createMobileFileStateSubject(service);
+    subject.subscribe({
+      next: fileState => {
+        this.setFileState(fileId, fileState);
+      },
+      error: err => {
+        const errorFileState = this.getErrorFileState(err, fileId, occurrenceKey);
+        this.setFileState(fileId, errorFileState);
+      }
+    });
     this.servicesCache.set(fileId, service);
     getFileStreamsCache().set(fileId, subject);
   }

package/dist/es2019/index.js

@@ -24,6 +24,7 @@ export { globalMediaEventEmitter } from './globalMediaEventEmitter';
 export { isMediaBlobUrl, getAttrsFromUrl, addFileAttrsToUrl, objectToQueryString } from './utils/url';
 export { createMediaSubscribable, fromObservable } from './utils/mediaSubscribable';
 export { RECENTS_COLLECTION, MAX_RESOLUTION } from './constants';
+export { getFileStreamsCache } from './file-streams-cache';
 
 // TODO MEX-659 Remove these exports when all the usages from media-client are replaced with media-common.
 

package/dist/es2019/utils/with-media-client-hoc.js

@@ -1,24 +1,16 @@
 import _extends from "@babel/runtime/helpers/extends";
 import React from 'react';
 import { MediaClient } from '../client/media-client';
-const NO_FLAGS = 'NO_FLAGS';
 const mediaClientsMap = new Map();
-export const getMediaClient = (mediaClientConfig, featureFlags) => {
-  var _mediaClientsMap$get;
-  const flagsMapKey = featureFlags || NO_FLAGS;
-  let mediaClient = (_mediaClientsMap$get = mediaClientsMap.get(mediaClientConfig)) === null || _mediaClientsMap$get === void 0 ? void 0 : _mediaClientsMap$get.get(flagsMapKey);
+export const getMediaClient = mediaClientConfig => {
+  let mediaClient = mediaClientsMap.get(mediaClientConfig);
   if (!mediaClient) {
-    let subMap = mediaClientsMap.get(mediaClientConfig);
-    if (!subMap) {
-      subMap = new Map();
-      mediaClientsMap.set(mediaClientConfig, subMap);
-    }
-    mediaClient = new MediaClient(mediaClientConfig, featureFlags);
-    subMap.set(flagsMapKey, mediaClient);
+    mediaClient = new MediaClient(mediaClientConfig);
+    mediaClientsMap.set(mediaClientConfig, mediaClient);
   }
   return mediaClient;
 };
-const createEmptyMediaClient = featureFlags => {
+const createEmptyMediaClient = () => {
   const emptyConfig = {
     authProvider: () => Promise.resolve({
       clientId: '',
@@ -26,9 +18,9 @@ const createEmptyMediaClient = featureFlags => {
       baseUrl: ''
     })
   };
-  return new MediaClient(emptyConfig, featureFlags);
+  return new MediaClient(emptyConfig);
 };
-export const withMediaClient = (Component, featureFlags) => {
+export const withMediaClient = Component => {
   return class extends React.Component {
     render() {
       // TODO MPT-315: clean up after we move mediaClientConfig into FileIdentifier
@@ -36,7 +28,7 @@ export const withMediaClient = (Component, featureFlags) => {
         mediaClientConfig,
         ...otherProps
       } = this.props;
-      const mediaClient = !mediaClientConfig ? createEmptyMediaClient(featureFlags) : getMediaClient(mediaClientConfig, featureFlags);
+      const mediaClient = !mediaClientConfig ? createEmptyMediaClient() : getMediaClient(mediaClientConfig);
       return /*#__PURE__*/React.createElement(Component, _extends({}, otherProps, {
         mediaClient: mediaClient
       }));