@atlaskit/media-client 39.1.19 → 39.2.0

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

@@ -0,0 +1,608 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { getMediaFile } from './getMediaFile';
+import { normaliseInput } from './normaliseInput';
+var getMediaApi = function getMediaApi(_ref) {
+  var getItem = _ref.getItem;
+  return {
+    // --------------------------------------------------------
+    // UPLOAD ENDPOINTS - None is supported
+    // --------------------------------------------------------
+
+    touchFiles: function () {
+      var _touchFiles = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref2) {
+        var descriptors;
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              descriptors = _ref2.descriptors;
+              throw new Error('500 - MockedMediaApi.touchFiles: method not implemented');
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      function touchFiles(_x) {
+        return _touchFiles.apply(this, arguments);
+      }
+      return touchFiles;
+    }(),
+    uploadChunk: function () {
+      var _uploadChunk = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_etag, _blob, uploadId) {
+        return _regeneratorRuntime.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.uploadChunk: method not implemented');
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function uploadChunk(_x2, _x3, _x4) {
+        return _uploadChunk.apply(this, arguments);
+      }
+      return uploadChunk;
+    }(),
+    appendChunksToUpload: function () {
+      var _appendChunksToUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        return _regeneratorRuntime.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.appendChunksToUpload: method not implemented');
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      function appendChunksToUpload() {
+        return _appendChunksToUpload.apply(this, arguments);
+      }
+      return appendChunksToUpload;
+    }(),
+    createFileFromUpload: function () {
+      var _createFileFromUpload = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(_ref3, _ref4) {
+        var uploadId, collection;
+        return _regeneratorRuntime.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              uploadId = _ref3.uploadId;
+              collection = _ref4.collection;
+              throw new Error('500 - MockedMediaApi.createFileFromUpload: method not implemented');
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      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 _callee5() {
+        return _regeneratorRuntime.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.createUpload: method not implemented');
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5);
+      }));
+      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 _callee6(fileId) {
+        var fileItem;
+        return _regeneratorRuntime.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              fileItem = getItem(fileId);
+              if (fileItem) {
+                _context6.next = 1;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getFile: file not found');
+            case 1:
+              return _context6.abrupt("return", {
+                data: getMediaFile(fileItem)
+              });
+            case 2:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6);
+      }));
+      function getFile(_x7) {
+        return _getFile.apply(this, arguments);
+      }
+      return getFile;
+    }(),
+    getItems: function () {
+      var _getItems = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(ids) {
+        var items;
+        return _regeneratorRuntime.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              items = ids.map(function (id) {
+                return getItem(id);
+              }).filter(function (fileState) {
+                return !!fileState;
+              });
+              return _context7.abrupt("return", {
+                data: {
+                  items: items
+                }
+              });
+            case 1:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7);
+      }));
+      function getItems(_x8) {
+        return _getItems.apply(this, arguments);
+      }
+      return getItems;
+    }(),
+    // TODO
+    getImageMetadata: function () {
+      var _getImageMetadata = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+        return _regeneratorRuntime.wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.getImageMetadata: method not implemented');
+            case 1:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8);
+      }));
+      function getImageMetadata() {
+        return _getImageMetadata.apply(this, arguments);
+      }
+      return getImageMetadata;
+    }(),
+    // --------------------------------------------------------
+    // URL ENDPOINTS
+    // --------------------------------------------------------
+
+    getFileImageURL: function () {
+      var _getFileImageURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9(id) {
+        return _regeneratorRuntime.wrap(function (_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              return _context9.abrupt("return", "image-url-".concat(id));
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9);
+      }));
+      function getFileImageURL(_x9) {
+        return _getFileImageURL.apply(this, arguments);
+      }
+      return getFileImageURL;
+    }(),
+    getFileImageURLSync: function getFileImageURLSync(id) {
+      return "image-url-sync-".concat(id);
+    },
+    getFileBinaryURL: function () {
+      var _getFileBinaryURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee0(id) {
+        var fileItem;
+        return _regeneratorRuntime.wrap(function (_context0) {
+          while (1) switch (_context0.prev = _context0.next) {
+            case 0:
+              fileItem = getItem(id);
+              if (fileItem) {
+                _context0.next = 1;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getFileBinaryURL: file not found');
+            case 1:
+              if (!(fileItem.details.size === 0)) {
+                _context0.next = 2;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getFileBinaryURL: file is empty');
+            case 2:
+              return _context0.abrupt("return", "/file/".concat(id, "/binary"));
+            case 3:
+            case "end":
+              return _context0.stop();
+          }
+        }, _callee0);
+      }));
+      function getFileBinaryURL(_x0) {
+        return _getFileBinaryURL.apply(this, arguments);
+      }
+      return getFileBinaryURL;
+    }(),
+    getArtifactURL: function () {
+      var _getArtifactURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee1(artifacts, artifactName) {
+        var _artifacts$artifactNa;
+        var artifactUrl;
+        return _regeneratorRuntime.wrap(function (_context1) {
+          while (1) switch (_context1.prev = _context1.next) {
+            case 0:
+              artifactUrl = (_artifacts$artifactNa = artifacts[artifactName]) === null || _artifacts$artifactNa === void 0 ? void 0 : _artifacts$artifactNa.url;
+              if (artifactUrl) {
+                _context1.next = 1;
+                break;
+              }
+              throw new Error("404 - MockedMediaApi.getArtifactURL: artifact ".concat(artifactName, " not found"));
+            case 1:
+              return _context1.abrupt("return", artifactUrl);
+            case 2:
+            case "end":
+              return _context1.stop();
+          }
+        }, _callee1);
+      }));
+      function getArtifactURL(_x1, _x10) {
+        return _getArtifactURL.apply(this, arguments);
+      }
+      return getArtifactURL;
+    }(),
+    getArtifactBinary: function () {
+      var _getArtifactBinary = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10(artifacts, artifactName) {
+        var _artifacts$artifactNa2, _artifacts$artifactNa3;
+        var artifactUrl;
+        return _regeneratorRuntime.wrap(function (_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              artifactUrl = ((_artifacts$artifactNa2 = artifacts[artifactName]) === null || _artifacts$artifactNa2 === void 0 ? void 0 : _artifacts$artifactNa2.url) || ((_artifacts$artifactNa3 = artifacts[artifactName]) === null || _artifacts$artifactNa3 === void 0 ? void 0 : _artifacts$artifactNa3.cdnUrl);
+              if (artifactUrl) {
+                _context10.next = 1;
+                break;
+              }
+              throw new Error("404 - MockedMediaApi.getArtifactBinary: artifact ".concat(artifactName, " URL not found"));
+            case 1:
+              return _context10.abrupt("return", new Blob());
+            case 2:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10);
+      }));
+      function getArtifactBinary(_x11, _x12) {
+        return _getArtifactBinary.apply(this, arguments);
+      }
+      return getArtifactBinary;
+    }(),
+    uploadArtifact: function () {
+      var _uploadArtifact = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11(id) {
+        var item;
+        return _regeneratorRuntime.wrap(function (_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              item = getItem(id);
+              if (item) {
+                _context11.next = 1;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.uploadArtifact: file not found');
+            case 1:
+              return _context11.abrupt("return", {
+                data: item.details
+              });
+            case 2:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11);
+      }));
+      function uploadArtifact(_x13) {
+        return _uploadArtifact.apply(this, arguments);
+      }
+      return uploadArtifact;
+    }(),
+    deleteArtifact: function () {
+      var _deleteArtifact = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12(id) {
+        return _regeneratorRuntime.wrap(function (_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12);
+      }));
+      function deleteArtifact(_x14) {
+        return _deleteArtifact.apply(this, arguments);
+      }
+      return deleteArtifact;
+    }(),
+    // --------------------------------------------------------
+    // BINARY ENDPOINTS
+    // --------------------------------------------------------
+    getImage: function () {
+      var _getImage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13(fileId) {
+        var fileItem;
+        return _regeneratorRuntime.wrap(function (_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              fileItem = getItem(fileId);
+              if (fileItem) {
+                _context13.next = 1;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getImage: file not found');
+            case 1:
+              if (fileItem.details.representations.image) {
+                _context13.next = 2;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getImage: image not found');
+            case 2:
+              return _context13.abrupt("return", new Blob());
+            case 3:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13);
+      }));
+      function getImage(_x15) {
+        return _getImage.apply(this, arguments);
+      }
+      return getImage;
+    }(),
+    getFileBinary: function () {
+      var _getFileBinary = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee14(fileId) {
+        var fileItem;
+        return _regeneratorRuntime.wrap(function (_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              fileItem = getItem(fileId);
+              if (fileItem) {
+                _context14.next = 1;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.getFileBinary: file not found');
+            case 1:
+              return _context14.abrupt("return", new Blob());
+            case 2:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14);
+      }));
+      function getFileBinary(_x16) {
+        return _getFileBinary.apply(this, arguments);
+      }
+      return getFileBinary;
+    }(),
+    // --------------------------------------------------------
+    // OTHER ENDPOINTS
+    // --------------------------------------------------------
+
+    // TODO
+    copyFileWithToken: function () {
+      var _copyFileWithToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee15(body) {
+        var fileId, fileItem;
+        return _regeneratorRuntime.wrap(function (_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              fileId = body.sourceFile.id;
+              fileItem = getItem(fileId);
+              if (fileItem) {
+                _context15.next = 1;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.copyFileWithToken: file not found');
+            case 1:
+              return _context15.abrupt("return", {
+                data: getMediaFile(fileItem)
+              });
+            case 2:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15);
+      }));
+      function copyFileWithToken(_x17) {
+        return _copyFileWithToken.apply(this, arguments);
+      }
+      return copyFileWithToken;
+    }(),
+    copyFile: function () {
+      var _copyFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee16(fileId, params) {
+        var fileItem;
+        return _regeneratorRuntime.wrap(function (_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              fileItem = getItem(fileId);
+              if (fileItem) {
+                _context16.next = 1;
+                break;
+              }
+              throw new Error('404 - MockedMediaApi.copy: file not found');
+            case 1:
+              return _context16.abrupt("return", {
+                data: getMediaFile(fileItem)
+              });
+            case 2:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16);
+      }));
+      function copyFile(_x18, _x19) {
+        return _copyFile.apply(this, arguments);
+      }
+      return copyFile;
+    }(),
+    registerCopyIntents: function () {
+      var _registerCopyIntents = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee17(ids, collectionName) {
+        return _regeneratorRuntime.wrap(function (_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17);
+      }));
+      function registerCopyIntents(_x20, _x21) {
+        return _registerCopyIntents.apply(this, arguments);
+      }
+      return registerCopyIntents;
+    }(),
+    // TODO
+    removeCollectionFile: function () {
+      var _removeCollectionFile = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee18() {
+        return _regeneratorRuntime.wrap(function (_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18);
+      }));
+      function removeCollectionFile() {
+        return _removeCollectionFile.apply(this, arguments);
+      }
+      return removeCollectionFile;
+    }(),
+    // --------------------------------------------------------
+    // OTHER ENDPOINTS
+    // --------------------------------------------------------
+    request: function () {
+      var _request = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee19() {
+        return _regeneratorRuntime.wrap(function (_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              return _context19.abrupt("return", new Response());
+            case 1:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19);
+      }));
+      function request() {
+        return _request.apply(this, arguments);
+      }
+      return request;
+    }(),
+    resolveAuth: function () {
+      var _resolveAuth = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee20() {
+        return _regeneratorRuntime.wrap(function (_context20) {
+          while (1) switch (_context20.prev = _context20.next) {
+            case 0:
+              return _context20.abrupt("return", {
+                asapIssuer: '',
+                token: '',
+                baseUrl: ''
+              });
+            case 1:
+            case "end":
+              return _context20.stop();
+          }
+        }, _callee20);
+      }));
+      function resolveAuth() {
+        return _resolveAuth.apply(this, arguments);
+      }
+      return resolveAuth;
+    }(),
+    resolveInitialAuth: function resolveInitialAuth() {
+      return {
+        asapIssuer: '',
+        token: '',
+        baseUrl: ''
+      };
+    },
+    getDocumentContent: function () {
+      var _getDocumentContent = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee21() {
+        return _regeneratorRuntime.wrap(function (_context21) {
+          while (1) switch (_context21.prev = _context21.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.getDocumentContent: method not implemented');
+            case 1:
+            case "end":
+              return _context21.stop();
+          }
+        }, _callee21);
+      }));
+      function getDocumentContent() {
+        return _getDocumentContent.apply(this, arguments);
+      }
+      return getDocumentContent;
+    }(),
+    getDocumentPageImage: function () {
+      var _getDocumentPageImage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee22() {
+        return _regeneratorRuntime.wrap(function (_context22) {
+          while (1) switch (_context22.prev = _context22.next) {
+            case 0:
+              throw new Error('500 - MockedMediaApi.getDocumentPageImage: method not implemented');
+            case 1:
+            case "end":
+              return _context22.stop();
+          }
+        }, _callee22);
+      }));
+      function getDocumentPageImage() {
+        return _getDocumentPageImage.apply(this, arguments);
+      }
+      return getDocumentPageImage;
+    }(),
+    testUrl: function () {
+      var _testUrl = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee23() {
+        return _regeneratorRuntime.wrap(function (_context23) {
+          while (1) switch (_context23.prev = _context23.next) {
+            case 0:
+            case "end":
+              return _context23.stop();
+          }
+        }, _callee23);
+      }));
+      function testUrl() {
+        return _testUrl.apply(this, arguments);
+      }
+      return testUrl;
+    }()
+  };
+};
+
+/**
+ * Mocked Media API
+ */
+export var createMockedMediaApi = function createMockedMediaApi(initialFileItems) {
+  var storedFileItems = new Map();
+  var getItem = function getItem(fileId) {
+    return storedFileItems.get(fileId);
+  };
+  var setItems = function setItems(fileItems) {
+    var normalised = normaliseInput(fileItems);
+    normalised.forEach(function (fileItem) {
+      return storedFileItems.set(fileItem.id, fileItem);
+    });
+  };
+  if (initialFileItems) {
+    setItems(initialFileItems);
+  }
+  var mediaApi = getMediaApi({
+    setItems: setItems,
+    getItem: getItem
+  });
+  return {
+    setItems: setItems,
+    getItem: getItem,
+    mediaApi: mediaApi
+  };
+};

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

@@ -0,0 +1,14 @@
+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; }
+/**
+ * Adds/overrides the attributes from fileItemB into the fileItemA
+ * */
+export var assign = function assign(fileItemA, fileItemB) {
+  var _fileItemA$details, _fileItemB$details;
+  return _objectSpread(_objectSpread(_objectSpread({}, fileItemA), fileItemB), {}, {
+    details: _objectSpread(_objectSpread(_objectSpread({}, fileItemA.details), fileItemB === null || fileItemB === void 0 ? void 0 : fileItemB.details), {}, {
+      artifacts: _objectSpread(_objectSpread({}, (_fileItemA$details = fileItemA.details) === null || _fileItemA$details === void 0 ? void 0 : _fileItemA$details.artifacts), fileItemB === null || fileItemB === void 0 || (_fileItemB$details = fileItemB.details) === null || _fileItemB$details === void 0 ? void 0 : _fileItemB$details.artifacts)
+    })
+  });
+};

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

@@ -0,0 +1,11 @@
+import { v4 as uuid } from 'uuid'; // eslint-disable-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
+
+/**
+ * Makes a copy of the provided file item with a random file id
+ * */
+export var copy = function copy(fileItem) {
+  return (
+    // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
+    JSON.parse(JSON.stringify(fileItem).replace(new RegExp(fileItem.id, 'g'), uuid()))
+  );
+};

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

@@ -0,0 +1,23 @@
+// --------------------------------------------------------
+// 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;
+};

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

@@ -0,0 +1,8 @@
+import { fromCommonMediaClientError } from '../../models/errors/fromCommonMediaClientError';
+import { createServerUnauthorizedError } from '../createServerUnauthorizedError';
+var defaultErrorFileStateError = createServerUnauthorizedError();
+export var createErrorFileState = function createErrorFileState(_ref) {
+  var id = _ref.id;
+  var error = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultErrorFileStateError;
+  return fromCommonMediaClientError(id, undefined, error);
+};

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

@@ -0,0 +1,23 @@
+export var createFileState = function createFileState(_ref) {
+  var id = _ref.id,
+    _ref$details = _ref.details,
+    name = _ref$details.name,
+    size = _ref$details.size,
+    mediaType = _ref$details.mediaType,
+    mimeType = _ref$details.mimeType,
+    createdAt = _ref$details.createdAt,
+    processingStatus = _ref$details.processingStatus,
+    artifacts = _ref$details.artifacts,
+    representations = _ref$details.representations;
+  return {
+    status: processingStatus === 'succeeded' ? 'processed' : 'processing',
+    id: id,
+    name: name,
+    size: size,
+    mediaType: mediaType,
+    mimeType: mimeType,
+    createdAt: createdAt,
+    artifacts: artifacts,
+    representations: representations
+  };
+};