@atlaskit/media-client 16.0.0 → 17.1.0

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;
+}

package/dist/esm/uploader/index.js

@@ -0,0 +1,298 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+
+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; }
+
+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 { chunkinator } from '@atlaskit/chunkinator';
+import { from } from 'rxjs/observable/from';
+import { concatMap } from 'rxjs/operators/concatMap';
+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
+
+var hashingFunction = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(blob) {
+    var hasher;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return createHasher();
+
+          case 2:
+            hasher = _context.sent;
+            return _context.abrupt("return", hasher.hash(blob));
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function hashingFunction(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var createProbingFunction = function createProbingFunction(store, deferredUploadId, collectionName) {
+  return /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(chunks) {
+      var response, results;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.t0 = store;
+              _context2.t1 = hashedChunks(chunks);
+              _context2.t2 = collectionName;
+
+              if (!getMediaFeatureFlag('mediaUploadApiV2', store.featureFlags)) {
+                _context2.next = 9;
+                break;
+              }
+
+              _context2.next = 6;
+              return deferredUploadId;
+
+            case 6:
+              _context2.t3 = _context2.sent;
+              _context2.next = 10;
+              break;
+
+            case 9:
+              _context2.t3 = undefined;
+
+            case 10:
+              _context2.t4 = _context2.t3;
+              _context2.t5 = {
+                collectionName: _context2.t2,
+                uploadId: _context2.t4
+              };
+              _context2.next = 14;
+              return _context2.t0.probeChunks.call(_context2.t0, _context2.t1, _context2.t5);
+
+            case 14:
+              response = _context2.sent;
+              results = response.data.results;
+              return _context2.abrupt("return", Object.values(results).map(function (result) {
+                return result.exists;
+              }));
+
+            case 17:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function (_x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+};
+
+var createUploadingFunction = function createUploadingFunction(store, deferredUploadId, collectionName) {
+  return /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(chunk) {
+      var options;
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              if (!getMediaFeatureFlag('mediaUploadApiV2', store.featureFlags)) {
+                _context3.next = 8;
+                break;
+              }
+
+              _context3.t1 = chunk.partNumber;
+              _context3.next = 4;
+              return deferredUploadId;
+
+            case 4:
+              _context3.t2 = _context3.sent;
+              _context3.t0 = {
+                partNumber: _context3.t1,
+                uploadId: _context3.t2
+              };
+              _context3.next = 9;
+              break;
+
+            case 8:
+              _context3.t0 = {};
+
+            case 9:
+              options = _context3.t0;
+              _context3.next = 12;
+              return store.uploadChunk(chunk.hash, chunk.blob, _objectSpread({
+                collectionName: collectionName
+              }, options));
+
+            case 12:
+              return _context3.abrupt("return", _context3.sent);
+
+            case 13:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }));
+
+    return function (_x3) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+};
+
+var createProcessingFunction = function createProcessingFunction(store, deferredUploadId, collection) {
+  var offset = 0;
+  return /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(chunks) {
+      return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.t0 = store;
+              _context4.next = 3;
+              return deferredUploadId;
+
+            case 3:
+              _context4.t1 = _context4.sent;
+              _context4.t2 = {
+                chunks: hashedChunks(chunks),
+                offset: offset
+              };
+              _context4.t3 = collection;
+              _context4.next = 8;
+              return _context4.t0.appendChunksToUpload.call(_context4.t0, _context4.t1, _context4.t2, _context4.t3);
+
+            case 8:
+              offset += chunks.length;
+
+            case 9:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    }));
+
+    return function (_x4) {
+      return _ref4.apply(this, arguments);
+    };
+  }();
+};
+
+var createFileFromUpload = /*#__PURE__*/function () {
+  var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(file, store, uploadableFileUpfrontIds, uploadId) {
+    var collection, name, mimeType, id, occurrenceKey;
+    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            collection = file.collection, name = file.name, mimeType = file.mimeType;
+            id = uploadableFileUpfrontIds.id, occurrenceKey = uploadableFileUpfrontIds.occurrenceKey;
+            return _context5.abrupt("return", store.createFileFromUpload({
+              uploadId: uploadId,
+              name: name,
+              mimeType: mimeType
+            }, {
+              occurrenceKey: occurrenceKey,
+              collection: collection,
+              replaceFileId: id
+            }));
+
+          case 3:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+
+  return function createFileFromUpload(_x5, _x6, _x7, _x8) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+
+export var uploadFile = function uploadFile(file, store, uploadableFileUpfrontIds, callbacks) {
+  var content = file.content,
+      collection = file.collection;
+  var deferredUploadId = uploadableFileUpfrontIds.deferredUploadId,
+      id = uploadableFileUpfrontIds.id,
+      occurrenceKey = uploadableFileUpfrontIds.occurrenceKey;
+  var 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: function cancel() {
+        callbacks === null || callbacks === void 0 ? void 0 : callbacks.onUploadFinish('canceled');
+      }
+    };
+  }
+
+  var chunkinatorObservable = chunkinator(content, {
+    hashingFunction: hashingFunction,
+    hashingConcurrency: 5,
+    probingBatchSize: 100,
+    chunkSize: chunkSize,
+    uploadingConcurrency: 3,
+    uploadingFunction: createUploadingFunction(store, deferredUploadId, collection),
+    probingFunction: createProbingFunction(store, deferredUploadId, collection),
+    processingBatchSize: PROCESSING_BATCH_SIZE,
+    processingFunction: createProcessingFunction(store, deferredUploadId, collection)
+  }, {
+    onProgress: function onProgress(progress) {
+      if (callbacks) {
+        callbacks.onProgress(progress);
+      }
+    }
+  });
+
+  var onUploadFinish = callbacks && callbacks.onUploadFinish || function () {};
+
+  var subscription = from(deferredUploadId).pipe(concatMap(function (uploadId) {
+    return chunkinatorObservable.pipe(concatMap(function () {
+      return from(createFileFromUpload(file, store, uploadableFileUpfrontIds, uploadId));
+    }));
+  })).subscribe({
+    error: function error(err) {
+      return onUploadFinish(err);
+    },
+    complete: function complete() {
+      return onUploadFinish();
+    }
+  });
+  return {
+    cancel: function cancel() {
+      subscription.unsubscribe();
+      onUploadFinish('canceled');
+    }
+  };
+};
+
+var hashedChunks = function hashedChunks(chunks) {
+  return chunks.map(function (chunk) {
+    return chunk.hash;
+  });
+};

package/dist/esm/utils/createFileDataLoader.js

@@ -1,6 +1,6 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 // import setimmediate to temporary fix dataloader 2.0.0 bug
 // @see https://github.com/graphql/dataloader/issues/249
 import 'setimmediate';

package/dist/esm/utils/getDimensionsFromBlob.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 { getImageDimensionsFromBlob } from './getImageDimensionsFromBlob';
 import { getVideoDimensionsFromBlob } from './getVideoDimensionsFromBlob';
 export var getDimensionsFromBlob = /*#__PURE__*/function () {

package/dist/esm/utils/getVideoDimensionsFromBlob.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 VideoSnapshot from 'video-snapshot';
 export var getVideoDimensionsFromBlob = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(blob) {

package/dist/esm/utils/hashing/hasherCreator.js

@@ -1,5 +1,5 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 var hasher = null;
 export var destroyHasher = function destroyHasher() {
   return hasher = null;

package/dist/esm/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: function subscribe(observer) {
       var 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/esm/utils/mediaSubscribable/index.js

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

package/dist/esm/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 var mediaSubscribableToPromise = function mediaSubscribableToPromise(mediaSubscribable) {
+export var toPromise = function toPromise(mediaSubscribable) {
   var subscription = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Subscription();
   return new Promise(function (resolve, reject) {
     return subscription.add(mediaSubscribable.subscribe({

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

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

package/dist/esm/utils/mobileUpload/helpers.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 { ReplaySubject } from 'rxjs/ReplaySubject';
 import { from } from 'rxjs/observable/from';
 import { map } from 'rxjs/operators/map';

package/dist/esm/utils/mobileUpload/stateMachine/index.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 { map } from 'rxjs/operators/map';
 import { createMachine, interpret } from 'xstate';
 import { isProcessingFileState } from '../../../models/file-state';

package/dist/esm/utils/polling/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; }
 

package/dist/esm/utils/request/errors.js

@@ -34,6 +34,8 @@ export var RequestError = /*#__PURE__*/function (_BaseMediaClientError) {
       _this$metadata = _this$metadata === void 0 ? {} : _this$metadata;
       var method = _this$metadata.method,
           endpoint = _this$metadata.endpoint,
+          mediaRegion = _this$metadata.mediaRegion,
+          mediaEnv = _this$metadata.mediaEnv,
           attempts = _this$metadata.attempts,
           clientExhaustedRetries = _this$metadata.clientExhaustedRetries,
           statusCode = _this$metadata.statusCode,
@@ -42,6 +44,8 @@ export var RequestError = /*#__PURE__*/function (_BaseMediaClientError) {
         reason: reason,
         method: method,
         endpoint: endpoint,
+        mediaRegion: mediaRegion,
+        mediaEnv: mediaEnv,
         attempts: attempts,
         clientExhaustedRetries: clientExhaustedRetries,
         statusCode: statusCode,

package/dist/esm/utils/request/helpers.js

@@ -1,8 +1,8 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 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; }
 
@@ -182,7 +182,7 @@ export function createMapResponseToJson(metadata) {
             case 6:
               _context.prev = 6;
               _context.t0 = _context["catch"](0);
-              throw new RequestError('serverInvalidBody', _objectSpread(_objectSpread({}, metadata), {}, {
+              throw new RequestError('serverInvalidBody', _objectSpread(_objectSpread(_objectSpread({}, metadata), extractMediaHeaders(response)), {}, {
                 statusCode: response.status
               }), _context.t0);
 
@@ -216,7 +216,7 @@ export function createMapResponseToBlob(metadata) {
             case 6:
               _context2.prev = 6;
               _context2.t0 = _context2["catch"](0);
-              throw new RequestError('serverInvalidBody', _objectSpread(_objectSpread({}, metadata), {}, {
+              throw new RequestError('serverInvalidBody', _objectSpread(_objectSpread(_objectSpread({}, metadata), extractMediaHeaders(response)), {}, {
                 statusCode: response.status
               }), _context2.t0);
 
@@ -397,7 +397,7 @@ export function createRequestErrorReason(statusCode) {
 export function createRequestErrorFromResponse(metadata, response) {
   var statusCode = response.status;
   var reason = createRequestErrorReason(statusCode);
-  return new RequestError(reason, _objectSpread(_objectSpread({}, metadata), {}, {
+  return new RequestError(reason, _objectSpread(_objectSpread(_objectSpread({}, metadata), extractMediaHeaders(response)), {}, {
     statusCode: statusCode
   }));
 }
@@ -410,4 +410,13 @@ export function createProcessFetchResponse(metadata) {
     var requestError = createRequestErrorFromResponse(metadata, response);
     throw requestError;
   };
+}
+export function extractMediaHeaders(response) {
+  var headers = response.headers;
+  var mediaRegion = headers.get('x-media-region') || 'unknown';
+  var mediaEnv = headers.get('x-media-env') || 'unknown';
+  return {
+    mediaRegion: mediaRegion,
+    mediaEnv: mediaEnv
+  };
 }

package/dist/esm/utils/request/index.js

@@ -1,5 +1,5 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 export { RequestError, isRequestError } from './errors';
 export { isRateLimitedError } from './helpers';
 import { createUrl, fetchRetry, createProcessFetchResponse, withAuth } from './helpers';

package/dist/esm/utils/shouldFetchRemoteFileStates.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 { from } from 'rxjs/observable/from';
 import { isMimeTypeSupportedByBrowser, isMimeTypeSupportedByServer } from '@atlaskit/media-common/mediaTypeUtils';
 import { getVideoDimensionsFromBlob } from './getVideoDimensionsFromBlob';

package/dist/esm/version.json

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

package/dist/types/client/collection-fetcher.d.ts

@@ -2,7 +2,7 @@ import { ReplaySubject } from 'rxjs/ReplaySubject';
 import { FileDetails, FileItem } from '../models/item';
 import { MediaCollectionItem } from '../models/media';
 import { MediaStore, MediaStoreGetCollectionItemsParams } from './media-store';
-import { MediaSubscribable } from '../utils/toMediaSubscribable';
+import { MediaSubscribable } from '../utils/mediaSubscribable';
 export interface MediaCollectionFileItemDetails extends FileDetails {
     occurrenceKey: string;
 }

package/dist/types/client/file-fetcher/index.d.ts

@@ -6,8 +6,8 @@ import { MediaFile } from '../../models/media';
 import { UploadableFile, UploadableFileUpfrontIds } from '../../uploader';
 import { MediaFileArtifacts } from '../../models/artifacts';
 import { UploadController } from '../../upload-controller';
+import { MediaSubscribable } from '../../utils/mediaSubscribable';
 import { Dimensions } from '../../utils/getDimensionsFromBlob';
-import { MediaSubscribable } from '../../utils/toMediaSubscribable';
 export type { FileFetcherErrorAttributes, FileFetcherErrorReason, } from './error';
 export { isFileFetcherError, FileFetcherError } from './error';
 export interface CopySourceFile {

package/dist/types/client/media-store/index.d.ts

@@ -12,8 +12,15 @@ export declare class MediaStore {
     getCollectionItems(collectionName: string, params?: MediaStoreGetCollectionItemsParams): Promise<MediaStoreResponse<MediaCollectionItems>>;
     removeCollectionFile(id: string, collectionName: string, occurrenceKey?: string): Promise<void>;
     createUpload(createUpTo?: number, collectionName?: string): Promise<MediaStoreResponse<MediaUpload[]>>;
-    uploadChunk(etag: string, blob: Blob, collectionName?: string): Promise<void>;
-    probeChunks(chunks: string[], collectionName?: string): Promise<MediaStoreResponse<MediaChunksProbe>>;
+    uploadChunk(etag: string, blob: Blob, { collectionName, uploadId, partNumber, }?: {
+        collectionName?: string;
+        uploadId?: string;
+        partNumber?: number;
+    }): Promise<void>;
+    probeChunks(chunks: string[], { collectionName, uploadId, }?: {
+        collectionName?: string;
+        uploadId?: string;
+    }): Promise<MediaStoreResponse<MediaChunksProbe>>;
     createFileFromUpload(body: MediaStoreCreateFileFromUploadBody, params?: MediaStoreCreateFileFromUploadParams): Promise<MediaStoreResponse<MediaFile>>;
     touchFiles(body: MediaStoreTouchFileBody, params?: MediaStoreTouchFileParams): Promise<MediaStoreResponse<TouchedFiles>>;
     getFile(fileId: string, params?: MediaStoreGetFileParams): Promise<MediaStoreResponse<MediaFile>>;

package/dist/types/constants.d.ts

@@ -1,3 +1,6 @@
 export declare const RECENTS_COLLECTION = "recents";
 export declare const FILE_CACHE_MAX_AGE: number;
 export declare const MAX_RESOLUTION = 4096;
+export declare const CHUNK_SIZE: number;
+export declare const PROCESSING_BATCH_SIZE = 1000;
+export declare const MAX_UPLOAD_FILE_SIZE: number;

package/dist/types/index.d.ts

@@ -45,8 +45,8 @@ export type { WithMediaClientConfig, WithMediaClientConfigProps, WithMediaClient
 export { globalMediaEventEmitter } from './globalMediaEventEmitter';
 export { isMediaBlobUrl, getAttrsFromUrl, addFileAttrsToUrl, objectToQueryString, } from './utils/url';
 export type { MediaBlobUrlAttrs } from './utils/url';
-export { createMediaSubscribable } from './utils/toMediaSubscribable';
-export type { MediaSubscribable, MediaSubscription, MediaObserver, } from './utils/toMediaSubscribable';
+export { createMediaSubscribable } from './utils/mediaSubscribable';
+export type { MediaSubscribable, MediaSubscription, MediaObserver, } from './utils/mediaSubscribable';
 export { RECENTS_COLLECTION, MAX_RESOLUTION } from './constants';
 /**
  * @deprecated This export will be removed. Please use one from @atlaskit/media-common or @atlaskit/media-common/mediaTypeUtils

package/dist/types/models/errors/types.d.ts

@@ -1,4 +1,4 @@
-export declare type MediaClientErrorReason = 'clientOffline' | 'clientAbortedRequest' | 'clientTimeoutRequest' | 'serverInvalidBody' | 'serverBadRequest' | 'serverUnauthorized' | 'serverForbidden' | 'serverNotFound' | 'serverRateLimited' | 'serverInternalError' | 'serverBadGateway' | 'serverUnexpectedError' | 'failedAuthProvider' | 'tokenExpired' | 'missingInitialAuth' | 'emptyAuth' | 'authProviderTimedOut' | 'invalidFileId' | 'emptyItems' | 'zeroVersionFile' | 'pollingMaxAttemptsExceeded';
+export declare type MediaClientErrorReason = 'clientOffline' | 'clientAbortedRequest' | 'clientTimeoutRequest' | 'serverInvalidBody' | 'serverBadRequest' | 'serverUnauthorized' | 'serverForbidden' | 'serverNotFound' | 'serverRateLimited' | 'serverInternalError' | 'serverBadGateway' | 'serverUnexpectedError' | 'failedAuthProvider' | 'tokenExpired' | 'missingInitialAuth' | 'emptyAuth' | 'authProviderTimedOut' | 'invalidFileId' | 'emptyItems' | 'zeroVersionFile' | 'pollingMaxAttemptsExceeded' | 'fileSizeExceedsLimit';
 export interface MediaClientErrorAttributes {
     reason: MediaClientErrorReason;
 }

package/dist/types/models/media.d.ts

@@ -59,3 +59,8 @@ export declare type MediaChunksProbe = {
         };
     };
 };
+export declare enum DATA_UNIT {
+    MB = 1048576,
+    GB = 1073741824,
+    TB = 1099511627776
+}