@atlaskit/media-client 25.0.3 → 26.0.0

package/dist/cjs/test-helpers/MockedMediaApi/index.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "copy", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.copy;
+  }
+});
+Object.defineProperty(exports, "createEmptyFileItem", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.createEmptyFileItem;
+  }
+});
+Object.defineProperty(exports, "createErrorFileState", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.createErrorFileState;
+  }
+});
+Object.defineProperty(exports, "createFileState", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.createFileState;
+  }
+});
+Object.defineProperty(exports, "createMockedMediaApi", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createMockedMediaApi;
+  }
+});
+Object.defineProperty(exports, "createProcessingFileItem", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.createProcessingFileItem;
+  }
+});
+Object.defineProperty(exports, "createUploadingFileState", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.createUploadingFileState;
+  }
+});
+Object.defineProperty(exports, "getIdentifier", {
+  enumerable: true,
+  get: function get() {
+    return _helpers.getIdentifier;
+  }
+});
+var _MockedMediaApi = require("./MockedMediaApi");
+var _helpers = require("./helpers");

package/dist/cjs/test-helpers/index.js

@@ -64,6 +64,42 @@ Object.defineProperty(exports, "collectionNames", {
     return _collectionNames.collectionNames;
   }
 });
+Object.defineProperty(exports, "copy", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.copy;
+  }
+});
+Object.defineProperty(exports, "createEmptyFileItem", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createEmptyFileItem;
+  }
+});
+Object.defineProperty(exports, "createErrorFileState", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createErrorFileState;
+  }
+});
+Object.defineProperty(exports, "createFileState", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createFileState;
+  }
+});
+Object.defineProperty(exports, "createMockedMediaApi", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createMockedMediaApi;
+  }
+});
+Object.defineProperty(exports, "createProcessingFileItem", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createProcessingFileItem;
+  }
+});
 Object.defineProperty(exports, "createStorybookMediaClient", {
   enumerable: true,
   get: function get() {
@@ -88,6 +124,12 @@ Object.defineProperty(exports, "createUploadMediaClientConfig", {
     return _mediaClientProvider.createUploadMediaClientConfig;
   }
 });
+Object.defineProperty(exports, "createUploadingFileState", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.createUploadingFileState;
+  }
+});
 Object.defineProperty(exports, "defaultBaseUrl", {
   enumerable: true,
   get: function get() {
@@ -202,6 +244,12 @@ Object.defineProperty(exports, "genericFileId", {
     return _exampleMediaItems.genericFileId;
   }
 });
+Object.defineProperty(exports, "getIdentifier", {
+  enumerable: true,
+  get: function get() {
+    return _MockedMediaApi.getIdentifier;
+  }
+});
 Object.defineProperty(exports, "gifFileId", {
   enumerable: true,
   get: function get() {
@@ -370,4 +418,5 @@ var _collectionNames = require("./collectionNames");
 var _exampleMediaItems = require("./exampleMediaItems");
 var _mediaPickerAuthProvider = require("./mediaPickerAuthProvider");
 var _fakeMediaClient = require("./fakeMediaClient");
+var _MockedMediaApi = require("./MockedMediaApi");
 var authProviderBaseURL = exports.authProviderBaseURL = 'https://media.dev.atl-paas.net';

package/dist/cjs/uploader/index.js

@@ -37,29 +37,26 @@ var hashingFunction = /*#__PURE__*/function () {
     return _ref.apply(this, arguments);
   };
 }();
-var createProbingFunction = function createProbingFunction(store, deferredUploadId, collectionName, traceContext) {
+var createUploadingFunction = function createUploadingFunction(store, deferredUploadId, collectionName, traceContext) {
   return /*#__PURE__*/function () {
-    var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(chunks) {
-      var response, results;
+    var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(chunk) {
       return _regenerator.default.wrap(function _callee2$(_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
             _context2.t0 = store;
-            _context2.t1 = hashedChunks(chunks);
-            _context2.next = 4;
+            _context2.t1 = chunk.hash;
+            _context2.t2 = chunk.blob;
+            _context2.next = 5;
             return deferredUploadId;
-          case 4:
-            _context2.t2 = _context2.sent;
-            _context2.t3 = collectionName;
-            _context2.t4 = traceContext;
-            _context2.next = 9;
-            return _context2.t0.probeChunks.call(_context2.t0, _context2.t1, _context2.t2, _context2.t3, _context2.t4);
-          case 9:
-            response = _context2.sent;
-            results = response.data.results;
-            return _context2.abrupt("return", Object.values(results).map(function (result) {
-              return result.exists;
-            }));
+          case 5:
+            _context2.t3 = _context2.sent;
+            _context2.t4 = chunk.partNumber;
+            _context2.t5 = collectionName;
+            _context2.t6 = traceContext;
+            _context2.next = 11;
+            return _context2.t0.uploadChunk.call(_context2.t0, _context2.t1, _context2.t2, _context2.t3, _context2.t4, _context2.t5, _context2.t6);
+          case 11:
+            return _context2.abrupt("return", _context2.sent);
           case 12:
           case "end":
             return _context2.stop();
@@ -71,75 +68,44 @@ var createProbingFunction = function createProbingFunction(store, deferredUpload
     };
   }();
 };
-var createUploadingFunction = function createUploadingFunction(store, deferredUploadId, collectionName, traceContext) {
+var createProcessingFunction = function createProcessingFunction(store, deferredUploadId, collection, traceContext) {
+  var offset = 0;
   return /*#__PURE__*/function () {
-    var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(chunk) {
+    var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(chunks) {
       return _regenerator.default.wrap(function _callee3$(_context3) {
         while (1) switch (_context3.prev = _context3.next) {
           case 0:
             _context3.t0 = store;
-            _context3.t1 = chunk.hash;
-            _context3.t2 = chunk.blob;
-            _context3.next = 5;
-            return deferredUploadId;
-          case 5:
-            _context3.t3 = _context3.sent;
-            _context3.t4 = chunk.partNumber;
-            _context3.t5 = collectionName;
-            _context3.t6 = traceContext;
-            _context3.next = 11;
-            return _context3.t0.uploadChunk.call(_context3.t0, _context3.t1, _context3.t2, _context3.t3, _context3.t4, _context3.t5, _context3.t6);
-          case 11:
-            return _context3.abrupt("return", _context3.sent);
-          case 12:
-          case "end":
-            return _context3.stop();
-        }
-      }, _callee3);
-    }));
-    return function (_x3) {
-      return _ref3.apply(this, arguments);
-    };
-  }();
-};
-var createProcessingFunction = function createProcessingFunction(store, deferredUploadId, collection, traceContext) {
-  var offset = 0;
-  return /*#__PURE__*/function () {
-    var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(chunks) {
-      return _regenerator.default.wrap(function _callee4$(_context4) {
-        while (1) switch (_context4.prev = _context4.next) {
-          case 0:
-            _context4.t0 = store;
-            _context4.next = 3;
+            _context3.next = 3;
             return deferredUploadId;
           case 3:
-            _context4.t1 = _context4.sent;
-            _context4.t2 = {
+            _context3.t1 = _context3.sent;
+            _context3.t2 = {
               chunks: hashedChunks(chunks),
               offset: offset
             };
-            _context4.t3 = collection;
-            _context4.t4 = traceContext;
-            _context4.next = 9;
-            return _context4.t0.appendChunksToUpload.call(_context4.t0, _context4.t1, _context4.t2, _context4.t3, _context4.t4);
+            _context3.t3 = collection;
+            _context3.t4 = traceContext;
+            _context3.next = 9;
+            return _context3.t0.appendChunksToUpload.call(_context3.t0, _context3.t1, _context3.t2, _context3.t3, _context3.t4);
           case 9:
             offset += chunks.length;
           case 10:
           case "end":
-            return _context4.stop();
+            return _context3.stop();
         }
-      }, _callee4);
+      }, _callee3);
     }));
-    return function (_x4) {
-      return _ref4.apply(this, arguments);
+    return function (_x3) {
+      return _ref3.apply(this, arguments);
     };
   }();
 };
 var createFileFromUpload = /*#__PURE__*/function () {
-  var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(file, store, uploadableFileUpfrontIds, uploadId, traceContext) {
+  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(file, store, uploadableFileUpfrontIds, uploadId, traceContext) {
     var collection, name, mimeType, id, occurrenceKey, body;
-    return _regenerator.default.wrap(function _callee5$(_context5) {
-      while (1) switch (_context5.prev = _context5.next) {
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
         case 0:
           collection = file.collection, name = file.name, mimeType = file.mimeType;
           id = uploadableFileUpfrontIds.id, occurrenceKey = uploadableFileUpfrontIds.occurrenceKey;
@@ -155,19 +121,19 @@ var createFileFromUpload = /*#__PURE__*/function () {
             name: name,
             mimeType: mimeType
           };
-          return _context5.abrupt("return", store.createFileFromUpload(body, {
+          return _context4.abrupt("return", store.createFileFromUpload(body, {
             occurrenceKey: occurrenceKey,
             collection: collection,
             replaceFileId: id
           }, traceContext));
         case 4:
         case "end":
-          return _context5.stop();
+          return _context4.stop();
       }
-    }, _callee5);
+    }, _callee4);
   }));
-  return function createFileFromUpload(_x5, _x6, _x7, _x8, _x9) {
-    return _ref5.apply(this, arguments);
+  return function createFileFromUpload(_x4, _x5, _x6, _x7, _x8) {
+    return _ref4.apply(this, arguments);
   };
 }();
 var uploadFile = exports.uploadFile = function uploadFile(file, store, uploadableFileUpfrontIds, callbacks, traceContext) {
@@ -197,11 +163,9 @@ var uploadFile = exports.uploadFile = function uploadFile(file, store, uploadabl
   var chunkinatorObservable = (0, _chunkinator.chunkinator)(content, {
     hashingFunction: hashingFunction,
     hashingConcurrency: 5,
-    probingBatchSize: 100,
     chunkSize: chunkSize,
     uploadingConcurrency: 3,
     uploadingFunction: createUploadingFunction(store, deferredUploadId, collection, traceContext),
-    probingFunction: createProbingFunction(store, deferredUploadId, collection, traceContext),
     processingBatchSize: _constants.PROCESSING_BATCH_SIZE,
     processingFunction: createProcessingFunction(store, deferredUploadId, collection, traceContext)
   }, {

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

@@ -100,27 +100,6 @@ export class MediaStore {
     };
     await this.request(`/chunk/${etag}`, options);
   }
-  probeChunks(chunks, uploadId, collectionName, traceContext) {
-    const metadata = {
-      method: 'POST',
-      endpoint: '/chunk/probe'
-    };
-    const options = {
-      ...metadata,
-      params: {
-        uploadId
-      },
-      authContext: {
-        collectionName
-      },
-      headers: jsonHeaders,
-      body: JSON.stringify({
-        chunks
-      }),
-      traceContext
-    };
-    return this.request(`/chunk/probe`, options).then(createMapResponseToJson(metadata));
-  }
   createFileFromUpload(body, params = {}, traceContext) {
     const metadata = {
       method: 'POST',

package/dist/es2019/test-helpers/MockedMediaApi/MockedMediaApi.js

@@ -0,0 +1,161 @@
+import { getMediaFile, normaliseInput } from './helpers';
+const getMediaApi = ({
+  getFileItem
+}) => ({
+  // --------------------------------------------------------
+  // UPLOAD ENDPOINTS - None is supported
+  // --------------------------------------------------------
+
+  touchFiles: async ({
+    descriptors
+  }) => {
+    throw new Error('500 - MockedMediaApi.touchFiles: method not implemented');
+  },
+  uploadChunk: async (_etag, _blob, uploadId) => {
+    throw new Error('500 - MockedMediaApi.uploadChunk: method not implemented');
+  },
+  appendChunksToUpload: async () => {
+    throw new Error('500 - MockedMediaApi.appendChunksToUpload: method not implemented');
+  },
+  createFileFromUpload: async ({
+    uploadId
+  }, {
+    collection
+  }) => {
+    throw new Error('500 - MockedMediaApi.createFileFromUpload: method not implemented');
+  },
+  // Used by Media Picker as a fallback for conflicted file Ids
+  createUpload: async () => {
+    throw new Error('500 - MockedMediaApi.createUpload: method not implemented');
+  },
+  // For File size limits
+  getRejectedResponseFromDescriptor: () => {
+    throw new Error('500 - MockedMediaApi.getRejectedResponseFromDescriptor: method not implemented');
+  },
+  // --------------------------------------------------------
+  // METADATA ENDPOINTS
+  // --------------------------------------------------------
+
+  getFile: async fileId => {
+    const fileItem = getFileItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getFile: file not found');
+    }
+    return {
+      data: getMediaFile(fileItem)
+    };
+  },
+  getItems: async ids => {
+    const items = ids.map(id => getFileItem(id)).filter(fileState => !!fileState);
+    return {
+      data: {
+        items
+      }
+    };
+  },
+  // TODO
+  getImageMetadata: async () => {
+    throw new Error('500 - MockedMediaApi.getImageMetadata: method not implemented');
+  },
+  // --------------------------------------------------------
+  // URL ENDPOINTS
+  // --------------------------------------------------------
+
+  // TODO
+  getFileImageURL: async () => {
+    throw new Error('500 - MockedMediaApi.getFileImageURL: method not implemented');
+  },
+  // TODO
+  getFileImageURLSync: () => {
+    throw new Error('500 - MockedMediaApi.getFileImageURLSync: method not implemented');
+  },
+  getFileBinaryURL: async id => {
+    const fileItem = getFileItem(id);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getFileBinaryURL: file not found');
+    }
+    if (fileItem.details.size === 0) {
+      // TODO veryify if this is the correct answer for an uploading file
+      throw new Error('404 - MockedMediaApi.getFileBinaryURL: file is empty');
+    }
+    return `/file/${id}/binary`;
+  },
+  getArtifactURL: async (artifacts, artifactName) => {
+    var _artifacts$artifactNa;
+    const artifactUrl = (_artifacts$artifactNa = artifacts[artifactName]) === null || _artifacts$artifactNa === void 0 ? void 0 : _artifacts$artifactNa.url;
+    if (!artifactUrl) {
+      throw new Error(`404 - MockedMediaApi.getArtifactURL: artifact ${artifactName} not found`);
+    }
+    return artifactUrl;
+  },
+  // --------------------------------------------------------
+  // BINARY ENDPOINTS
+  // --------------------------------------------------------
+  getImage: async fileId => {
+    const fileItem = getFileItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.getImage: file not found');
+    }
+    if (!fileItem.details.representations.image) {
+      throw new Error('404 - MockedMediaApi.getImage: image not found');
+    }
+
+    // Empty Blob. Might have to change for a real one if TLR loads the image
+    return new Blob();
+  },
+  // --------------------------------------------------------
+  // OTHER ENDPOINTS
+  // --------------------------------------------------------
+
+  // TODO
+  copyFileWithToken: async body => {
+    const fileId = body.sourceFile.id;
+    const fileItem = getFileItem(fileId);
+    if (!fileItem) {
+      throw new Error('404 - MockedMediaApi.copyFileWithToken: file not found');
+    }
+    return {
+      data: getMediaFile(fileItem)
+    };
+  },
+  // TODO
+  removeCollectionFile: async () => {},
+  // --------------------------------------------------------
+  // OTHER ENDPOINTS
+  // --------------------------------------------------------
+  request: async () => new Response(),
+  resolveAuth: async () => ({
+    asapIssuer: '',
+    token: '',
+    baseUrl: ''
+  }),
+  resolveInitialAuth: () => ({
+    asapIssuer: '',
+    token: '',
+    baseUrl: ''
+  })
+});
+
+/**
+ * Mocked Media API
+ */
+export const createMockedMediaApi = initialFileItems => {
+  const storedFileItems = new Map();
+  const getFileItem = fileId => storedFileItems.get(fileId);
+  const setFileItems = fileItems => {
+    const normalised = normaliseInput(fileItems);
+    normalised.forEach(fileItem => storedFileItems.set(fileItem.id, fileItem));
+  };
+  if (initialFileItems) {
+    setFileItems(initialFileItems);
+  }
+  const mediaApi = getMediaApi({
+    setFileItems,
+    getFileItem
+  });
+  return {
+    setFileItems,
+    getFileItem,
+    mediaApi
+  };
+};

package/dist/es2019/test-helpers/MockedMediaApi/helpers.js

@@ -0,0 +1,166 @@
+import uuid from 'uuid/v4';
+// --------------------------------------------------------
+// Factory Utils
+// --------------------------------------------------------
+export const normaliseInput = input => !input ? [] : input instanceof Array ? input : [input];
+
+// --------------------------------------------------------
+// Utils for the main class
+// --------------------------------------------------------
+
+export const getMediaFile = fileItem => ({
+  id: fileItem.id,
+  ...fileItem.details
+});
+
+// --------------------------------------------------------
+// Utils for creating file descriptors for tests
+// --------------------------------------------------------
+
+export const createEmptyFileItem = (id, collection) => {
+  const emptyFileItem = {
+    type: 'file',
+    id,
+    details: {
+      mediaType: 'unknown',
+      mimeType: 'binary/octet-stream',
+      name: '',
+      size: 0,
+      processingStatus: 'pending',
+      artifacts: {},
+      representations: {},
+      createdAt: 1699488941974
+    }
+  };
+  if (collection) {
+    emptyFileItem.collection = collection;
+  }
+  return emptyFileItem;
+};
+
+/**
+ * Simulates the processing of the file by updating the processing status of the artifacts by a percentage
+ * Percent must be between 0 and 1
+ */
+export const createProcessingFileItem = (fileItem, percent) => {
+  if (percent < 0 || percent > 1) {
+    throw new Error('Error createProcessingFileItem: percent must be between 0 and 1');
+  }
+
+  /**
+   * This behaviour has to be confirmed
+   * Artifacts show up immediately after processed or they have a
+   * "processing time"?
+   */
+
+  if (percent === 1) {
+    return fileItem;
+  }
+
+  // No artifacts for 0% processing
+  if (percent === 0) {
+    return {
+      ...fileItem,
+      details: {
+        ...fileItem.details,
+        processingStatus: 'pending',
+        artifacts: {},
+        // The preview will only be ready at 100% -> TODO verify against backend
+        representations: {}
+      }
+    };
+  }
+  const artifactsKeys = Object.keys(fileItem.details.artifacts);
+  const artifactsEntries = Object.entries({
+    ...fileItem.details.artifacts // Spreading to make TS happy
+  });
+
+  // Get a % of the total artifacts to be set as processed
+  const processedArtifactKeys = artifactsKeys.slice(0, Math.ceil(artifactsKeys.length * percent));
+  const processedArtifactEntries = artifactsEntries.map(([key, artifact]) => [key, {
+    ...artifact,
+    processingStatus: processedArtifactKeys.includes(key) ? 'succeeded' : 'pending'
+  }]);
+  const artifactsProcessingPercent = Object.fromEntries(processedArtifactEntries);
+  return {
+    ...fileItem,
+    details: {
+      ...fileItem.details,
+      processingStatus: 'pending',
+      artifacts: artifactsProcessingPercent,
+      // The preview will only be ready at 100% -> TODO verify against backend
+      representations: {}
+    }
+  };
+};
+
+/**
+ * Makes a copy of the provided file item with a random file id
+ * */
+export const copy = fileItem => JSON.parse(JSON.stringify(fileItem).replace(new RegExp(fileItem.id, 'g'), uuid()));
+/**
+ * Extracts the file identifier from the provided file item
+ */
+export const getIdentifier = fileItem => ({
+  mediaItemType: 'file',
+  id: fileItem.id,
+  collectionName: fileItem.collection
+});
+export const createFileState = ({
+  id,
+  details: {
+    name,
+    size,
+    mediaType,
+    mimeType,
+    createdAt,
+    processingStatus,
+    artifacts,
+    representations
+  }
+}) => ({
+  status: processingStatus === 'succeeded' ? 'processed' : 'processing',
+  id,
+  name,
+  size,
+  mediaType,
+  mimeType,
+  createdAt,
+  artifacts,
+  representations
+});
+export const createUploadingFileState = ({
+  id,
+  details: {
+    name,
+    size,
+    mediaType,
+    mimeType,
+    createdAt
+  }
+}, progress) => ({
+  status: 'uploading',
+  progress,
+  id,
+  name,
+  size,
+  mediaType,
+  mimeType,
+  createdAt,
+  preview: {
+    value: new Blob(['some-content'], {
+      type: mimeType
+    })
+  }
+});
+export const createErrorFileState = ({
+  id
+}) => ({
+  status: 'error',
+  id,
+  reason: 'a random error',
+  message: 'a random error message',
+  details: {
+    some: 'mocked error detail'
+  }
+});

package/dist/es2019/test-helpers/MockedMediaApi/index.js

@@ -0,0 +1,2 @@
+export { createMockedMediaApi } from './MockedMediaApi';
+export { copy, getIdentifier, createEmptyFileItem, createUploadingFileState, createErrorFileState, createFileState, createProcessingFileItem } from './helpers';

package/dist/es2019/test-helpers/index.js

@@ -4,4 +4,5 @@ export { collectionNames, defaultCollectionName, defaultMediaPickerCollectionNam
 export { animatedFileId, archiveFileId, atlassianLogoUrl, audioFileDetails, audioFileId, audioNoCoverFileId, bigDocFileId, docFileDetails, docFileId, emptyImageFileId, errorFileId, externalImageIdentifier, externalSmallImageIdentifier, externaBrokenlIdentifier, genericDataURI, genericFileDetails, genericFileId, gifFileId, imageFileDetails, imageFileId, largeImageFileId, largePdfFileId, noMetadataFileId, passwordProtectedPdfFileId, smallImageFileId, unknownFileDetails, unknownFileId, verticalImageFileId, videoFileDetails, videoFileId, videoHorizontalFileId, videoLargeFileId, videoProcessingFailedId, videoSquareFileId, wideImageFileId, zipFileId, zipFileWithNestedFolderId, zipItemLargeInnerFileId, zipItemMultipleFoldersAtRootId, zipJiraArchiveFileId, zipEncryptedFileId, codeFileId, emailFileId, emailUnsupportedFileId, vrVideoDetails } from './exampleMediaItems';
 export const authProviderBaseURL = 'https://media.dev.atl-paas.net';
 export { mediaPickerAuthProvider, defaultMediaPickerAuthProvider } from './mediaPickerAuthProvider';
-export { fakeMediaClient } from './fakeMediaClient';
+export { fakeMediaClient } from './fakeMediaClient';
+export { createMockedMediaApi, copy, getIdentifier, createProcessingFileItem, createEmptyFileItem, createUploadingFileState, createFileState, createErrorFileState } from './MockedMediaApi';