@atlaskit/media-card 70.9.0 → 72.0.0

package/dist/esm/root/card/getCardPreview/helpers.js

@@ -0,0 +1,194 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import { takeSnapshot } from '../../../utils/videoSnapshot';
+import { getMediaTypeFromMimeType } from '@atlaskit/media-common';
+import { getOrientation } from '@atlaskit/media-ui';
+import { LocalPreviewError, RemotePreviewError } from '../../../errors';
+
+/**
+ * This method tells the support for the media
+ * types covered in getCardPreviewFromFilePreview
+ */
+export var isSupportedLocalPreview = function isSupportedLocalPreview(mediaType) {
+  return mediaType === 'image' || mediaType === 'video';
+};
+
+var getImageLocalPreview = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(value) {
+    var orientation, dataURI;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 3;
+            return getOrientation(value);
+
+          case 3:
+            orientation = _context.sent;
+            dataURI = URL.createObjectURL(value);
+            return _context.abrupt("return", {
+              dataURI: dataURI,
+              orientation: orientation,
+              source: 'local'
+            });
+
+          case 8:
+            _context.prev = 8;
+            _context.t0 = _context["catch"](0);
+            throw new LocalPreviewError('local-preview-image', _context.t0);
+
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[0, 8]]);
+  }));
+
+  return function getImageLocalPreview(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var getVideoLocalPreview = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(value) {
+    var dataURI;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.prev = 0;
+            _context2.next = 3;
+            return takeSnapshot(value);
+
+          case 3:
+            dataURI = _context2.sent;
+            return _context2.abrupt("return", {
+              dataURI: dataURI,
+              orientation: 1,
+              source: 'local'
+            });
+
+          case 7:
+            _context2.prev = 7;
+            _context2.t0 = _context2["catch"](0);
+            throw new LocalPreviewError('local-preview-video', _context2.t0);
+
+          case 10:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[0, 7]]);
+  }));
+
+  return function getVideoLocalPreview(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+export var getCardPreviewFromFilePreview = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(filePreview) {
+    var value, resolvedFilePreview, _value, type, mediaType;
+
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            _context3.next = 3;
+            return filePreview;
+
+          case 3:
+            resolvedFilePreview = _context3.sent;
+            value = resolvedFilePreview.value;
+            _context3.next = 10;
+            break;
+
+          case 7:
+            _context3.prev = 7;
+            _context3.t0 = _context3["catch"](0);
+            throw new LocalPreviewError('local-preview-rejected', _context3.t0);
+
+          case 10:
+            if (!(typeof value === 'string')) {
+              _context3.next = 14;
+              break;
+            }
+
+            return _context3.abrupt("return", {
+              dataURI: value,
+              orientation: 1,
+              source: 'local'
+            });
+
+          case 14:
+            if (!(value instanceof Blob)) {
+              _context3.next = 22;
+              break;
+            }
+
+            _value = value, type = _value.type;
+            mediaType = getMediaTypeFromMimeType(type);
+            _context3.t1 = mediaType;
+            _context3.next = _context3.t1 === 'image' ? 20 : _context3.t1 === 'video' ? 21 : 22;
+            break;
+
+          case 20:
+            return _context3.abrupt("return", getImageLocalPreview(value));
+
+          case 21:
+            return _context3.abrupt("return", getVideoLocalPreview(value));
+
+          case 22:
+            throw new LocalPreviewError('local-preview-unsupported');
+
+          case 23:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[0, 7]]);
+  }));
+
+  return function getCardPreviewFromFilePreview(_x3) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+export var getCardPreviewFromBackend = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(mediaClient, id, params) {
+    var blob;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.prev = 0;
+            _context4.next = 3;
+            return mediaClient.getImage(id, params);
+
+          case 3:
+            blob = _context4.sent;
+            return _context4.abrupt("return", {
+              dataURI: URL.createObjectURL(blob),
+              orientation: 1,
+              source: 'remote'
+            });
+
+          case 7:
+            _context4.prev = 7;
+            _context4.t0 = _context4["catch"](0);
+            throw new RemotePreviewError('remote-preview-fetch', _context4.t0);
+
+          case 10:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[0, 7]]);
+  }));
+
+  return function getCardPreviewFromBackend(_x4, _x5, _x6) {
+    return _ref4.apply(this, arguments);
+  };
+}();

package/dist/esm/root/card/getCardPreview/index.js

@@ -0,0 +1,174 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { isPreviewableFileState, addFileAttrsToUrl } from '@atlaskit/media-client';
+import { isMimeTypeSupportedByBrowser } from '@atlaskit/media-common';
+import cardPreviewCache from './cache';
+import { getCardPreviewFromFilePreview, getCardPreviewFromBackend } from './helpers';
+import { MediaCardError, isUnsupportedLocalPreviewError } from '../../../errors';
+import { isBigger } from '../../../utils/dimensionComparer';
+import { extractFilePreviewStatus, isPreviewableStatus } from './filePreviewStatus';
+export { getCardPreviewFromFilePreview, getCardPreviewFromBackend, isSupportedLocalPreview } from './helpers';
+export { extractFilePreviewStatus } from './filePreviewStatus';
+export var getCardPreviewFromCache = cardPreviewCache.get;
+export var removeCardPreviewFromCache = cardPreviewCache.remove;
+/**
+ * Will return the preview if available and supported by the browser
+ * See extractFilePreviewStatus "hasLocalPreview" logic
+ */
+
+export var getFilePreviewFromFileState = function getFilePreviewFromFileState(fileState) {
+  return 'mimeType' in fileState && isMimeTypeSupportedByBrowser(fileState.mimeType) && isPreviewableFileState(fileState) ? fileState.preview : undefined;
+};
+
+var extendAndCachePreview = function extendAndCachePreview(id, dimensions, preview, mediaBlobUrlAttrs) {
+  var source;
+
+  switch (preview.source) {
+    case 'local':
+      source = 'cache-local';
+      break;
+
+    case 'remote':
+      source = 'cache-remote';
+      break;
+
+    default:
+      source = preview.source;
+  } // We want to embed some meta context into dataURI for Copy/Paste to work.
+
+
+  var dataURI = mediaBlobUrlAttrs ? addFileAttrsToUrl(preview.dataURI, mediaBlobUrlAttrs) : preview.dataURI; // We store new cardPreview into cache
+
+  cardPreviewCache.set(id, dimensions, _objectSpread(_objectSpread({}, preview), {}, {
+    source: source,
+    dataURI: dataURI
+  }));
+  return _objectSpread(_objectSpread({}, preview), {}, {
+    dataURI: dataURI
+  });
+};
+/**
+ * This function will try to return a Card preview, either from cache, local preview or remote preview.
+ * It should only be called if there is a chance to get either a remote or a local preview, or both.
+ * This, in order to ensure there is always going to be a valid return value OR throw an error if the process fails.
+ * It is worth noting that local preview failures break the process if there is no remote preview available.
+ * In that case we throw an error immediately.
+ * Otherwise, if the local preview fails but there is a remote preview available, the failure does not break the process.
+ * In that case, we still want to report the local preview error to the caller, for feature realiability track.
+ * hence the use of the optional callback onLocalPreviewError
+ */
+
+
+export var getCardPreview = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+    var mediaClient, id, _ref$dimensions, dimensions, filePreview, onLocalPreviewError, isRemotePreviewReady, imageUrlParams, mediaBlobUrlAttrs, cachedPreview, localPreview, remotePreview;
+
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            mediaClient = _ref.mediaClient, id = _ref.id, _ref$dimensions = _ref.dimensions, dimensions = _ref$dimensions === void 0 ? {} : _ref$dimensions, filePreview = _ref.filePreview, onLocalPreviewError = _ref.onLocalPreviewError, isRemotePreviewReady = _ref.isRemotePreviewReady, imageUrlParams = _ref.imageUrlParams, mediaBlobUrlAttrs = _ref.mediaBlobUrlAttrs;
+            cachedPreview = cardPreviewCache.get(id, dimensions);
+
+            if (!cachedPreview) {
+              _context.next = 4;
+              break;
+            }
+
+            return _context.abrupt("return", cachedPreview);
+
+          case 4:
+            _context.prev = 4;
+
+            if (!filePreview) {
+              _context.next = 10;
+              break;
+            }
+
+            _context.next = 8;
+            return getCardPreviewFromFilePreview(filePreview);
+
+          case 8:
+            localPreview = _context.sent;
+            return _context.abrupt("return", extendAndCachePreview(id, dimensions, localPreview, mediaBlobUrlAttrs));
+
+          case 10:
+            _context.next = 17;
+            break;
+
+          case 12:
+            _context.prev = 12;
+            _context.t0 = _context["catch"](4);
+
+            /**
+             * We report the error if:
+             * - local preview is supported and fails
+             * - local preview is unsupported and remote preview is NOT READY
+             *   i.e. the function was called for "no reason".
+             * We DON'T report the error if:
+             * - local preview is unsupported and remote preview IS READY
+             *   i.e. local preview is available and not supported,
+             *   but we are after the remote preview instead.
+             */
+            if (!isUnsupportedLocalPreviewError(_context.t0) || isUnsupportedLocalPreviewError(_context.t0) && !isRemotePreviewReady) {
+              onLocalPreviewError && onLocalPreviewError(_context.t0);
+            }
+            /**
+             * No matter the reason why the local preview failed, we break the process
+             * if there is no remote preview available
+             */
+
+
+            if (isRemotePreviewReady) {
+              _context.next = 17;
+              break;
+            }
+
+            throw _context.t0;
+
+          case 17:
+            if (isRemotePreviewReady) {
+              _context.next = 19;
+              break;
+            }
+
+            throw new MediaCardError('remote-preview-not-ready');
+
+          case 19:
+            _context.next = 21;
+            return getCardPreviewFromBackend(mediaClient, id, imageUrlParams);
+
+          case 21:
+            remotePreview = _context.sent;
+            return _context.abrupt("return", extendAndCachePreview(id, dimensions, remotePreview, mediaBlobUrlAttrs));
+
+          case 23:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[4, 12]]);
+  }));
+
+  return function getCardPreview(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+export var shouldResolvePreview = function shouldResolvePreview(_ref3) {
+  var status = _ref3.status,
+      fileState = _ref3.fileState,
+      dimensions = _ref3.dimensions,
+      prevDimensions = _ref3.prevDimensions,
+      hasCardPreview = _ref3.hasCardPreview,
+      isBannedLocalPreview = _ref3.isBannedLocalPreview,
+      featureFlags = _ref3.featureFlags;
+  var statusIsPreviewable = isPreviewableStatus(status, extractFilePreviewStatus(fileState, isBannedLocalPreview, featureFlags));
+  var dimensionsAreBigger = isBigger(prevDimensions, dimensions);
+  return statusIsPreviewable && (!hasCardPreview || dimensionsAreBigger);
+};

package/dist/esm/root/card/getCardStatus.js

@@ -1,17 +1,10 @@
-import { isPreviewableType, isPreviewableFileState } from '@atlaskit/media-client';
-export var extractCardStatusParams = function extractCardStatusParams(fileState, featureFlags) {
-  return {
-    // TODO: align these checks with helpers from Media Client
-    // https://product-fabric.atlassian.net/browse/BMPT-1300
-    isPreviewableType: 'mediaType' in fileState && !!fileState.mediaType && isPreviewableType(fileState.mediaType, featureFlags),
-    hasFilesize: 'size' in fileState && !!fileState.size,
-    isPreviewableFileState: isPreviewableFileState(fileState)
-  };
+export var isFinalCardStatus = function isFinalCardStatus(status) {
+  return ['complete', 'error', 'failed-processing'].includes(status);
 };
 export var getCardStatus = function getCardStatus(fileStatus, _ref) {
-  var isPreviewableType = _ref.isPreviewableType,
-      hasFilesize = _ref.hasFilesize,
-      isPreviewableFileState = _ref.isPreviewableFileState;
+  var hasFilesize = _ref.hasFilesize,
+      isPreviewable = _ref.isPreviewable,
+      hasPreview = _ref.hasPreview;
 
   switch (fileStatus) {
     case 'uploading':
@@ -21,24 +14,27 @@ export var getCardStatus = function getCardStatus(fileStatus, _ref) {
 
     case 'processing':
       // Legacy empty files logic
-      // isPreviewableType will most likely be false for empty files,
+      // isPreviewable will most likely be false for empty files,
       // therefore we need to do this cut before that check.
       // TODO: https://product-fabric.atlassian.net/browse/BMPT-1247
       if (!hasFilesize) {
         return 'processing';
       } // If we show no preview for this file
-      // we won't show the "creating preview" message
-      // i.e. Card is "complete".
+      // we won't show the "creating preview" message, i.e. Card is "complete".
 
 
-      if (!isPreviewableType || isPreviewableFileState) {
+      if (!isPreviewable) {
         return 'complete';
       }
 
       return 'processing';
 
     case 'processed':
-      return 'complete';
+      if (!isPreviewable || !hasPreview) {
+        return 'complete';
+      }
+
+      return 'loading-preview';
 
     default:
       return 'loading';