@atlaskit/media-client 25.0.3 → 25.1.0

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

@@ -0,0 +1,442 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { getMediaFile, normaliseInput } from './helpers';
+var getMediaApi = function getMediaApi(_ref) {
+  var getFileItem = _ref.getFileItem;
+  return {
+    // --------------------------------------------------------
+    // UPLOAD ENDPOINTS - None is supported
+    // --------------------------------------------------------
+
+    touchFiles: function () {
+      var _touchFiles = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref2) {
+        var descriptors;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              descriptors = _ref2.descriptors;
+              throw new Error('500 - MockedMediaApi.touchFiles: method not implemented');
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      function touchFiles(_x) {
+        return _touchFiles.apply(this, arguments);
+      }
+      return touchFiles;
+    }(),
+    probeChunks: function () {
+      var _probeChunks = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.probeChunks: method not implemented');
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function probeChunks() {
+        return _probeChunks.apply(this, arguments);
+      }
+      return probeChunks;
+    }(),
+    uploadChunk: function () {
+      var _uploadChunk = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(_etag, _blob, uploadId) {
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.uploadChunk: method not implemented');
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      function uploadChunk(_x2, _x3, _x4) {
+        return _uploadChunk.apply(this, arguments);
+      }
+      return uploadChunk;
+    }(),
+    appendChunksToUpload: function () {
+      var _appendChunksToUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.appendChunksToUpload: method not implemented');
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      function appendChunksToUpload() {
+        return _appendChunksToUpload.apply(this, arguments);
+      }
+      return appendChunksToUpload;
+    }(),
+    createFileFromUpload: function () {
+      var _createFileFromUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref3, _ref4) {
+        var uploadId, collection;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              uploadId = _ref3.uploadId;
+              collection = _ref4.collection;
+              throw new Error('500 - MockedMediaApi.createFileFromUpload: method not implemented');
+            case 3:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5);
+      }));
+      function createFileFromUpload(_x5, _x6) {
+        return _createFileFromUpload.apply(this, arguments);
+      }
+      return createFileFromUpload;
+    }(),
+    // Used by Media Picker as a fallback for conflicted file Ids
+    createUpload: function () {
+      var _createUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.createUpload: method not implemented');
+            case 1:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6);
+      }));
+      function createUpload() {
+        return _createUpload.apply(this, arguments);
+      }
+      return createUpload;
+    }(),
+    // For File size limits
+    getRejectedResponseFromDescriptor: function getRejectedResponseFromDescriptor() {
+      throw new Error('500 - MockedMediaApi.getRejectedResponseFromDescriptor: method not implemented');
+    },
+    // --------------------------------------------------------
+    // METADATA ENDPOINTS
+    // --------------------------------------------------------
+
+    getFile: function () {
+      var _getFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(fileId) {
+        var fileItem;
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              fileItem = getFileItem(fileId);
+              if (fileItem) {
+                _context7.next = 3;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getFile: file not found');
+            case 3:
+              return _context7.abrupt("return", {
+                data: getMediaFile(fileItem)
+              });
+            case 4:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7);
+      }));
+      function getFile(_x7) {
+        return _getFile.apply(this, arguments);
+      }
+      return getFile;
+    }(),
+    getItems: function () {
+      var _getItems = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(ids) {
+        var items;
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              items = ids.map(function (id) {
+                return getFileItem(id);
+              }).filter(function (fileState) {
+                return !!fileState;
+              });
+              return _context8.abrupt("return", {
+                data: {
+                  items: items
+                }
+              });
+            case 2:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8);
+      }));
+      function getItems(_x8) {
+        return _getItems.apply(this, arguments);
+      }
+      return getItems;
+    }(),
+    // TODO
+    getImageMetadata: function () {
+      var _getImageMetadata = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.getImageMetadata: method not implemented');
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9);
+      }));
+      function getImageMetadata() {
+        return _getImageMetadata.apply(this, arguments);
+      }
+      return getImageMetadata;
+    }(),
+    // --------------------------------------------------------
+    // URL ENDPOINTS
+    // --------------------------------------------------------
+
+    // TODO
+    getFileImageURL: function () {
+      var _getFileImageURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+        return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.getFileImageURL: method not implemented');
+            case 1:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10);
+      }));
+      function getFileImageURL() {
+        return _getFileImageURL.apply(this, arguments);
+      }
+      return getFileImageURL;
+    }(),
+    // TODO
+    getFileImageURLSync: function getFileImageURLSync() {
+      throw new Error('500 - MockedMediaApi.getFileImageURLSync: method not implemented');
+    },
+    getFileBinaryURL: function () {
+      var _getFileBinaryURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11(id) {
+        var fileItem;
+        return _regeneratorRuntime.wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              fileItem = getFileItem(id);
+              if (fileItem) {
+                _context11.next = 3;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getFileBinaryURL: file not found');
+            case 3:
+              if (!(fileItem.details.size === 0)) {
+                _context11.next = 5;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getFileBinaryURL: file is empty');
+            case 5:
+              return _context11.abrupt("return", "/file/".concat(id, "/binary"));
+            case 6:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11);
+      }));
+      function getFileBinaryURL(_x9) {
+        return _getFileBinaryURL.apply(this, arguments);
+      }
+      return getFileBinaryURL;
+    }(),
+    getArtifactURL: function () {
+      var _getArtifactURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12(artifacts, artifactName) {
+        var _artifacts$artifactNa;
+        var artifactUrl;
+        return _regeneratorRuntime.wrap(function _callee12$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              artifactUrl = (_artifacts$artifactNa = artifacts[artifactName]) === null || _artifacts$artifactNa === void 0 ? void 0 : _artifacts$artifactNa.url;
+              if (artifactUrl) {
+                _context12.next = 3;
+                break;
+              }
+              throw new Error("404 - MockedMediaApi.getArtifactURL: artifact ".concat(artifactName, " not found"));
+            case 3:
+              return _context12.abrupt("return", artifactUrl);
+            case 4:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12);
+      }));
+      function getArtifactURL(_x10, _x11) {
+        return _getArtifactURL.apply(this, arguments);
+      }
+      return getArtifactURL;
+    }(),
+    // --------------------------------------------------------
+    // BINARY ENDPOINTS
+    // --------------------------------------------------------
+    getImage: function () {
+      var _getImage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13(fileId) {
+        var fileItem;
+        return _regeneratorRuntime.wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              fileItem = getFileItem(fileId);
+              if (fileItem) {
+                _context13.next = 3;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getImage: file not found');
+            case 3:
+              if (fileItem.details.representations.image) {
+                _context13.next = 5;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getImage: image not found');
+            case 5:
+              return _context13.abrupt("return", new Blob());
+            case 6:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13);
+      }));
+      function getImage(_x12) {
+        return _getImage.apply(this, arguments);
+      }
+      return getImage;
+    }(),
+    // --------------------------------------------------------
+    // OTHER ENDPOINTS
+    // --------------------------------------------------------
+
+    // TODO
+    copyFileWithToken: function () {
+      var _copyFileWithToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee14(body) {
+        var fileId, fileItem;
+        return _regeneratorRuntime.wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              fileId = body.sourceFile.id;
+              fileItem = getFileItem(fileId);
+              if (fileItem) {
+                _context14.next = 4;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.copyFileWithToken: file not found');
+            case 4:
+              return _context14.abrupt("return", {
+                data: getMediaFile(fileItem)
+              });
+            case 5:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14);
+      }));
+      function copyFileWithToken(_x13) {
+        return _copyFileWithToken.apply(this, arguments);
+      }
+      return copyFileWithToken;
+    }(),
+    // TODO
+    removeCollectionFile: function () {
+      var _removeCollectionFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {
+        return _regeneratorRuntime.wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15);
+      }));
+      function removeCollectionFile() {
+        return _removeCollectionFile.apply(this, arguments);
+      }
+      return removeCollectionFile;
+    }(),
+    // --------------------------------------------------------
+    // OTHER ENDPOINTS
+    // --------------------------------------------------------
+    request: function () {
+      var _request = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee16() {
+        return _regeneratorRuntime.wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              return _context16.abrupt("return", new Response());
+            case 1:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16);
+      }));
+      function request() {
+        return _request.apply(this, arguments);
+      }
+      return request;
+    }(),
+    resolveAuth: function () {
+      var _resolveAuth = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee17() {
+        return _regeneratorRuntime.wrap(function _callee17$(_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              return _context17.abrupt("return", {
+                asapIssuer: '',
+                token: '',
+                baseUrl: ''
+              });
+            case 1:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17);
+      }));
+      function resolveAuth() {
+        return _resolveAuth.apply(this, arguments);
+      }
+      return resolveAuth;
+    }(),
+    resolveInitialAuth: function resolveInitialAuth() {
+      return {
+        asapIssuer: '',
+        token: '',
+        baseUrl: ''
+      };
+    }
+  };
+};
+
+/**
+ * Mocked Media API
+ */
+export var createMockedMediaApi = function createMockedMediaApi(initialFileItems) {
+  var storedFileItems = new Map();
+  var getFileItem = function getFileItem(fileId) {
+    return storedFileItems.get(fileId);
+  };
+  var setFileItems = function setFileItems(fileItems) {
+    var normalised = normaliseInput(fileItems);
+    normalised.forEach(function (fileItem) {
+      return storedFileItems.set(fileItem.id, fileItem);
+    });
+  };
+  if (initialFileItems) {
+    setFileItems(initialFileItems);
+  }
+  var mediaApi = getMediaApi({
+    setFileItems: setFileItems,
+    getFileItem: getFileItem
+  });
+  return {
+    setFileItems: setFileItems,
+    getFileItem: getFileItem,
+    mediaApi: mediaApi
+  };
+};

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

@@ -0,0 +1,176 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import uuid from 'uuid/v4';
+// --------------------------------------------------------
+// Factory Utils
+// --------------------------------------------------------
+export var normaliseInput = function normaliseInput(input) {
+  return !input ? [] : input instanceof Array ? input : [input];
+};
+
+// --------------------------------------------------------
+// Utils for the main class
+// --------------------------------------------------------
+
+export var getMediaFile = function getMediaFile(fileItem) {
+  return _objectSpread({
+    id: fileItem.id
+  }, fileItem.details);
+};
+
+// --------------------------------------------------------
+// Utils for creating file descriptors for tests
+// --------------------------------------------------------
+
+export var createEmptyFileItem = function createEmptyFileItem(id, collection) {
+  var emptyFileItem = {
+    type: 'file',
+    id: 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 var createProcessingFileItem = function 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 _objectSpread(_objectSpread({}, fileItem), {}, {
+      details: _objectSpread(_objectSpread({}, fileItem.details), {}, {
+        processingStatus: 'pending',
+        artifacts: {},
+        // The preview will only be ready at 100% -> TODO verify against backend
+        representations: {}
+      })
+    });
+  }
+  var artifactsKeys = Object.keys(fileItem.details.artifacts);
+  var artifactsEntries = Object.entries(_objectSpread({}, fileItem.details.artifacts));
+
+  // Get a % of the total artifacts to be set as processed
+  var processedArtifactKeys = artifactsKeys.slice(0, Math.ceil(artifactsKeys.length * percent));
+  var processedArtifactEntries = artifactsEntries.map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      artifact = _ref2[1];
+    return [key, _objectSpread(_objectSpread({}, artifact), {}, {
+      processingStatus: processedArtifactKeys.includes(key) ? 'succeeded' : 'pending'
+    })];
+  });
+  var artifactsProcessingPercent = Object.fromEntries(processedArtifactEntries);
+  return _objectSpread(_objectSpread({}, fileItem), {}, {
+    details: _objectSpread(_objectSpread({}, 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 var copy = function copy(fileItem) {
+  return JSON.parse(JSON.stringify(fileItem).replace(new RegExp(fileItem.id, 'g'), uuid()));
+};
+/**
+ * Extracts the file identifier from the provided file item
+ */
+export var getIdentifier = function getIdentifier(fileItem) {
+  return {
+    mediaItemType: 'file',
+    id: fileItem.id,
+    collectionName: fileItem.collection
+  };
+};
+export var createFileState = function createFileState(_ref3) {
+  var id = _ref3.id,
+    _ref3$details = _ref3.details,
+    name = _ref3$details.name,
+    size = _ref3$details.size,
+    mediaType = _ref3$details.mediaType,
+    mimeType = _ref3$details.mimeType,
+    createdAt = _ref3$details.createdAt,
+    processingStatus = _ref3$details.processingStatus,
+    artifacts = _ref3$details.artifacts,
+    representations = _ref3$details.representations;
+  return {
+    status: processingStatus === 'succeeded' ? 'processed' : 'processing',
+    id: id,
+    name: name,
+    size: size,
+    mediaType: mediaType,
+    mimeType: mimeType,
+    createdAt: createdAt,
+    artifacts: artifacts,
+    representations: representations
+  };
+};
+export var createUploadingFileState = function createUploadingFileState(_ref4, progress) {
+  var id = _ref4.id,
+    _ref4$details = _ref4.details,
+    name = _ref4$details.name,
+    size = _ref4$details.size,
+    mediaType = _ref4$details.mediaType,
+    mimeType = _ref4$details.mimeType,
+    createdAt = _ref4$details.createdAt;
+  return {
+    status: 'uploading',
+    progress: progress,
+    id: id,
+    name: name,
+    size: size,
+    mediaType: mediaType,
+    mimeType: mimeType,
+    createdAt: createdAt,
+    preview: {
+      value: new Blob(['some-content'], {
+        type: mimeType
+      })
+    }
+  };
+};
+export var createErrorFileState = function createErrorFileState(_ref5) {
+  var id = _ref5.id;
+  return {
+    status: 'error',
+    id: id,
+    reason: 'a random error',
+    message: 'a random error message',
+    details: {
+      some: 'mocked error detail'
+    }
+  };
+};

package/dist/esm/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/esm/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 var 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';

package/dist/types/test-helpers/MockedMediaApi/MockedMediaApi.d.ts

@@ -0,0 +1,16 @@
+import { MediaApi, ResponseFileItem } from '../../client/media-store';
+export interface SetFileItems {
+    (fileItems: ResponseFileItem | ResponseFileItem[]): void;
+}
+export interface GetFileItem {
+    (id: string): ResponseFileItem | undefined;
+}
+export interface CreateMockedMediaApiResult {
+    mediaApi: MediaApi;
+    setFileItems: SetFileItems;
+    getFileItem: GetFileItem;
+}
+/**
+ * Mocked Media API
+ */
+export declare const createMockedMediaApi: (initialFileItems?: ResponseFileItem | ResponseFileItem[]) => CreateMockedMediaApiResult;

package/dist/types/test-helpers/MockedMediaApi/helpers.d.ts

@@ -0,0 +1,23 @@
+import { UploadingFileState, ErrorFileState, FileState } from '@atlaskit/media-state';
+import { MediaFile } from '../../models/media';
+import { ResponseFileItem } from '../../client/media-store/types';
+import type { FileIdentifier } from '../../identifier';
+export declare const normaliseInput: <T>(input?: T | T[] | undefined) => T[];
+export declare const getMediaFile: (fileItem: ResponseFileItem) => MediaFile;
+export declare const createEmptyFileItem: (id: string, collection?: string) => ResponseFileItem;
+/**
+ * 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 declare const createProcessingFileItem: (fileItem: ResponseFileItem, percent: number) => ResponseFileItem;
+/**
+ * Makes a copy of the provided file item with a random file id
+ * */
+export declare const copy: (fileItem: ResponseFileItem) => ResponseFileItem;
+/**
+ * Extracts the file identifier from the provided file item
+ */
+export declare const getIdentifier: (fileItem: ResponseFileItem) => FileIdentifier;
+export declare const createFileState: ({ id, details: { name, size, mediaType, mimeType, createdAt, processingStatus, artifacts, representations, }, }: ResponseFileItem) => FileState;
+export declare const createUploadingFileState: ({ id, details: { name, size, mediaType, mimeType, createdAt }, }: ResponseFileItem, progress: number) => UploadingFileState;
+export declare const createErrorFileState: ({ id, }: ResponseFileItem) => ErrorFileState;

package/dist/types/test-helpers/MockedMediaApi/index.d.ts

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

package/dist/types/test-helpers/index.d.ts

@@ -5,3 +5,5 @@ export { animatedFileId, archiveFileId, atlassianLogoUrl, audioFileDetails, audi
 export declare const authProviderBaseURL = "https://media.dev.atl-paas.net";
 export { mediaPickerAuthProvider, defaultMediaPickerAuthProvider, } from './mediaPickerAuthProvider';
 export { fakeMediaClient } from './fakeMediaClient';
+export type { CreateMockedMediaApiResult, SetFileItems, GetFileItem, } from './MockedMediaApi';
+export { createMockedMediaApi, copy, getIdentifier, createProcessingFileItem, createEmptyFileItem, createUploadingFileState, createFileState, createErrorFileState, } from './MockedMediaApi';