@atlaskit/media-client 16.0.1 → 17.1.1

package/dist/cjs/uploader/index.js

@@ -0,0 +1,318 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uploadFile = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _chunkinator = require("@atlaskit/chunkinator");
+
+var _from = require("rxjs/observable/from");
+
+var _concatMap = require("rxjs/operators/concatMap");
+
+var _hasherCreator = require("../utils/hashing/hasherCreator");
+
+var _error = require("./error");
+
+var _constants = require("../constants");
+
+var _calculateChunkSize = require("./calculateChunkSize");
+
+var _mediaCommon = require("@atlaskit/media-common");
+
+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) { (0, _defineProperty2.default)(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; }
+
+var hashingFunction = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(blob) {
+    var hasher;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return (0, _hasherCreator.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(chunks) {
+      var response, results;
+      return _regenerator.default.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.t0 = store;
+              _context2.t1 = hashedChunks(chunks);
+              _context2.t2 = collectionName;
+
+              if (!(0, _mediaCommon.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(chunk) {
+      var options;
+      return _regenerator.default.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              if (!(0, _mediaCommon.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(chunks) {
+      return _regenerator.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(file, store, uploadableFileUpfrontIds, uploadId) {
+    var collection, name, mimeType, id, occurrenceKey;
+    return _regenerator.default.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);
+  };
+}();
+
+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 = _constants.CHUNK_SIZE;
+
+  try {
+    if (content instanceof Blob && (0, _mediaCommon.getMediaFeatureFlag)('mediaUploadApiV2', store.featureFlags)) {
+      chunkSize = (0, _calculateChunkSize.calculateChunkSize)(content.size);
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message === _calculateChunkSize.fileSizeError) {
+      callbacks === null || callbacks === void 0 ? void 0 : callbacks.onUploadFinish(new _error.UploaderError(err.message, id, {
+        collectionName: collection,
+        occurrenceKey: occurrenceKey
+      }));
+    }
+
+    return {
+      cancel: function cancel() {
+        callbacks === null || callbacks === void 0 ? void 0 : callbacks.onUploadFinish('canceled');
+      }
+    };
+  }
+
+  var chunkinatorObservable = (0, _chunkinator.chunkinator)(content, {
+    hashingFunction: hashingFunction,
+    hashingConcurrency: 5,
+    probingBatchSize: 100,
+    chunkSize: chunkSize,
+    uploadingConcurrency: 3,
+    uploadingFunction: createUploadingFunction(store, deferredUploadId, collection),
+    probingFunction: createProbingFunction(store, deferredUploadId, collection),
+    processingBatchSize: _constants.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 = (0, _from.from)(deferredUploadId).pipe((0, _concatMap.concatMap)(function (uploadId) {
+    return chunkinatorObservable.pipe((0, _concatMap.concatMap)(function () {
+      return (0, _from.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');
+    }
+  };
+};
+
+exports.uploadFile = uploadFile;
+
+var hashedChunks = function hashedChunks(chunks) {
+  return chunks.map(function (chunk) {
+    return chunk.hash;
+  });
+};

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

@@ -4,11 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createMediaSubscribable = createMediaSubscribable;
-exports.toMediaSubscribable = toMediaSubscribable;
+exports.fromObservable = fromObservable;
 
-var _createMediaSubject = require("./createMediaSubject");
+var _createMediaSubject = require("../createMediaSubject");
 
-function toMediaSubscribable(observable) {
+function fromObservable(observable) {
   return {
     subscribe: function subscribe(observer) {
       var subscription = // This is needed to handle "subscribe" function overload.
@@ -24,5 +24,5 @@ function toMediaSubscribable(observable) {
 }
 
 function createMediaSubscribable(mediaSubscribableItem) {
-  return toMediaSubscribable((0, _createMediaSubject.createMediaSubject)(mediaSubscribableItem));
+  return fromObservable((0, _createMediaSubject.createMediaSubject)(mediaSubscribableItem));
 }

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createMediaSubscribable", {
+  enumerable: true,
+  get: function get() {
+    return _fromObservable.createMediaSubscribable;
+  }
+});
+Object.defineProperty(exports, "fromObservable", {
+  enumerable: true,
+  get: function get() {
+    return _fromObservable.fromObservable;
+  }
+});
+Object.defineProperty(exports, "toPromise", {
+  enumerable: true,
+  get: function get() {
+    return _toPromise.toPromise;
+  }
+});
+
+var _toPromise = require("./toPromise");
+
+var _fromObservable = require("./fromObservable");

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.mediaSubscribableToPromise = void 0;
+exports.toPromise = void 0;
 
 var _Subscription = require("rxjs/Subscription");
 
@@ -13,7 +13,7 @@ var _Subscription = require("rxjs/Subscription");
  * @param mediaSubscribable a given MediaSubscribable<MediaSubscribableItem>
  * @param subscription a default Subscription (this parameter exists for testing purpose)
  */
-var mediaSubscribableToPromise = function mediaSubscribableToPromise(mediaSubscribable) {
+var toPromise = function toPromise(mediaSubscribable) {
   var subscription = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _Subscription.Subscription();
   return new Promise(function (resolve, reject) {
     return subscription.add(mediaSubscribable.subscribe({
@@ -29,4 +29,4 @@ var mediaSubscribableToPromise = function mediaSubscribableToPromise(mediaSubscr
   });
 };
 
-exports.mediaSubscribableToPromise = mediaSubscribableToPromise;
+exports.toPromise = toPromise;

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

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/version.json

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

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

@@ -1,7 +1,7 @@
 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 const collectionCache = {};
 
 const createCacheEntry = () => ({
@@ -67,7 +67,7 @@ export class CollectionFetcher {
       collection.nextInclusiveStartKey = nextInclusiveStartKey;
       subject.next(collection.items);
     }).catch(error => subject.error(error));
-    return toMediaSubscribable(subject);
+    return fromObservable(subject);
   }
 
   async removeFile(id, collectionName, occurrenceKey) {

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

@@ -21,14 +21,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 class FileFetcherImpl {
   constructor(mediaStore) {
@@ -91,14 +90,14 @@ export class FileFetcherImpl {
         collectionName,
         occurrenceKey
       }));
-      return toMediaSubscribable(subject);
+      return fromObservable(subject);
     }
 
-    return toMediaSubscribable(getFileStreamsCache().getOrInsert(id, () => this.createDownloadFileStream(id, collectionName)));
+    return fromObservable(getFileStreamsCache().getOrInsert(id, () => this.createDownloadFileStream(id, collectionName)));
   }
 
   getCurrentState(id, options) {
-    return mediaSubscribableToPromise(this.getFileState(id, options));
+    return toPromise(this.getFileState(id, options));
   }
 
   getArtifactURL(artifacts, artifactName, collectionName) {
@@ -307,7 +306,7 @@ export class FileFetcherImpl {
       });
     }
 
-    return toMediaSubscribable(subject);
+    return fromObservable(subject);
   }
 
   async downloadBinary(id, name = 'download', collectionName) {

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

@@ -122,12 +122,20 @@ export class MediaStore {
     return this.request(`/upload`, options).then(createMapResponseToJson(metadata));
   }
 
-  async uploadChunk(etag, blob, collectionName) {
+  async uploadChunk(etag, blob, {
+    collectionName,
+    uploadId,
+    partNumber
+  } = {}) {
     const metadata = {
       method: 'PUT',
       endpoint: '/chunk/{etag}'
     };
     const options = { ...metadata,
+      params: {
+        uploadId,
+        partNumber
+      },
       authContext: {
         collectionName
       },
@@ -136,12 +144,18 @@ export class MediaStore {
     await this.request(`/chunk/${etag}`, options);
   }
 
-  probeChunks(chunks, collectionName) {
+  probeChunks(chunks, {
+    collectionName,
+    uploadId
+  } = {}) {
     const metadata = {
       method: 'POST',
       endpoint: '/chunk/probe'
     };
     const options = { ...metadata,
+      params: {
+        uploadId
+      },
       authContext: {
         collectionName
       },

package/dist/es2019/constants.js

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

package/dist/es2019/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/es2019/models/media.js

@@ -9,4 +9,11 @@ export const isPreviewableType = (type, featureFlags) => {
 
   return defaultPreviewableTypes.indexOf(type) > -1;
 };
-export const isMediaCollectionItemFullDetails = mediaCollectionItem => !!mediaCollectionItem['mediaType'] && !!mediaCollectionItem['mimeType'] && !!mediaCollectionItem['processingStatus'];
+export const isMediaCollectionItemFullDetails = mediaCollectionItem => !!mediaCollectionItem['mediaType'] && !!mediaCollectionItem['mimeType'] && !!mediaCollectionItem['processingStatus'];
+export let 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/es2019/uploader/calculateChunkSize.js

@@ -0,0 +1,32 @@
+import { DATA_UNIT } from '../models/media';
+import { MAX_UPLOAD_FILE_SIZE } from '../constants';
+export 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 const 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/es2019/uploader/error.js

@@ -0,0 +1,30 @@
+import { BaseMediaClientError } from '../models/errors';
+export class UploaderError extends BaseMediaClientError {
+  constructor(reason, id, metadata) {
+    super(reason);
+    this.reason = reason;
+    this.id = id;
+    this.metadata = metadata;
+  }
+
+  get attributes() {
+    const {
+      reason,
+      id,
+      metadata: {
+        collectionName,
+        occurrenceKey
+      } = {}
+    } = this;
+    return {
+      reason,
+      id,
+      collectionName,
+      occurrenceKey
+    };
+  }
+
+}
+export function isUploaderError(err) {
+  return err instanceof UploaderError;
+}