@atlaskit/media-client 23.2.0 → 24.0.0

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

@@ -13,7 +13,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';
@@ -32,11 +32,34 @@ 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 var FileFetcherImpl = /*#__PURE__*/function () {
-  function FileFetcherImpl(mediaStore) {
+  function FileFetcherImpl(mediaApi) {
     var _this = this;
+    var store = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : mediaStore;
     _classCallCheck(this, FileFetcherImpl);
+    _defineProperty(this, "getErrorFileState", function (error, id, occurrenceKey) {
+      return typeof error === 'string' ? {
+        status: 'error',
+        id: id,
+        reason: error,
+        occurrenceKey: occurrenceKey,
+        message: error
+      } : {
+        status: 'error',
+        id: id,
+        reason: error === null || error === void 0 ? void 0 : error.reason,
+        details: error === null || error === void 0 ? void 0 : error.attributes,
+        occurrenceKey: occurrenceKey,
+        message: error === null || error === void 0 ? void 0 : error.message
+      };
+    });
+    _defineProperty(this, "setFileState", function (id, fileState) {
+      _this.store.setState(function (state) {
+        state.files[id] = fileState;
+      });
+    });
     // TODO: ----- ADD TICKET TO PASS TRACE ID to this.dataloader.load
     _defineProperty(this, "createDownloadFileStream", function (id, collectionName, occurrenceKey) {
       var subject = createMediaSubject();
@@ -131,8 +154,9 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
         preview: preview
       };
     });
-    this.mediaStore = mediaStore;
-    this.dataloader = createFileDataloader(mediaStore);
+    this.mediaApi = mediaApi;
+    this.store = store;
+    this.dataloader = createFileDataloader(mediaApi);
   }
   _createClass(FileFetcherImpl, [{
     key: "getFileState",
@@ -143,14 +167,34 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
         occurrenceKey = options.occurrenceKey;
       if (!isValidId(id)) {
         var subject = createMediaSubject();
-        subject.error(new FileFetcherError('invalidFileId', id, {
+        var err = new FileFetcherError('invalidFileId', id, {
           collectionName: collectionName,
           occurrenceKey: occurrenceKey
-        }));
+        });
+        var errorFileState = {
+          status: 'error',
+          id: id,
+          reason: err === null || err === void 0 ? void 0 : err.reason,
+          message: err === null || err === void 0 ? void 0 : err.message,
+          occurrenceKey: 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, function () {
-        return _this2.createDownloadFileStream(id, collectionName);
+        var subject = _this2.createDownloadFileStream(id, collectionName);
+        subject.subscribe({
+          next: function next(fileState) {
+            _this2.setFileState(id, fileState);
+          },
+          error: function error(err) {
+            var errorFileState = _this2.getErrorFileState(err, id, occurrenceKey);
+            _this2.setFileState(id, errorFileState);
+          }
+        });
+        return subject;
       }));
     }
   }, {
@@ -161,17 +205,17 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
   }, {
     key: "getArtifactURL",
     value: function getArtifactURL(artifacts, artifactName, collectionName) {
-      return this.mediaStore.getArtifactURL(artifacts, artifactName, collectionName);
+      return this.mediaApi.getArtifactURL(artifacts, artifactName, collectionName);
     }
   }, {
     key: "getFileBinaryURL",
     value: function getFileBinaryURL(id, collectionName) {
-      return this.mediaStore.getFileBinaryURL(id, collectionName);
+      return this.mediaApi.getFileBinaryURL(id, collectionName);
     }
   }, {
     key: "touchFiles",
     value: function touchFiles(descriptors, collection, traceContext) {
-      return this.mediaStore.touchFiles({
+      return this.mediaApi.touchFiles({
         descriptors: descriptors
       }, {
         collection: collection
@@ -257,6 +301,7 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
               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 _context4.abrupt("return", new Promise( /*#__PURE__*/function () {
                 var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(resolve, reject) {
                   var blob, type, size, file, mediaType, dimensions;
@@ -312,7 +357,7 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
                   return _ref4.apply(this, arguments);
                 };
               }()));
-            case 10:
+            case 11:
             case "end":
               return _context4.stop();
           }
@@ -335,22 +380,37 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
       var subject = createMediaSubject();
       getFileStreamsCache().set(id, subject);
       var onProgress = function onProgress(progress) {
-        subject.next(_objectSpread(_objectSpread({
+        var fileState = _objectSpread(_objectSpread({
           status: 'uploading'
         }, stateBase), {}, {
           progress: progress
-        }));
+        });
+        subject.next(fileState);
+        _this4.setFileState(id, fileState);
       };
       var processingSubscription = new Subscription();
       var onUploadFinish = function onUploadFinish(error) {
         if (error) {
+          var errorFileState = _this4.getErrorFileState(error, id, occurrenceKey);
+          _this4.setFileState(id, errorFileState);
           return subject.error(error);
         }
         processingSubscription = _this4.createDownloadFileStream(id, collection, occurrenceKey).pipe(map(function (remoteFileState) {
           return _objectSpread(_objectSpread(_objectSpread({}, stateBase), remoteFileState), overrideMediaTypeIfUnknown(remoteFileState, stateBase.mediaType));
-        })).subscribe(subject);
+        })).subscribe({
+          next: function next(fileState) {
+            subject.next(fileState);
+            _this4.setFileState(id, fileState);
+          },
+          error: function error(err) {
+            var errorFileState = _this4.getErrorFileState(err, id, occurrenceKey);
+            subject.error(err);
+            _this4.setFileState(id, errorFileState);
+          },
+          complete: subject.complete
+        });
       };
-      var _uploadFile = uploadFile(file, this.mediaStore, upfrontId, {
+      var _uploadFile = uploadFile(file, this.mediaApi, upfrontId, {
           onUploadFinish: onUploadFinish,
           onProgress: onProgress
         }, traceContext),
@@ -367,8 +427,6 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
       setTimeout(onProgress, 0, 0);
       return fromObservable(subject);
     }
-
-    // TODO: ----- ADD TICKET
   }, {
     key: "downloadBinary",
     value: function () {
@@ -383,7 +441,7 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
               name = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : 'download';
               collectionName = _args5.length > 2 ? _args5[2] : undefined;
               _context5.next = 4;
-              return this.mediaStore.getFileBinaryURL(id, collectionName);
+              return this.mediaApi.getFileBinaryURL(id, collectionName);
             case 4:
               url = _context5.sent;
               downloadUrl(url, {
@@ -409,6 +467,7 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
     key: "copyFile",
     value: function () {
       var _copyFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(source, destination) {
+        var _this5 = this;
         var options,
           traceContext,
           authProvider,
@@ -436,7 +495,12 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
           fileCache,
           subject,
           previewOverride,
+          fileState,
+          _fileState,
           _fileCache,
+          replaceFileState,
+          key,
+          errorFileState,
           _args6 = arguments;
         return _regeneratorRuntime.wrap(function _callee6$(_context6) {
           while (1) switch (_context6.prev = _context6.next) {
@@ -446,7 +510,7 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
               authProvider = source.authProvider, sourceCollection = source.collection, id = source.id;
               destinationAuthProvider = destination.authProvider, destinationCollectionName = destination.collection, replaceFileId = destination.replaceFileId, occurrenceKey = destination.occurrenceKey;
               preview = options.preview, mimeType = options.mimeType;
-              mediaStore = destination.mediaStore || new MediaStore({
+              mediaStore = destination.mediaStore || new MediaApi({
                 authProvider: destinationAuthProvider
               });
               _context6.t0 = authToOwner;
@@ -505,53 +569,65 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
               _context6.t2 = _context6.sent;
             case 31:
               if (!_context6.t2) {
-                _context6.next = 36;
+                _context6.next = 38;
                 break;
               }
-              subject.next(_objectSpread(_objectSpread(_objectSpread({}, copiedFileState), overrideMediaTypeIfUnknown(copiedFileState, mediaType)), previewOverride));
+              fileState = _objectSpread(_objectSpread(_objectSpread({}, copiedFileState), overrideMediaTypeIfUnknown(copiedFileState, mediaType)), previewOverride);
+              subject.next(fileState);
+              this.setFileState(copiedId, fileState);
               processingSubscription = this.createDownloadFileStream(copiedId, destinationCollectionName, occurrenceKey).subscribe({
                 next: function next(remoteFileState) {
-                  return subject.next(_objectSpread(_objectSpread(_objectSpread({}, remoteFileState), overrideMediaTypeIfUnknown(remoteFileState, mediaType)), !isErrorFileState(remoteFileState) && previewOverride));
+                  var fileState = _objectSpread(_objectSpread(_objectSpread({}, remoteFileState), overrideMediaTypeIfUnknown(remoteFileState, mediaType)), !isErrorFileState(remoteFileState) && previewOverride);
+                  _this5.setFileState(copiedId, fileState);
+                  return subject.next(fileState);
                 },
                 error: function error(err) {
+                  var errorFileState = _this5.getErrorFileState(err, id, occurrenceKey);
+                  _this5.setFileState(copiedId, errorFileState);
                   return subject.error(err);
                 },
                 complete: function complete() {
                   return subject.complete();
                 }
               });
-              _context6.next = 37;
+              _context6.next = 39;
               break;
-            case 36:
+            case 38:
               if (!isProcessingFileState(copiedFileState)) {
-                subject.next(_objectSpread(_objectSpread({}, copiedFileState), !isErrorFileState(copiedFileState) && previewOverride));
+                _fileState = _objectSpread(_objectSpread({}, copiedFileState), !isErrorFileState(copiedFileState) && previewOverride);
+                subject.next(_fileState);
+                this.setFileState(copiedId, _fileState);
               }
-            case 37:
+            case 39:
               if (!cache.has(copiedId)) {
                 getFileStreamsCache().set(copiedId, subject);
               }
               return _context6.abrupt("return", copiedFile);
-            case 41:
-              _context6.prev = 41;
+            case 43:
+              _context6.prev = 43;
               _context6.t3 = _context6["catch"](14);
               if (processingSubscription) {
                 processingSubscription.unsubscribe();
               }
               if (replaceFileId) {
                 _fileCache = cache.get(replaceFileId);
+                replaceFileState = this.store.getState().files[replaceFileId];
                 if (_fileCache) {
                   _fileCache.error(_context6.t3);
                 } else {
                   // Create a new subject with the error state for new subscriptions
                   cache.set(id, createMediaSubject(_context6.t3));
                 }
+                key = replaceFileState ? replaceFileId : id;
+                errorFileState = this.getErrorFileState(_context6.t3, id, occurrenceKey);
+                this.setFileState(key, errorFileState);
               }
               throw _context6.t3;
-            case 46:
+            case 48:
             case "end":
               return _context6.stop();
           }
-        }, _callee6, this, [[14, 41]]);
+        }, _callee6, this, [[14, 43]]);
       }));
       function copyFile(_x9, _x10) {
         return _copyFile.apply(this, arguments);

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

@@ -3,28 +3,40 @@ import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 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 var MediaClient = /*#__PURE__*/function () {
   // mobile upload is lazily loaded
 
   // Deprecated value introduced for backward compatibility with Context
 
-  function MediaClient(mediaClientConfig, featureFlags) {
+  function MediaClient(mediaClientConfig) {
+    var store = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : mediaStore;
+    var mediaApi = arguments.length > 2 ? arguments[2] : undefined;
     _classCallCheck(this, MediaClient);
     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
+   */
   _createClass(MediaClient, [{
+    key: "__DO_NOT_USE__getMediaStore",
+    value: function __DO_NOT_USE__getMediaStore() {
+      return this.store;
+    }
+  }, {
     key: "getImage",
     value: function getImage(id, params, controller, fetchMaxRes, traceContext) {
       return this.mediaStore.getImage(id, params, controller, fetchMaxRes, traceContext);
@@ -79,7 +91,7 @@ export var MediaClient = /*#__PURE__*/function () {
               return import( /* webpackChunkName: "@atlaskit-internal_media-client-mobile-upload" */'./mobile-upload');
             case 4:
               module = _context2.sent;
-              this.mobileUpload = new module.MobileUploadImpl(this.mediaStore);
+              this.mobileUpload = new module.MobileUploadImpl(this.mediaStore, this.store);
               return _context2.abrupt("return", this.mobileUpload);
             case 7:
             case "end":

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

@@ -31,7 +31,7 @@ var jsonHeaders = {
   'Content-Type': 'application/json'
 };
 export var MediaStore = /*#__PURE__*/function () {
-  function MediaStore(config, featureFlags) {
+  function MediaStore(config) {
     var _this = this;
     _classCallCheck(this, MediaStore);
     _defineProperty(this, "resolveAuth", function (authContext) {
@@ -41,7 +41,6 @@ export var MediaStore = /*#__PURE__*/function () {
       return resolveInitialAuth(_this.config.initialAuth);
     });
     this.config = config;
-    this.featureFlags = featureFlags;
   }
   _createClass(MediaStore, [{
     key: "removeCollectionFile",

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

@@ -1,18 +1,45 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+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 var MobileUploadImpl = /*#__PURE__*/function () {
-  function MobileUploadImpl(mediaStore) {
+  function MobileUploadImpl(mediaApi) {
+    var _this = this;
+    var store = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : mediaStore;
     _classCallCheck(this, MobileUploadImpl);
-    this.dataloader = createFileDataloader(mediaStore);
+    _defineProperty(this, "getErrorFileState", function (error, id, occurrenceKey) {
+      return typeof error === 'string' ? {
+        status: 'error',
+        id: id,
+        reason: error,
+        occurrenceKey: occurrenceKey,
+        message: error
+      } : {
+        status: 'error',
+        id: id,
+        reason: error === null || error === void 0 ? void 0 : error.reason,
+        details: error === null || error === void 0 ? void 0 : error.attributes,
+        occurrenceKey: occurrenceKey,
+        message: error === null || error === void 0 ? void 0 : error.message
+      };
+    });
+    _defineProperty(this, "setFileState", function (id, fileState) {
+      _this.store.setState(function (state) {
+        state.files[id] = fileState;
+      });
+    });
+    this.store = store;
+    this.dataloader = createFileDataloader(mediaApi);
     this.servicesCache = createServicesCache();
   }
   _createClass(MobileUploadImpl, [{
     key: "notifyUploadStart",
     value: function notifyUploadStart(event) {
+      var _this2 = this;
       var fileId = event.fileId,
         collectionName = event.collectionName,
         occurrenceKey = event.occurrenceKey,
@@ -36,6 +63,15 @@ export var MobileUploadImpl = /*#__PURE__*/function () {
       };
       var service = createMobileUploadService(createMobileUploadStateMachine(this.dataloader, initialState, collectionName));
       var subject = createMobileFileStateSubject(service);
+      subject.subscribe({
+        next: function next(fileState) {
+          _this2.setFileState(fileId, fileState);
+        },
+        error: function error(err) {
+          var errorFileState = _this2.getErrorFileState(err, fileId, occurrenceKey);
+          _this2.setFileState(fileId, errorFileState);
+        }
+      });
       this.servicesCache.set(fileId, service);
       getFileStreamsCache().set(fileId, subject);
     }

package/dist/esm/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/esm/utils/with-media-client-hoc.js

@@ -10,24 +10,16 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 import React from 'react';
 import { MediaClient } from '../client/media-client';
-var NO_FLAGS = 'NO_FLAGS';
 var mediaClientsMap = new Map();
-export var getMediaClient = function getMediaClient(mediaClientConfig, featureFlags) {
-  var _mediaClientsMap$get;
-  var flagsMapKey = featureFlags || NO_FLAGS;
-  var mediaClient = (_mediaClientsMap$get = mediaClientsMap.get(mediaClientConfig)) === null || _mediaClientsMap$get === void 0 ? void 0 : _mediaClientsMap$get.get(flagsMapKey);
+export var getMediaClient = function getMediaClient(mediaClientConfig) {
+  var mediaClient = mediaClientsMap.get(mediaClientConfig);
   if (!mediaClient) {
-    var 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;
 };
-var createEmptyMediaClient = function createEmptyMediaClient(featureFlags) {
+var createEmptyMediaClient = function createEmptyMediaClient() {
   var emptyConfig = {
     authProvider: function authProvider() {
       return Promise.resolve({
@@ -37,9 +29,9 @@ var createEmptyMediaClient = function createEmptyMediaClient(featureFlags) {
       });
     }
   };
-  return new MediaClient(emptyConfig, featureFlags);
+  return new MediaClient(emptyConfig);
 };
-export var withMediaClient = function withMediaClient(Component, featureFlags) {
+export var withMediaClient = function withMediaClient(Component) {
   return /*#__PURE__*/function (_React$Component) {
     _inherits(_class, _React$Component);
     var _super = _createSuper(_class);
@@ -54,7 +46,7 @@ export var withMediaClient = function withMediaClient(Component, featureFlags) {
         var _this$props = this.props,
           mediaClientConfig = _this$props.mediaClientConfig,
           otherProps = _objectWithoutProperties(_this$props, _excluded);
-        var mediaClient = !mediaClientConfig ? createEmptyMediaClient(featureFlags) : getMediaClient(mediaClientConfig, featureFlags);
+        var mediaClient = !mediaClientConfig ? createEmptyMediaClient() : getMediaClient(mediaClientConfig);
         return /*#__PURE__*/React.createElement(Component, _extends({}, otherProps, {
           mediaClient: mediaClient
         }));

package/dist/types/client/events.d.ts

@@ -1,4 +1,4 @@
-import { FileState } from '../models/file-state';
+import { FileState } from '@atlaskit/media-state';
 export type EventPayloadMap<P> = {
     readonly [event: string]: P;
 };

package/dist/types/client/file-fetcher/index.d.ts

@@ -1,14 +1,15 @@
 import 'setimmediate';
 import { AuthProvider } from '@atlaskit/media-core';
-import { MediaStore, MediaStoreCopyFileWithTokenParams, TouchedFiles, TouchFileDescriptor } from '../media-store';
-import { FilePreview, FileState, GetFileOptions } from '../../models/file-state';
+import { MediaFileArtifacts } from '@atlaskit/media-state';
+import { MediaStore as MediaApi, MediaStoreCopyFileWithTokenParams, TouchedFiles, TouchFileDescriptor } from '../media-store';
+import { GetFileOptions } from '../../models/file-state';
 import { MediaFile } from '../../models/media';
 import { UploadableFile, UploadableFileUpfrontIds } from '../../uploader';
-import { MediaFileArtifacts } from '../../models/artifacts';
 import { UploadController } from '../../upload-controller';
 import { MediaSubscribable } from '../../utils/mediaSubscribable';
 import { Dimensions } from '../../utils/getDimensionsFromBlob';
 import { MediaTraceContext } from '@atlaskit/media-common';
+import { FilePreview, FileState, MediaStore } from '@atlaskit/media-state';
 export type { FileFetcherErrorAttributes, FileFetcherErrorReason, } from './error';
 export { isFileFetcherError, FileFetcherError } from './error';
 export interface CopySourceFile {
@@ -18,7 +19,7 @@ export interface CopySourceFile {
 }
 export interface CopyDestination extends MediaStoreCopyFileWithTokenParams {
     authProvider: AuthProvider;
-    mediaStore?: MediaStore;
+    mediaStore?: MediaApi;
 }
 export interface CopyFileOptions {
     preview?: FilePreview | Promise<FilePreview>;
@@ -40,9 +41,12 @@ export interface FileFetcher {
     getFileBinaryURL(id: string, collectionName?: string): Promise<string>;
 }
 export declare class FileFetcherImpl implements FileFetcher {
-    private readonly mediaStore;
+    private readonly mediaApi;
+    private readonly store;
     private readonly dataloader;
-    constructor(mediaStore: MediaStore);
+    constructor(mediaApi: MediaApi, store?: MediaStore);
+    private getErrorFileState;
+    private setFileState;
     getFileState(id: string, options?: GetFileOptions): MediaSubscribable;
     getCurrentState(id: string, options?: GetFileOptions): Promise<FileState>;
     getArtifactURL(artifacts: MediaFileArtifacts, artifactName: keyof MediaFileArtifacts, collectionName?: string): Promise<string>;

package/dist/types/client/media-client.d.ts

@@ -1,20 +1,25 @@
 import { MediaClientConfig } from '@atlaskit/media-core';
-import { MediaFeatureFlags, MediaTraceContext } from '@atlaskit/media-common';
-import { MediaStore, MediaStoreGetFileImageParams, ImageMetadata } from './media-store';
+import { MediaTraceContext } from '@atlaskit/media-common';
+import { MediaStore as MediaApi, MediaStoreGetFileImageParams, ImageMetadata } from './media-store';
 import { FileFetcher } from './file-fetcher';
 import { UploadEventPayloadMap, EventPayloadListener } from './events';
 import { StargateClient } from './stargate-client';
 import { MobileUpload } from '../models/mobile-upload';
+import { MediaStore } from '@atlaskit/media-state';
 export declare class MediaClient {
     readonly mediaClientConfig: MediaClientConfig;
-    readonly featureFlags?: MediaFeatureFlags | undefined;
-    readonly mediaStore: MediaStore;
+    private readonly store;
+    readonly mediaStore: MediaApi;
     readonly file: FileFetcher;
     readonly stargate: StargateClient;
     private readonly eventEmitter;
     private mobileUpload?;
     readonly config: MediaClientConfig;
-    constructor(mediaClientConfig: MediaClientConfig, featureFlags?: MediaFeatureFlags | undefined);
+    constructor(mediaClientConfig: MediaClientConfig, store?: MediaStore, mediaApi?: MediaApi);
+    /**
+     * @internal
+     */
+    __DO_NOT_USE__getMediaStore(): MediaStore;
     getImage(id: string, params?: MediaStoreGetFileImageParams, controller?: AbortController, fetchMaxRes?: boolean, traceContext?: MediaTraceContext): Promise<Blob>;
     getImageUrl(id: string, params?: MediaStoreGetFileImageParams): Promise<string>;
     getImageUrlSync(id: string, params?: MediaStoreGetFileImageParams): string;

package/dist/types/client/media-store/index.d.ts

@@ -1,14 +1,13 @@
 import { AsapBasedAuth, AuthContext, ClientAltBasedAuth, MediaApiConfig, Auth } from '@atlaskit/media-core';
-import { MediaFeatureFlags, MediaTraceContext } from '@atlaskit/media-common';
-import { MediaFileArtifacts } from '../../models/artifacts';
+import { MediaTraceContext } from '@atlaskit/media-common';
+import { MediaFileArtifacts } from '@atlaskit/media-state';
 import { MediaChunksProbe, MediaItemDetails, MediaFile, MediaUpload } from '../../models/media';
 import { ClientOptions, RequestHeaders, RequestMethod, RequestParams, RequestMetadata } from '../../utils/request/types';
 export type { MediaStoreErrorReason, MediaStoreErrorAttributes } from './error';
 export { MediaStoreError, isMediaStoreError } from './error';
 export declare class MediaStore {
     private readonly config;
-    readonly featureFlags?: MediaFeatureFlags | undefined;
-    constructor(config: MediaApiConfig, featureFlags?: MediaFeatureFlags | undefined);
+    constructor(config: MediaApiConfig);
     removeCollectionFile(id: string, collectionName: string, occurrenceKey?: string, traceContext?: MediaTraceContext): Promise<void>;
     createUpload(createUpTo?: number, collectionName?: string, traceContext?: MediaTraceContext): Promise<MediaStoreResponse<MediaUpload[]>>;
     uploadChunk(etag: string, blob: Blob, uploadId: string, partNumber: number, collectionName?: string, traceContext?: MediaTraceContext): Promise<void>;

package/dist/types/client/mobile-upload.d.ts

@@ -1,11 +1,15 @@
+import { MediaStore } from '@atlaskit/media-state';
 import { MobileUpload, MobileUploadStartEvent, MobileUploadProgressEvent, MobileUploadEndEvent, MobileUploadErrorEvent } from '../models/mobile-upload';
-import { MediaStore } from './media-store';
+import { MediaStore as MediaApi } from './media-store';
 export declare class MobileUploadImpl implements MobileUpload {
+    private readonly store;
     private readonly dataloader;
     private readonly servicesCache;
-    constructor(mediaStore: MediaStore);
+    constructor(mediaApi: MediaApi, store?: MediaStore);
     notifyUploadStart(event: MobileUploadStartEvent): void;
     notifyUploadProgress(event: MobileUploadProgressEvent): void;
     notifyUploadEnd(event: MobileUploadEndEvent): void;
     notifyUploadError(event: MobileUploadErrorEvent): void;
+    private getErrorFileState;
+    private setFileState;
 }

package/dist/types/file-streams-cache.d.ts

@@ -1,6 +1,6 @@
 import { LRUMap } from 'lru_map';
 import { ReplaySubject } from 'rxjs/ReplaySubject';
-import { FileState } from './models/file-state';
+import { FileState } from '@atlaskit/media-state';
 export declare class StreamsCache<T> {
     private readonly streams;
     constructor(streams: LRUMap<string, ReplaySubject<T>>);