@atlaskit/media-client 16.0.1 → 17.1.1

package/dist/es2019/{uploader.js → uploader/index.js}

@@ -1,21 +1,35 @@
 import { chunkinator } from '@atlaskit/chunkinator';
 import { from } from 'rxjs/observable/from';
 import { concatMap } from 'rxjs/operators/concatMap';
-import { createHasher } from './utils/hashing/hasherCreator'; // TODO: Allow to pass multiple files
+import { createHasher } from '../utils/hashing/hasherCreator';
+import { UploaderError } from './error';
+import { CHUNK_SIZE, PROCESSING_BATCH_SIZE } from '../constants';
+import { calculateChunkSize, fileSizeError } from './calculateChunkSize';
+import { getMediaFeatureFlag } from '@atlaskit/media-common'; // TODO: Allow to pass multiple files
 
 const hashingFunction = async blob => {
   const hasher = await createHasher();
   return hasher.hash(blob);
 };
 
-const createProbingFunction = (store, collection) => async chunks => {
-  const response = await store.probeChunks(hashedChunks(chunks), collection);
+const createProbingFunction = (store, deferredUploadId, collectionName) => async chunks => {
+  const response = await store.probeChunks(hashedChunks(chunks), {
+    collectionName,
+    uploadId: getMediaFeatureFlag('mediaUploadApiV2', store.featureFlags) ? await deferredUploadId : undefined
+  });
   const results = response.data.results;
   return Object.values(results).map(result => result.exists);
 };
 
-const createUploadingFunction = (store, collection) => {
-  return chunk => store.uploadChunk(chunk.hash, chunk.blob, collection);
+const createUploadingFunction = (store, deferredUploadId, collectionName) => async chunk => {
+  const options = getMediaFeatureFlag('mediaUploadApiV2', store.featureFlags) ? {
+    partNumber: chunk.partNumber,
+    uploadId: await deferredUploadId
+  } : {};
+  return await store.uploadChunk(chunk.hash, chunk.blob, {
+    collectionName,
+    ...options
+  });
 };
 
 const createProcessingFunction = (store, deferredUploadId, collection) => {
@@ -50,23 +64,46 @@ const createFileFromUpload = async (file, store, uploadableFileUpfrontIds, uploa
   });
 };
 
-export const uploadFile = (file, store, uploadableFileUpfrontIds, callbacks, chunkSize = 4 * 1024 * 1024, processingBatchSize = 1000) => {
+export const uploadFile = (file, store, uploadableFileUpfrontIds, callbacks) => {
   const {
     content,
     collection
   } = file;
   const {
-    deferredUploadId
+    deferredUploadId,
+    id,
+    occurrenceKey
   } = uploadableFileUpfrontIds;
+  let chunkSize = CHUNK_SIZE;
+
+  try {
+    if (content instanceof Blob && getMediaFeatureFlag('mediaUploadApiV2', store.featureFlags)) {
+      chunkSize = calculateChunkSize(content.size);
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message === fileSizeError) {
+      callbacks === null || callbacks === void 0 ? void 0 : callbacks.onUploadFinish(new UploaderError(err.message, id, {
+        collectionName: collection,
+        occurrenceKey: occurrenceKey
+      }));
+    }
+
+    return {
+      cancel: () => {
+        callbacks === null || callbacks === void 0 ? void 0 : callbacks.onUploadFinish('canceled');
+      }
+    };
+  }
+
   const chunkinatorObservable = chunkinator(content, {
     hashingFunction,
     hashingConcurrency: 5,
     probingBatchSize: 100,
     chunkSize,
     uploadingConcurrency: 3,
-    uploadingFunction: createUploadingFunction(store, collection),
-    probingFunction: createProbingFunction(store, collection),
-    processingBatchSize,
+    uploadingFunction: createUploadingFunction(store, deferredUploadId, collection),
+    probingFunction: createProbingFunction(store, deferredUploadId, collection),
+    processingBatchSize: PROCESSING_BATCH_SIZE,
     processingFunction: createProcessingFunction(store, deferredUploadId, collection)
   }, {
     onProgress(progress) {

package/dist/es2019/utils/{toMediaSubscribable.js → mediaSubscribable/fromObservable.js}

@@ -1,5 +1,5 @@
-import { createMediaSubject } from './createMediaSubject';
-export function toMediaSubscribable(observable) {
+import { createMediaSubject } from '../createMediaSubject';
+export function fromObservable(observable) {
   return {
     subscribe: observer => {
       const subscription = // This is needed to handle "subscribe" function overload.
@@ -14,5 +14,5 @@ export function toMediaSubscribable(observable) {
   };
 }
 export function createMediaSubscribable(mediaSubscribableItem) {
-  return toMediaSubscribable(createMediaSubject(mediaSubscribableItem));
+  return fromObservable(createMediaSubject(mediaSubscribableItem));
 }

package/dist/es2019/utils/mediaSubscribable/index.js

@@ -0,0 +1,2 @@
+export { toPromise } from './toPromise';
+export { createMediaSubscribable, fromObservable } from './fromObservable';

package/dist/es2019/utils/{mediaSubscribableToPromise.js → mediaSubscribable/toPromise.js}

@@ -6,7 +6,7 @@ import { Subscription } from 'rxjs/Subscription';
  * @param mediaSubscribable a given MediaSubscribable<MediaSubscribableItem>
  * @param subscription a default Subscription (this parameter exists for testing purpose)
  */
-export const mediaSubscribableToPromise = (mediaSubscribable, subscription = new Subscription()) => {
+export const toPromise = (mediaSubscribable, subscription = new Subscription()) => {
   return new Promise((resolve, reject) => subscription.add(mediaSubscribable.subscribe({
     next: state => {
       resolve(state);

package/dist/es2019/utils/mediaSubscribable/types.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/media-client",
-	"version": "16.0.1",
+	"version": "17.1.1",
 	"sideEffects": false
 }

package/dist/esm/client/collection-fetcher.js

@@ -1,9 +1,9 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
@@ -12,7 +12,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 import { ReplaySubject } from 'rxjs/ReplaySubject';
 import { getFileStreamsCache } from '../file-streams-cache';
 import { mapMediaFileToFileState } from '../models/file-state';
-import { toMediaSubscribable } from '../utils/toMediaSubscribable';
+import { fromObservable } from '../utils/mediaSubscribable';
 export var collectionCache = {};
 
 var createCacheEntry = function createCacheEntry() {
@@ -98,7 +98,7 @@ export var CollectionFetcher = /*#__PURE__*/function () {
       }).catch(function (error) {
         return subject.error(error);
       });
-      return toMediaSubscribable(subject);
+      return fromObservable(subject);
     }
   }, {
     key: "removeFile",

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

@@ -1,4 +1,3 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
@@ -8,6 +7,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { Subscription } from 'rxjs/Subscription';
 import { of } from 'rxjs/observable/of';
 import { map } from 'rxjs/operators/map';
@@ -30,14 +30,13 @@ import { createFileDataloader } from '../../utils/createFileDataLoader';
 import { getMediaTypeFromUploadableFile } from '../../utils/getMediaTypeFromUploadableFile';
 import { overrideMediaTypeIfUnknown } from '../../utils/overrideMediaTypeIfUnknown';
 import { convertBase64ToBlob } from '../../utils/convertBase64ToBlob';
-import { mediaSubscribableToPromise } from '../../utils/mediaSubscribableToPromise';
+import { toPromise, fromObservable } from '../../utils/mediaSubscribable';
 import { getDimensionsFromBlob } from '../../utils/getDimensionsFromBlob';
 import { createMediaSubject } from '../../utils/createMediaSubject';
 import { isMimeTypeSupportedByBrowser, getMediaTypeFromMimeType } from '@atlaskit/media-common/mediaTypeUtils';
 import { shouldFetchRemoteFileStates, shouldFetchRemoteFileStatesObservable } from '../../utils/shouldFetchRemoteFileStates';
 import { PollingFunction } from '../../utils/polling';
 import { isEmptyFile } from '../../utils/detectEmptyFile';
-import { toMediaSubscribable } from '../../utils/toMediaSubscribable';
 export { isFileFetcherError, FileFetcherError } from './error';
 export var FileFetcherImpl = /*#__PURE__*/function () {
   function FileFetcherImpl(mediaStore) {
@@ -134,17 +133,17 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
           collectionName: collectionName,
           occurrenceKey: occurrenceKey
         }));
-        return toMediaSubscribable(subject);
+        return fromObservable(subject);
       }
 
-      return toMediaSubscribable(getFileStreamsCache().getOrInsert(id, function () {
+      return fromObservable(getFileStreamsCache().getOrInsert(id, function () {
         return _this2.createDownloadFileStream(id, collectionName);
       }));
     }
   }, {
     key: "getCurrentState",
     value: function getCurrentState(id, options) {
-      return mediaSubscribableToPromise(this.getFileState(id, options));
+      return toPromise(this.getFileState(id, options));
     }
   }, {
     key: "getArtifactURL",
@@ -432,7 +431,7 @@ export var FileFetcherImpl = /*#__PURE__*/function () {
         });
       }
 
-      return toMediaSubscribable(subject);
+      return fromObservable(subject);
     }
   }, {
     key: "downloadBinary",

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

@@ -1,7 +1,7 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { EventEmitter2 } from 'eventemitter2';
 import { MediaStore } from './media-store';
 import { CollectionFetcher } from './collection-fetcher';

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

@@ -1,8 +1,8 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
@@ -195,26 +195,38 @@ export var MediaStore = /*#__PURE__*/function () {
   }, {
     key: "uploadChunk",
     value: function () {
-      var _uploadChunk = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(etag, blob, collectionName) {
-        var metadata, options;
+      var _uploadChunk = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(etag, blob) {
+        var _ref,
+            collectionName,
+            uploadId,
+            partNumber,
+            metadata,
+            options,
+            _args3 = arguments;
+
         return _regeneratorRuntime.wrap(function _callee3$(_context3) {
           while (1) {
             switch (_context3.prev = _context3.next) {
               case 0:
+                _ref = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : {}, collectionName = _ref.collectionName, uploadId = _ref.uploadId, partNumber = _ref.partNumber;
                 metadata = {
                   method: 'PUT',
                   endpoint: '/chunk/{etag}'
                 };
                 options = _objectSpread(_objectSpread({}, metadata), {}, {
+                  params: {
+                    uploadId: uploadId,
+                    partNumber: partNumber
+                  },
                   authContext: {
                     collectionName: collectionName
                   },
                   body: blob
                 });
-                _context3.next = 4;
+                _context3.next = 5;
                 return this.request("/chunk/".concat(etag), options);
 
-              case 4:
+              case 5:
               case "end":
                 return _context3.stop();
             }
@@ -222,7 +234,7 @@ export var MediaStore = /*#__PURE__*/function () {
         }, _callee3, this);
       }));
 
-      function uploadChunk(_x6, _x7, _x8) {
+      function uploadChunk(_x6, _x7) {
         return _uploadChunk.apply(this, arguments);
       }
 
@@ -230,13 +242,20 @@ export var MediaStore = /*#__PURE__*/function () {
     }()
   }, {
     key: "probeChunks",
-    value: function probeChunks(chunks, collectionName) {
+    value: function probeChunks(chunks) {
+      var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+          collectionName = _ref2.collectionName,
+          uploadId = _ref2.uploadId;
+
       var metadata = {
         method: 'POST',
         endpoint: '/chunk/probe'
       };
 
       var options = _objectSpread(_objectSpread({}, metadata), {}, {
+        params: {
+          uploadId: uploadId
+        },
         authContext: {
           collectionName: collectionName
         },
@@ -309,13 +328,13 @@ export var MediaStore = /*#__PURE__*/function () {
     key: "getFileImageURL",
     value: function () {
       var _getFileImageURL = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(id, params) {
-        var _ref, collectionName, auth;
+        var _ref3, collectionName, auth;
 
         return _regeneratorRuntime.wrap(function _callee4$(_context4) {
           while (1) {
             switch (_context4.prev = _context4.next) {
               case 0:
-                _ref = params || {}, collectionName = _ref.collection;
+                _ref3 = params || {}, collectionName = _ref3.collection;
                 _context4.next = 3;
                 return this.resolveAuth({
                   collectionName: collectionName
@@ -333,7 +352,7 @@ export var MediaStore = /*#__PURE__*/function () {
         }, _callee4, this);
       }));
 
-      function getFileImageURL(_x9, _x10) {
+      function getFileImageURL(_x8, _x9) {
         return _getFileImageURL.apply(this, arguments);
       }
 
@@ -388,7 +407,7 @@ export var MediaStore = /*#__PURE__*/function () {
         }, _callee5, this);
       }));
 
-      function getFileBinaryURL(_x11, _x12) {
+      function getFileBinaryURL(_x10, _x11) {
         return _getFileBinaryURL.apply(this, arguments);
       }
 
@@ -437,7 +456,7 @@ export var MediaStore = /*#__PURE__*/function () {
         }, _callee6, this);
       }));
 
-      function getArtifactURL(_x13, _x14, _x15) {
+      function getArtifactURL(_x12, _x13, _x14) {
         return _getArtifactURL.apply(this, arguments);
       }
 
@@ -482,7 +501,7 @@ export var MediaStore = /*#__PURE__*/function () {
         }, _callee7, this);
       }));
 
-      function getImage(_x16, _x17, _x18, _x19) {
+      function getImage(_x15, _x16, _x17, _x18) {
         return _getImage.apply(this, arguments);
       }
 
@@ -527,7 +546,7 @@ export var MediaStore = /*#__PURE__*/function () {
         }, _callee8, this);
       }));
 
-      function getItems(_x20, _x21) {
+      function getItems(_x19, _x20) {
         return _getItems.apply(this, arguments);
       }
 
@@ -562,7 +581,7 @@ export var MediaStore = /*#__PURE__*/function () {
         }, _callee9, this);
       }));
 
-      function getImageMetadata(_x22, _x23) {
+      function getImageMetadata(_x21, _x22) {
         return _getImageMetadata.apply(this, arguments);
       }
 
@@ -599,7 +618,7 @@ export var MediaStore = /*#__PURE__*/function () {
         }, _callee10, this);
       }));
 
-      function appendChunksToUpload(_x24, _x25, _x26) {
+      function appendChunksToUpload(_x23, _x24, _x25) {
         return _appendChunksToUpload.apply(this, arguments);
       }
 
@@ -684,7 +703,7 @@ export var MediaStore = /*#__PURE__*/function () {
         }, _callee11, this);
       }));
 
-      function request(_x27) {
+      function request(_x26) {
         return _request2.apply(this, arguments);
       }
 

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

@@ -1,5 +1,5 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { MediaStoreError } from './error';
 import { rejectTimeout } from '../../utils/setTimeoutPromise';
 export var DEFAULT_AUTH_PROVIDER_TIMEOUT = 10000;

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

@@ -1,7 +1,7 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 export var StargateClient = /*#__PURE__*/function () {
   function StargateClient(baseUrl) {
     _classCallCheck(this, StargateClient);

package/dist/esm/constants.js

@@ -1,4 +1,8 @@
+import { DATA_UNIT } from './models/media';
 export var RECENTS_COLLECTION = 'recents';
 export var FILE_CACHE_MAX_AGE = 60 * 60 * 24 * 30; // Retain for 30 days
 
-export var MAX_RESOLUTION = 4096;
+export var MAX_RESOLUTION = 4096;
+export var CHUNK_SIZE = 4 * DATA_UNIT.MB;
+export var PROCESSING_BATCH_SIZE = 1000;
+export var MAX_UPLOAD_FILE_SIZE = 2 * DATA_UNIT.TB;

package/dist/esm/index.js

@@ -25,7 +25,7 @@ export { isFileIdentifier, isExternalImageIdentifier, isDifferentIdentifier } fr
 export { withMediaClient, getMediaClient } from './utils/with-media-client-hoc';
 export { globalMediaEventEmitter } from './globalMediaEventEmitter';
 export { isMediaBlobUrl, getAttrsFromUrl, addFileAttrsToUrl, objectToQueryString } from './utils/url';
-export { createMediaSubscribable } from './utils/toMediaSubscribable';
+export { createMediaSubscribable } from './utils/mediaSubscribable';
 export { RECENTS_COLLECTION, MAX_RESOLUTION } from './constants'; // TODO MEX-659 Remove these exports when all the usages from media-client are replaced with media-common.
 
 import { getMediaTypeFromMimeType as _getMediaTypeFromMimeType, isImageMimeTypeSupportedByBrowser as _isImageMimeTypeSupportedByBrowser, isDocumentMimeTypeSupportedByBrowser as _isDocumentMimeTypeSupportedByBrowser, isMimeTypeSupportedByBrowser as _isMimeTypeSupportedByBrowser, isImageMimeTypeSupportedByServer as _isImageMimeTypeSupportedByServer, isDocumentMimeTypeSupportedByServer as _isDocumentMimeTypeSupportedByServer, isAudioMimeTypeSupportedByServer as _isAudioMimeTypeSupportedByServer, isVideoMimeTypeSupportedByServer as _isVideoMimeTypeSupportedByServer, isUnknownMimeTypeSupportedByServer as _isUnknownMimeTypeSupportedByServer, isMimeTypeSupportedByServer as _isMimeTypeSupportedByServer } from '@atlaskit/media-common/mediaTypeUtils';

package/dist/esm/models/media.js

@@ -11,4 +11,11 @@ export var isPreviewableType = function isPreviewableType(type, featureFlags) {
 };
 export var isMediaCollectionItemFullDetails = function isMediaCollectionItemFullDetails(mediaCollectionItem) {
   return !!mediaCollectionItem['mediaType'] && !!mediaCollectionItem['mimeType'] && !!mediaCollectionItem['processingStatus'];
-};
+};
+export var DATA_UNIT;
+
+(function (DATA_UNIT) {
+  DATA_UNIT[DATA_UNIT["MB"] = 1048576] = "MB";
+  DATA_UNIT[DATA_UNIT["GB"] = 1073741824] = "GB";
+  DATA_UNIT[DATA_UNIT["TB"] = 1099511627776] = "TB";
+})(DATA_UNIT || (DATA_UNIT = {}));

package/dist/esm/uploader/calculateChunkSize.js

@@ -0,0 +1,32 @@
+import { DATA_UNIT } from '../models/media';
+import { MAX_UPLOAD_FILE_SIZE } from '../constants';
+export var fileSizeError = 'fileSizeExceedsLimit';
+/**
+ * This is a helper to dynamically calculate the chunk size for a given file size.
+ *
+ * @param fileSize The size of a file to calculate the chunk size for.
+ * @returns A number of bytes per chunk or Throws an Error if the file size exceeds 2TB
+ *
+ * @see {@link https://product-fabric.atlassian.net/wiki/spaces/FIL/pages/3221881143/Rule+of+thumb+for+chunk+sizes#Given-the-following-conditions}
+ *
+ */
+
+export var calculateChunkSize = function calculateChunkSize(fileSize) {
+  if (fileSize > MAX_UPLOAD_FILE_SIZE) {
+    throw new Error(fileSizeError);
+  }
+
+  if (fileSize <= 5 * DATA_UNIT.GB) {
+    return 5 * DATA_UNIT.MB;
+  }
+
+  if (fileSize > 5 * DATA_UNIT.GB && fileSize <= 50 * DATA_UNIT.GB) {
+    return 50 * DATA_UNIT.MB;
+  }
+
+  if (fileSize > 50 * DATA_UNIT.GB && fileSize <= 0.95 * DATA_UNIT.TB) {
+    return 100 * DATA_UNIT.MB;
+  }
+
+  return 210 * DATA_UNIT.MB;
+};

package/dist/esm/uploader/error.js

@@ -0,0 +1,51 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+import { BaseMediaClientError } from '../models/errors';
+export var UploaderError = /*#__PURE__*/function (_BaseMediaClientError) {
+  _inherits(UploaderError, _BaseMediaClientError);
+
+  var _super = _createSuper(UploaderError);
+
+  function UploaderError(reason, id, metadata) {
+    var _this;
+
+    _classCallCheck(this, UploaderError);
+
+    _this = _super.call(this, reason);
+    _this.reason = reason;
+    _this.id = id;
+    _this.metadata = metadata;
+    return _this;
+  }
+
+  _createClass(UploaderError, [{
+    key: "attributes",
+    get: function get() {
+      var reason = this.reason,
+          id = this.id,
+          _this$metadata = this.metadata;
+      _this$metadata = _this$metadata === void 0 ? {} : _this$metadata;
+      var collectionName = _this$metadata.collectionName,
+          occurrenceKey = _this$metadata.occurrenceKey;
+      return {
+        reason: reason,
+        id: id,
+        collectionName: collectionName,
+        occurrenceKey: occurrenceKey
+      };
+    }
+  }]);
+
+  return UploaderError;
+}(BaseMediaClientError);
+export function isUploaderError(err) {
+  return err instanceof UploaderError;
+}