@atlaskit/media-card 70.10.0 → 72.1.0

package/dist/esm/files/cardImageView/index.js

@@ -20,19 +20,17 @@ import { CardLoading } from '../../utils/lightCards/cardLoading';
 import { shouldDisplayImageThumbnail } from '../../utils/shouldDisplayImageThumbnail';
 import { ProgressBar } from '../../utils/progressBar';
 import CardActions from '../../utils/cardActions';
-import { withAnalyticsEvents } from '@atlaskit/analytics-next';
-import { fireMediaCardEvent, RenderEventAction, getRenderSucceededEventPayload, getRenderFailedFileUriPayload, getRenderFailedExternalUriPayload } from '../../utils/analytics';
-import { withFileAttributes } from '../../utils/fileAttributesContext';
 export var fileCardImageViewSelector = 'media-file-card-view';
-export var FileCardImageViewBase = /*#__PURE__*/function (_Component) {
-  _inherits(FileCardImageViewBase, _Component);
+export var fileCardImageViewSelectedSelector = 'media-file-card-view-selected';
+export var FileCardImageView = /*#__PURE__*/function (_Component) {
+  _inherits(FileCardImageView, _Component);
 
-  var _super = _createSuper(FileCardImageViewBase);
+  var _super = _createSuper(FileCardImageView);
 
-  function FileCardImageViewBase() {
+  function FileCardImageView() {
     var _this;
 
-    _classCallCheck(this, FileCardImageViewBase);
+    _classCallCheck(this, FileCardImageView);
 
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
@@ -56,7 +54,7 @@ export var FileCardImageViewBase = /*#__PURE__*/function (_Component) {
       // immediately, even if there's no image preview
 
 
-      var isZeroSize = fileSize === '' && status === 'processing';
+      var isZeroSize = fileSize === '' && ['processing', 'loading-preview'].includes(status);
 
       if (mediaType !== 'video' && !_this.isFileCardImageReadyForDisplay && !isZeroSize) {
         return _this.renderLoadingContents();
@@ -158,42 +156,18 @@ export var FileCardImageViewBase = /*#__PURE__*/function (_Component) {
       })));
     });
 
-    _defineProperty(_assertThisInitialized(_this), "onImageLoad", function () {
-      var _this$props6 = _this.props,
-          createAnalyticsEvent = _this$props6.createAnalyticsEvent,
-          fileAttributes = _this$props6.fileAttributes;
-
-      if (fileAttributes && _this.shouldFireEvent(RenderEventAction.SUCCEEDED)) {
-        fireMediaCardEvent(getRenderSucceededEventPayload(fileAttributes), createAnalyticsEvent);
-      }
-    });
-
-    _defineProperty(_assertThisInitialized(_this), "onImageError", function () {
-      var fileAttributes = _this.props.fileAttributes;
-
-      if (fileAttributes && _this.shouldFireEvent(RenderEventAction.FAILED)) {
-        var _this$props7 = _this.props,
-            createAnalyticsEvent = _this$props7.createAnalyticsEvent,
-            mediaItemType = _this$props7.mediaItemType;
-
-        if (mediaItemType === 'file') {
-          fireMediaCardEvent(getRenderFailedFileUriPayload(fileAttributes), createAnalyticsEvent);
-        } else if (mediaItemType === 'external-image') {
-          fireMediaCardEvent(getRenderFailedExternalUriPayload(fileAttributes), createAnalyticsEvent);
-        }
-      }
-    });
-
     _defineProperty(_assertThisInitialized(_this), "renderMediaImage", function () {
-      var _this$props8 = _this.props,
-          status = _this$props8.status,
-          mediaItemType = _this$props8.mediaItemType,
-          dataURI = _this$props8.dataURI,
-          mediaType = _this$props8.mediaType,
-          mimeType = _this$props8.mimeType,
-          previewOrientation = _this$props8.previewOrientation,
-          onDisplayImage = _this$props8.onDisplayImage,
-          alt = _this$props8.alt;
+      var _this$props6 = _this.props,
+          status = _this$props6.status,
+          mediaItemType = _this$props6.mediaItemType,
+          dataURI = _this$props6.dataURI,
+          mediaType = _this$props6.mediaType,
+          mimeType = _this$props6.mimeType,
+          previewOrientation = _this$props6.previewOrientation,
+          onDisplayImage = _this$props6.onDisplayImage,
+          alt = _this$props6.alt,
+          onImageLoad = _this$props6.onImageLoad,
+          onImageError = _this$props6.onImageError;
 
       if (!shouldDisplayImageThumbnail(status, mediaItemType, dataURI, mediaType, mimeType)) {
         return null;
@@ -210,21 +184,17 @@ export var FileCardImageViewBase = /*#__PURE__*/function (_Component) {
         crop: _this.isCropped,
         stretch: _this.isStretched,
         previewOrientation: previewOrientation,
-        onImageLoad: _this.onImageLoad,
-        onImageError: _this.onImageError
+        onImageLoad: onImageLoad,
+        onImageError: onImageError
       });
     });
 
-    _defineProperty(_assertThisInitialized(_this), "shouldFireEvent", function (action) {
-      return !_this.lastAnalyticsAction || _this.lastAnalyticsAction !== action;
-    });
-
     _defineProperty(_assertThisInitialized(_this), "renderProgressBar", function () {
-      var _this$props9 = _this.props,
-          mediaName = _this$props9.mediaName,
-          progress = _this$props9.progress,
-          actions = _this$props9.actions,
-          status = _this$props9.status;
+      var _this$props7 = _this.props,
+          mediaName = _this$props7.mediaName,
+          progress = _this$props7.progress,
+          actions = _this$props7.actions,
+          status = _this$props7.status;
 
       if (status !== 'uploading') {
         return null;
@@ -243,10 +213,10 @@ export var FileCardImageViewBase = /*#__PURE__*/function (_Component) {
     });
 
     _defineProperty(_assertThisInitialized(_this), "renderSuccessCardContents", function () {
-      var _this$props10 = _this.props,
-          disableOverlay = _this$props10.disableOverlay,
-          selectable = _this$props10.selectable,
-          status = _this$props10.status;
+      var _this$props8 = _this.props,
+          disableOverlay = _this$props8.disableOverlay,
+          selectable = _this$props8.selectable,
+          status = _this$props8.status;
       var overlay = null;
 
       if (!disableOverlay) {
@@ -267,15 +237,15 @@ export var FileCardImageViewBase = /*#__PURE__*/function (_Component) {
     });
 
     _defineProperty(_assertThisInitialized(_this), "renderSuccessCardOverlay", function () {
-      var _this$props11 = _this.props,
-          status = _this$props11.status,
-          mediaName = _this$props11.mediaName,
-          mediaType = _this$props11.mediaType,
-          fileSize = _this$props11.fileSize,
-          dataURI = _this$props11.dataURI,
-          selectable = _this$props11.selectable,
-          selected = _this$props11.selected,
-          actions = _this$props11.actions;
+      var _this$props9 = _this.props,
+          status = _this$props9.status,
+          mediaName = _this$props9.mediaName,
+          mediaType = _this$props9.mediaType,
+          fileSize = _this$props9.fileSize,
+          dataURI = _this$props9.dataURI,
+          selectable = _this$props9.selectable,
+          selected = _this$props9.selected,
+          actions = _this$props9.actions;
       var isPersistent = mediaType === 'doc' || !dataURI;
       return /*#__PURE__*/React.createElement(CardOverlay, {
         cardStatus: status,
@@ -292,17 +262,17 @@ export var FileCardImageViewBase = /*#__PURE__*/function (_Component) {
     return _this;
   }
 
-  _createClass(FileCardImageViewBase, [{
+  _createClass(FileCardImageView, [{
     key: "render",
     value: function render() {
-      var _this$props12 = this.props,
-          disableOverlay = _this$props12.disableOverlay,
-          selectable = _this$props12.selectable,
-          selected = _this$props12.selected,
-          mediaType = _this$props12.mediaType,
-          progress = _this$props12.progress,
-          status = _this$props12.status,
-          mediaName = _this$props12.mediaName;
+      var _this$props10 = this.props,
+          disableOverlay = _this$props10.disableOverlay,
+          selectable = _this$props10.selectable,
+          selected = _this$props10.selected,
+          mediaType = _this$props10.mediaType,
+          progress = _this$props10.progress,
+          status = _this$props10.status,
+          mediaName = _this$props10.mediaName;
       return /*#__PURE__*/React.createElement(Wrapper, {
         "data-testid": "media-file-card-view",
         "data-test-media-name": mediaName,
@@ -313,16 +283,16 @@ export var FileCardImageViewBase = /*#__PURE__*/function (_Component) {
         selectable: selectable,
         selected: selected,
         mediaType: mediaType,
-        className: fileCardImageViewSelector
+        className: "".concat(fileCardImageViewSelector, " ").concat(selected ? fileCardImageViewSelectedSelector : '')
       }, this.renderCardContents());
     }
   }, {
     key: "isFileCardImageReadyForDisplay",
     get: function get() {
-      var _this$props13 = this.props,
-          dataURI = _this$props13.dataURI,
-          status = _this$props13.status;
-      return !!dataURI || !['loading', 'processing'].includes(status);
+      var _this$props11 = this.props,
+          dataURI = _this$props11.dataURI,
+          status = _this$props11.status;
+      return !!dataURI || !['loading', 'processing', 'loading-preview'].includes(status);
     }
   }, {
     key: "isCropped",
@@ -338,12 +308,10 @@ export var FileCardImageViewBase = /*#__PURE__*/function (_Component) {
     }
   }]);
 
-  return FileCardImageViewBase;
+  return FileCardImageView;
 }(Component);
 
-_defineProperty(FileCardImageViewBase, "defaultProps", {
+_defineProperty(FileCardImageView, "defaultProps", {
   resizeMode: 'crop',
   disableOverlay: false
-});
-
-export var FileCardImageView = withAnalyticsEvents()(withFileAttributes(FileCardImageViewBase));
+});

package/dist/esm/files/index.js

@@ -1 +1 @@
-export { FileCardImageView, FileCardImageViewBase } from './cardImageView';
+export { FileCardImageView } from './cardImageView';

package/dist/esm/index.js

@@ -1,7 +1,7 @@
-export { default as Card } from './root/card/cardLoader';
+export { Card, MediaInlineCard } from './root';
 export { CardLoading } from './utils/lightCards/cardLoading';
 export { CardError } from './utils/lightCards/cardError';
 export { defaultImageCardDimensions } from './utils/cardDimensions';
-export { fileCardImageViewSelector } from './files/cardImageView';
+export { fileCardImageViewSelector, fileCardImageViewSelectedSelector } from './files/cardImageView';
 export { inlinePlayerClassName } from './root/inlinePlayer';
-export { newFileExperienceClassName } from './root/cardView';
+export { newFileExperienceClassName } from './root/card/cardConstants';

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

@@ -1,33 +1,38 @@
-import { fireMediaCardEvent, getRenderSucceededEventPayload, getRenderErrorEventPayload, getRenderFailedFileStatusPayload } from '../../utils/analytics';
-export var relevantFeatureFlagNames = ['newCardExperience', 'poll_intervalMs', 'poll_maxAttempts', 'poll_backoffFactor', 'poll_maxIntervalMs', 'captions'];
-export var fireOperationalEvent = function fireOperationalEvent(createAnalyticsEvent, status, fileAttributes) {
-  var _ref = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
-      cardPreview = _ref.cardPreview,
-      error = _ref.error;
-
+import { fireMediaCardEvent, getRenderSucceededEventPayload, getRenderErrorEventPayload, getRenderFailedFileStatusPayload, getCopiedFilePayload, getRenderCommencedEventPayload, getRenderPreviewableCardPayload } from '../../utils/analytics';
+export var relevantFeatureFlagNames = ['newCardExperience', 'captions'];
+export var fireOperationalEvent = function fireOperationalEvent(createAnalyticsEvent, status, fileAttributes, performanceAttributes, error) {
   var fireEvent = function fireEvent(payload) {
     return fireMediaCardEvent(payload, createAnalyticsEvent);
   };
 
   switch (status) {
     case 'complete':
-      /**
-       * A Card that is considered Complete and has no preview,
-       * reflects an expected behaviour, and thus a legitimate
-       * success case to be logged.
-       */
-      if (!(cardPreview !== null && cardPreview !== void 0 && cardPreview.dataURI)) {
-        fireEvent(getRenderSucceededEventPayload(fileAttributes));
-      }
-
+      fireEvent(getRenderSucceededEventPayload(fileAttributes, performanceAttributes));
       break;
 
     case 'failed-processing':
-      fireEvent(getRenderFailedFileStatusPayload(fileAttributes));
+      fireEvent(getRenderFailedFileStatusPayload(fileAttributes, performanceAttributes));
       break;
 
     case 'error':
-      error && fireEvent(getRenderErrorEventPayload(fileAttributes, error));
+      error && fireEvent(getRenderErrorEventPayload(fileAttributes, performanceAttributes, error));
       break;
   }
+};
+export var fireCommencedEvent = function fireCommencedEvent(createAnalyticsEvent, fileAttributes, performanceAttributes) {
+  fireMediaCardEvent(getRenderCommencedEventPayload(fileAttributes, performanceAttributes), createAnalyticsEvent);
+};
+export var fireCopiedEvent = function fireCopiedEvent(createAnalyticsEvent, fileId, cardRef) {
+  if (typeof window.getSelection === 'function') {
+    var _selection$containsNo;
+
+    var selection = window.getSelection();
+
+    if (selection !== null && selection !== void 0 && (_selection$containsNo = selection.containsNode) !== null && _selection$containsNo !== void 0 && _selection$containsNo.call(selection, cardRef, true)) {
+      fireMediaCardEvent(getCopiedFilePayload(fileId), createAnalyticsEvent);
+    }
+  }
+};
+export var fireScreenEvent = function fireScreenEvent(createAnalyticsEvent, fileAttributes) {
+  fireMediaCardEvent(getRenderPreviewableCardPayload(fileAttributes), createAnalyticsEvent);
 };

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

@@ -0,0 +1 @@
+export var newFileExperienceClassName = 'new-file-experience-wrapper';

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

@@ -1,129 +1,69 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
-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 React from 'react';
+import _extends from "@babel/runtime/helpers/extends";
+import React, { useContext } from 'react';
+import { useMemoizeFeatureFlags } from '@atlaskit/media-common';
+import Loadable from 'react-loadable';
 import { CardLoading } from '../..';
-
-var CardLoader = /*#__PURE__*/function (_React$PureComponent) {
-  _inherits(CardLoader, _React$PureComponent);
-
-  var _super = _createSuper(CardLoader);
-
-  function CardLoader() {
-    var _this;
-
-    _classCallCheck(this, CardLoader);
-
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
-    _this = _super.call.apply(_super, [this].concat(args));
-
-    _defineProperty(_assertThisInitialized(_this), "state", {
-      Card: CardLoader.Card,
-      MediaCardErrorBoundary: CardLoader.MediaCardErrorBoundary
+var MediaCardContext = /*#__PURE__*/React.createContext({});
+
+var CardLoadingWithContext = function CardLoadingWithContext() {
+  var props = useContext(MediaCardContext);
+  return /*#__PURE__*/React.createElement(CardLoading, props);
+};
+
+var MediaCard = Loadable({
+  loader: function loader() {
+    return import(
+    /* webpackChunkName: "@atlaskit-internal_media-card" */
+    './index').then(function (mod) {
+      return mod.Card;
     });
-
-    return _this;
+  },
+  loading: function loading() {
+    return /*#__PURE__*/React.createElement(CardLoadingWithContext, null);
   }
-
-  _createClass(CardLoader, [{
-    key: "componentDidMount",
-    value: function () {
-      var _componentDidMount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        var _yield$Promise$all, _yield$Promise$all2, mediaClient, cardModule, mediaCardErrorBoundaryModule;
-
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (this.state.Card) {
-                  _context.next = 16;
-                  break;
-                }
-
-                _context.prev = 1;
-                _context.next = 4;
-                return Promise.all([import(
-                /* webpackChunkName: "@atlaskit-internal_media-client" */
-                '@atlaskit/media-client'), import(
-                /* webpackChunkName: "@atlaskit-internal_media-card" */
-                './index'), import(
-                /* webpackChunkName: "@atlaskit-internal_media-card-error-boundary" */
-                '../media-card-analytics-error-boundary')]);
-
-              case 4:
-                _yield$Promise$all = _context.sent;
-                _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 3);
-                mediaClient = _yield$Promise$all2[0];
-                cardModule = _yield$Promise$all2[1];
-                mediaCardErrorBoundaryModule = _yield$Promise$all2[2];
-                CardLoader.Card = mediaClient.withMediaClient(cardModule.Card, this.props.featureFlags);
-                CardLoader.MediaCardErrorBoundary = mediaCardErrorBoundaryModule.default;
-                this.setState({
-                  Card: CardLoader.Card,
-                  MediaCardErrorBoundary: CardLoader.MediaCardErrorBoundary
-                });
-                _context.next = 16;
-                break;
-
-              case 14:
-                _context.prev = 14;
-                _context.t0 = _context["catch"](1);
-
-              case 16:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this, [[1, 14]]);
-      }));
-
-      function componentDidMount() {
-        return _componentDidMount.apply(this, arguments);
-      }
-
-      return componentDidMount;
-    }()
-  }, {
-    key: "render",
-    value: function render() {
-      var _this$props = this.props,
-          dimensions = _this$props.dimensions,
-          testId = _this$props.testId,
-          featureFlags = _this$props.featureFlags;
-      var _this$state = this.state,
-          Card = _this$state.Card,
-          MediaCardErrorBoundary = _this$state.MediaCardErrorBoundary;
-
-      if (!Card || !MediaCardErrorBoundary) {
-        return /*#__PURE__*/React.createElement(CardLoading, {
-          testId: testId,
-          dimensions: dimensions,
-          featureFlags: featureFlags
-        });
-      }
-
-      return /*#__PURE__*/React.createElement(MediaCardErrorBoundary, null, /*#__PURE__*/React.createElement(Card, this.props));
-    }
-  }]);
-
-  return CardLoader;
-}(React.PureComponent);
-
-_defineProperty(CardLoader, "displayName", 'AsyncCard');
-
-export { CardLoader as default };
+});
+var MediaCardErrorBoundary = Loadable({
+  loader: function loader() {
+    return import(
+    /* webpackChunkName: "@atlaskit-internal_media-card-error-boundary" */
+    '../media-card-analytics-error-boundary').then(function (mod) {
+      return mod.default;
+    });
+  },
+  loading: function loading() {
+    return /*#__PURE__*/React.createElement(CardLoadingWithContext, null);
+  }
+});
+var MediaCardWithMediaClient = Loadable({
+  loader: function loader() {
+    return import(
+    /* webpackChunkName: "@atlaskit-internal_media-client" */
+    '@atlaskit/media-client');
+  },
+  loading: function loading() {
+    return /*#__PURE__*/React.createElement(CardLoadingWithContext, null);
+  },
+  render: function render(loaded, props) {
+    return /*#__PURE__*/React.createElement(CardWithMediaClient, _extends({}, props, {
+      withMediaClient: loaded.withMediaClient
+    }));
+  }
+});
+
+var CardWithMediaClient = function CardWithMediaClient(props) {
+  var withMediaClient = props.withMediaClient,
+      featureFlags = props.featureFlags;
+  var memoizedFeatureFlags = useMemoizeFeatureFlags(featureFlags);
+  var Card = React.useMemo(function () {
+    return withMediaClient(MediaCard, memoizedFeatureFlags);
+  }, [withMediaClient, memoizedFeatureFlags]);
+  return /*#__PURE__*/React.createElement(MediaCardErrorBoundary, null, /*#__PURE__*/React.createElement(Card, props));
+};
+
+var CardLoader = function CardLoader(props) {
+  return /*#__PURE__*/React.createElement(MediaCardContext.Provider, {
+    value: props
+  }, /*#__PURE__*/React.createElement(MediaCardWithMediaClient, props));
+};
+
+export default CardLoader;

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

@@ -0,0 +1,32 @@
+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 { isErrorFileState } from '@atlaskit/media-client';
+import { MediaCardError } from '../../errors';
+import { getCardStatus, isFinalCardStatus } from './getCardStatus';
+import { extractFilePreviewStatus } from './getCardPreview';
+export var createStateUpdater = function createStateUpdater(newState) {
+  return function (prevState) {
+    // Only override if previous status is non-final
+    // or new status is 'complete'
+    if (isFinalCardStatus(prevState.status) && newState.status !== 'complete') {
+      return prevState;
+    }
+
+    return _objectSpread(_objectSpread({}, prevState), newState);
+  };
+};
+export var getCardStateFromFileState = function getCardStateFromFileState(fileState, isBannedLocalPreview, featureFlags) {
+  var status = getCardStatus(fileState.status, extractFilePreviewStatus(fileState, isBannedLocalPreview, featureFlags));
+  var error = status === 'error' && isErrorFileState(fileState) ? new MediaCardError('error-file-state', new Error(fileState.message)) : undefined;
+  var progress = status === 'uploading' && fileState.status === 'uploading' ? fileState.progress : 1;
+  return {
+    fileState: fileState,
+    status: status,
+    progress: progress,
+    error: error
+  };
+};

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

@@ -22,6 +22,12 @@ export var CardPreviewCacheImpl = function CardPreviewCacheImpl(previewCache) {
     _this.previewCache.set(cacheKey, cardPreview);
   });
 
+  _defineProperty(this, "remove", function (id, dimensions) {
+    var cacheKey = getCacheKey(id, dimensions);
+
+    _this.previewCache.remove(cacheKey);
+  });
+
   this.previewCache = previewCache;
 };
 export default new CardPreviewCacheImpl(createObjectURLCache());

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

@@ -0,0 +1,35 @@
+import { isMimeTypeSupportedByBrowser } from '@atlaskit/media-common';
+import { isPreviewableFileState, isPreviewableType, isImageRepresentationReady } from '@atlaskit/media-client';
+import { isSupportedLocalPreview } from './helpers'; // TODO: align these checks with helpers from Media Client
+// https://product-fabric.atlassian.net/browse/BMPT-1300
+
+export var extractFilePreviewStatus = function extractFilePreviewStatus(fileState, isBannedLocalPreview, featureFlags) {
+  var hasFilesize = 'size' in fileState && !!fileState.size;
+
+  var _ref = 'mediaType' in fileState && fileState || {},
+      mediaType = _ref.mediaType;
+
+  var _ref2 = 'mimeType' in fileState && fileState || {},
+      mimeType = _ref2.mimeType;
+
+  var isPreviewable = !!mediaType && isPreviewableType(mediaType, featureFlags); // Local preview is available only if it's supported by browser and supported by Media Card (isSupportedLocalPreview)
+  // For example, SVGs are mime type NOT supported by browser but media type supported by Media Card (image)
+  // Then, local Preview NOT available
+
+  var hasLocalPreview = !isBannedLocalPreview && isPreviewableFileState(fileState) && isSupportedLocalPreview(mediaType) && !!mimeType && isMimeTypeSupportedByBrowser(mimeType);
+  var hasRemotePreview = isImageRepresentationReady(fileState);
+  var hasPreview = hasLocalPreview || hasRemotePreview;
+  var isSupportedByBrowser = !!mimeType && isMimeTypeSupportedByBrowser(mimeType);
+  return {
+    hasFilesize: hasFilesize,
+    isPreviewable: isPreviewable,
+    hasPreview: hasPreview,
+    isSupportedByBrowser: isSupportedByBrowser
+  };
+};
+export var isPreviewableStatus = function isPreviewableStatus(cardStatus, _ref3) {
+  var isPreviewable = _ref3.isPreviewable,
+      hasPreview = _ref3.hasPreview,
+      isSupportedByBrowser = _ref3.isSupportedByBrowser;
+  return hasPreview && isPreviewable && (cardStatus === 'complete' || cardStatus === 'loading-preview' || cardStatus === 'uploading' || cardStatus === 'processing' && isSupportedByBrowser);
+};

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

@@ -157,25 +157,17 @@ export var getCardPreviewFromFilePreview = /*#__PURE__*/function () {
   };
 }();
 export var getCardPreviewFromBackend = /*#__PURE__*/function () {
-  var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(mediaClient, id, _ref4, collectionName, resizeMode) {
-    var width, height, mode, blob;
+  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:
-            width = _ref4.width, height = _ref4.height;
-            _context4.prev = 1;
-            mode = resizeMode === 'stretchy-fit' ? 'full-fit' : resizeMode;
-            _context4.next = 5;
-            return mediaClient.getImage(id, {
-              collection: collectionName,
-              mode: mode,
-              width: width,
-              height: height,
-              allowAnimated: true
-            });
+            _context4.prev = 0;
+            _context4.next = 3;
+            return mediaClient.getImage(id, params);
 
-          case 5:
+          case 3:
             blob = _context4.sent;
             return _context4.abrupt("return", {
               dataURI: URL.createObjectURL(blob),
@@ -183,20 +175,20 @@ export var getCardPreviewFromBackend = /*#__PURE__*/function () {
               source: 'remote'
             });
 
-          case 9:
-            _context4.prev = 9;
-            _context4.t0 = _context4["catch"](1);
+          case 7:
+            _context4.prev = 7;
+            _context4.t0 = _context4["catch"](0);
             throw new RemotePreviewError('remote-preview-fetch', _context4.t0);
 
-          case 12:
+          case 10:
           case "end":
             return _context4.stop();
         }
       }
-    }, _callee4, null, [[1, 9]]);
+    }, _callee4, null, [[0, 7]]);
   }));
 
-  return function getCardPreviewFromBackend(_x4, _x5, _x6, _x7, _x8) {
-    return _ref5.apply(this, arguments);
+  return function getCardPreviewFromBackend(_x4, _x5, _x6) {
+    return _ref4.apply(this, arguments);
   };
 }();