@atlaskit/media-client 39.1.20 → 39.2.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @atlaskit/media-client
 
+## 39.2.1
+
+### Patch Changes
+
+- Updated dependencies
+
+## 39.2.0
+
+### Minor Changes
+
+- [`749df3301523e`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/749df3301523e) -
+  Include intended generated entrypoints in published packages
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 39.1.20
 
 ### Patch Changes

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,615 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMockedMediaApi = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _getMediaFile = require("./getMediaFile");
+var _normaliseInput = require("./normaliseInput");
+var getMediaApi = function getMediaApi(_ref) {
+  var getItem = _ref.getItem;
+  return {
+    // --------------------------------------------------------
+    // UPLOAD ENDPOINTS - None is supported
+    // --------------------------------------------------------
+
+    touchFiles: function () {
+      var _touchFiles = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(_ref2) {
+        var descriptors;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(_etag, _blob, uploadId) {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(_ref3, _ref4) {
+        var uploadId, collection;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(fileId) {
+        var fileItem;
+        return _regenerator.default.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: (0, _getMediaFile.getMediaFile)(fileItem)
+              });
+            case 2:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6);
+      }));
+      function getFile(_x7) {
+        return _getFile.apply(this, arguments);
+      }
+      return getFile;
+    }(),
+    getItems: function () {
+      var _getItems = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(ids) {
+        var items;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(id) {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee0(id) {
+        var fileItem;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee1(artifacts, artifactName) {
+        var _artifacts$artifactNa;
+        var artifactUrl;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10(artifacts, artifactName) {
+        var _artifacts$artifactNa2, _artifacts$artifactNa3;
+        var artifactUrl;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11(id) {
+        var item;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12(id) {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13(fileId) {
+        var fileItem;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14(fileId) {
+        var fileItem;
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15(body) {
+        var fileId, fileItem;
+        return _regenerator.default.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: (0, _getMediaFile.getMediaFile)(fileItem)
+              });
+            case 2:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15);
+      }));
+      function copyFileWithToken(_x17) {
+        return _copyFileWithToken.apply(this, arguments);
+      }
+      return copyFileWithToken;
+    }(),
+    copyFile: function () {
+      var _copyFile = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16(fileId, params) {
+        var fileItem;
+        return _regenerator.default.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: (0, _getMediaFile.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17(ids, collectionName) {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee21() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee22() {
+        return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee23() {
+        return _regenerator.default.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
+ */
+var createMockedMediaApi = exports.createMockedMediaApi = function createMockedMediaApi(initialFileItems) {
+  var storedFileItems = new Map();
+  var getItem = function getItem(fileId) {
+    return storedFileItems.get(fileId);
+  };
+  var setItems = function setItems(fileItems) {
+    var normalised = (0, _normaliseInput.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/cjs/test-helpers/MockedMediaApi/assign.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assign = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@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) { (0, _defineProperty2.default)(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
+ * */
+var assign = exports.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/cjs/test-helpers/MockedMediaApi/copy.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.copy = void 0;
+var _uuid = require("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
+ * */
+var copy = exports.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'), (0, _uuid.v4)()))
+  );
+};