@atlaskit/media-client 16.0.1 → 17.1.1

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

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.1",
+	"version": "17.1.1",
 	"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
+}

package/dist/types/uploader/calculateChunkSize.d.ts

@@ -0,0 +1,11 @@
+export declare const 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 declare const calculateChunkSize: (fileSize: number) => number;

package/dist/types/uploader/error.d.ts

@@ -0,0 +1,29 @@
+import { BaseMediaClientError } from '../models/errors';
+export declare type UploaderErrorReason = 'fileSizeExceedsLimit';
+export declare type UploaderErrorAttributes = {
+    readonly reason: UploaderErrorReason;
+    readonly id: string;
+    readonly metadata?: {
+        readonly collectionName?: string;
+        readonly occurrenceKey?: string;
+    };
+};
+export declare class UploaderError extends BaseMediaClientError<UploaderErrorAttributes> {
+    readonly reason: UploaderErrorReason;
+    readonly id: string;
+    readonly metadata?: {
+        readonly collectionName?: string | undefined;
+        readonly occurrenceKey?: string | undefined;
+    } | undefined;
+    constructor(reason: UploaderErrorReason, id: string, metadata?: {
+        readonly collectionName?: string | undefined;
+        readonly occurrenceKey?: string | undefined;
+    } | undefined);
+    get attributes(): {
+        reason: "fileSizeExceedsLimit";
+        id: string;
+        collectionName: string | undefined;
+        occurrenceKey: string | undefined;
+    };
+}
+export declare function isUploaderError(err: Error): err is UploaderError;

package/dist/types/{uploader.d.ts → uploader/index.d.ts}

@@ -1,5 +1,5 @@
 import { ChunkinatorFile } from '@atlaskit/chunkinator';
-import { MediaStore } from './client/media-store';
+import { MediaStore } from '../client/media-store';
 export declare type UploadableFile = {
     content: ChunkinatorFile;
     name?: string;
@@ -18,4 +18,4 @@ export declare type UploadFileCallbacks = {
 export interface UploadFileResult {
     cancel: () => void;
 }
-export declare const uploadFile: (file: UploadableFile, store: MediaStore, uploadableFileUpfrontIds: UploadableFileUpfrontIds, callbacks?: UploadFileCallbacks | undefined, chunkSize?: number, processingBatchSize?: number) => UploadFileResult;
+export declare const uploadFile: (file: UploadableFile, store: MediaStore, uploadableFileUpfrontIds: UploadableFileUpfrontIds, callbacks?: UploadFileCallbacks | undefined) => UploadFileResult;

package/dist/types/utils/mediaSubscribable/fromObservable.d.ts

@@ -0,0 +1,5 @@
+import { ReplaySubject } from 'rxjs/ReplaySubject';
+import { MediaSubscribableItem } from '../../models/media-subscribable';
+import { MediaSubscribable } from './types';
+export declare function fromObservable<T>(observable: ReplaySubject<T>): MediaSubscribable<T>;
+export declare function createMediaSubscribable<T extends MediaSubscribableItem>(mediaSubscribableItem?: T | Error): MediaSubscribable<T>;

package/dist/types/utils/mediaSubscribable/index.d.ts

@@ -0,0 +1,3 @@
+export type { MediaSubscribable, MediaObserver, MediaSubscription, } from './types';
+export { toPromise } from './toPromise';
+export { createMediaSubscribable, fromObservable } from './fromObservable';

package/dist/types/utils/{mediaSubscribableToPromise.d.ts → mediaSubscribable/toPromise.d.ts}

@@ -1,10 +1,10 @@
 import { Subscription } from 'rxjs/Subscription';
-import { MediaSubscribable } from './toMediaSubscribable';
-import { MediaSubscribableItem } from '../models/media-subscribable';
+import { MediaSubscribable } from './types';
+import { MediaSubscribableItem } from '../../models/media-subscribable';
 /**
  * This is a helper to transform the first value emitted by an MediaSubscribable into a Promise.
  *
  * @param mediaSubscribable a given MediaSubscribable<MediaSubscribableItem>
  * @param subscription a default Subscription (this parameter exists for testing purpose)
  */
-export declare const mediaSubscribableToPromise: <T extends MediaSubscribableItem>(mediaSubscribable: MediaSubscribable<T>, subscription?: Subscription) => Promise<T>;
+export declare const toPromise: <T extends MediaSubscribableItem>(mediaSubscribable: MediaSubscribable<T>, subscription?: Subscription) => Promise<T>;

package/dist/types/utils/mediaSubscribable/types.d.ts

@@ -0,0 +1,16 @@
+export declare type MediaSubscription = {
+    unsubscribe: () => void;
+};
+declare type PartialObserver<T> = {
+    next?: (value: T) => void;
+    error?: (err: any) => void;
+    complete?: () => void;
+};
+export declare type NextObserver<T> = PartialObserver<T> & Required<Pick<PartialObserver<T>, 'next'>>;
+export declare type ErrorObserver<T> = PartialObserver<T> & Required<Pick<PartialObserver<T>, 'error'>>;
+export declare type CompletionObserver<T> = PartialObserver<T> & Required<Pick<PartialObserver<T>, 'complete'>>;
+export declare type MediaObserver<T> = NextObserver<T> | ErrorObserver<T> | CompletionObserver<T> | ((value: T) => void);
+export declare type MediaSubscribable<T> = {
+    subscribe(observer?: MediaObserver<T>): MediaSubscription;
+};
+export {};

package/dist/types/utils/safeUnsubscribe.d.ts

@@ -1,2 +1,2 @@
-import { MediaSubscription } from './toMediaSubscribable';
+import { MediaSubscription } from './mediaSubscribable';
 export declare const safeUnsubscribe: (subscription: MediaSubscription) => void;