@atlaskit/media-card 77.4.10 → 77.5.1

package/dist/es2019/card/v2/{useFilePreview.js → useFilePreview/useFilePreview.js}

@@ -1,18 +1,12 @@
-import { addFileAttrsToUrl, imageResizeModeToFileImageMode, isImageRepresentationReady } from '@atlaskit/media-client';
+import { imageResizeModeToFileImageMode, isImageRepresentationReady } from '@atlaskit/media-client';
 import { MediaFileStateError, useFileState, useMediaClient } from '@atlaskit/media-client-react';
-import { getMediaTypeFromMimeType, isMimeTypeSupportedByBrowser } from '@atlaskit/media-common';
-import { getOrientation } from '@atlaskit/media-ui';
+import { isMimeTypeSupportedByBrowser } from '@atlaskit/media-common';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { ensureMediaCardError, ImageLoadError, isLocalPreviewError, isUnsupportedLocalPreviewError, LocalPreviewError, MediaCardError } from '../../errors';
-import { extractErrorInfo } from '../../utils/analytics';
-import { isBigger } from '../../utils/dimensionComparer';
-import { isRetina } from '../../utils/isRetina';
-import { generateScriptProps, getSSRData } from '../../utils/globalScope';
-import { useCurrentValueRef } from '../../utils/useCurrentValueRef';
-import { usePrevious } from '../../utils/usePrevious';
-import { takeSnapshot } from '../../utils/videoSnapshot';
-import { fetchAndCacheRemotePreview, getCardPreviewFromCache, getSSRCardPreview, isLocalPreview, isSSRClientPreview, isSSRDataPreview, removeCardPreviewFromCache, shouldResolvePreview } from '../getCardPreview';
-import cardPreviewCache from '../getCardPreview/cache';
+import { ensureMediaFilePreviewError, ImageLoadError, isLocalPreviewError, isUnsupportedLocalPreviewError, MediaFilePreviewError } from './errors';
+import { extractErrorInfo } from '../../../utils/analytics';
+import { isBigger, createRequestDimensions, useCurrentValueRef, usePrevious } from './helpers';
+import { generateScriptProps, getSSRData } from './globalScope';
+import { getAndCacheRemotePreview, getSSRCardPreview, isLocalPreview, isSSRClientPreview, isSSRDataPreview, isPreviewableStatus, extractFilePreviewStatus, mediaFilePreviewCache, getAndCacheLocalPreview } from './getPreview';
 export const useFilePreview = ({
   resizeMode = 'crop',
   identifier,
@@ -72,7 +66,7 @@ export const useFilePreview = ({
       id
     } = identifier;
     const fileImageMode = imageResizeModeToFileImageMode(resizeMode);
-    cardPreview = getCardPreviewFromCache(id, fileImageMode);
+    cardPreview = mediaFilePreviewCache.get(id, fileImageMode);
     if (!cardPreview && ssr) {
       cardPreview = getSSRPreview(ssr, identifier, mediaClient);
     }
@@ -95,104 +89,22 @@ export const useFilePreview = ({
   //----------------------------------------------------------------//
 
   const fetchRemotePreviewRef = useCurrentValueRef(identifier => {
-    return fetchAndCacheRemotePreview(mediaClient, identifier.id, requestDimensions || {}, imageURLParams, mediaBlobUrlAttrs, traceContext);
+    return getAndCacheRemotePreview(mediaClient, identifier.id, requestDimensions || {}, imageURLParams, mediaBlobUrlAttrs, traceContext);
   });
   const resolvePreviewRef = useCurrentValueRef(async (identifier, fileState) => {
     const filePreview = isBannedLocalPreview ? undefined : fileState.status !== 'error' && 'mimeType' in fileState && isMimeTypeSupportedByBrowser(fileState.mimeType) ? fileState.preview : undefined;
     const isRemotePreviewReady = isImageRepresentationReady(fileState);
     try {
       const mode = imageURLParams.mode;
-      const cachedPreview = cardPreviewCache.get(identifier.id, mode);
+      const cachedPreview = mediaFilePreviewCache.get(identifier.id, mode);
       const dimensionsAreBigger = isBigger(cachedPreview === null || cachedPreview === void 0 ? void 0 : cachedPreview.dimensions, requestDimensions);
       if (cachedPreview && !dimensionsAreBigger) {
         return cachedPreview;
       }
-      let localPreview;
       try {
         if (filePreview) {
-          let value;
-          try {
-            const resolvedFilePreview = await filePreview;
-            value = resolvedFilePreview.value;
-          } catch (e) {
-            throw new LocalPreviewError('local-preview-rejected', e instanceof Error ? e : undefined);
-          }
-          if (typeof value === 'string') {
-            localPreview = {
-              dataURI: value,
-              orientation: 1,
-              source: 'local'
-            };
-          } else if (value instanceof Blob) {
-            const {
-              type
-            } = value;
-            const mediaType = getMediaTypeFromMimeType(type);
-            switch (mediaType) {
-              case 'image':
-                try {
-                  const orientation = await getOrientation(value);
-                  const dataURI = URL.createObjectURL(value);
-                  localPreview = {
-                    dataURI,
-                    orientation,
-                    source: 'local'
-                  };
-                } catch (e) {
-                  throw new LocalPreviewError('local-preview-image', e instanceof Error ? e : undefined);
-                }
-                break;
-              case 'video':
-                try {
-                  const dataURI = await takeSnapshot(value);
-                  localPreview = {
-                    dataURI,
-                    orientation: 1,
-                    source: 'local'
-                  };
-                } catch (e) {
-                  throw new LocalPreviewError('local-preview-video', e instanceof Error ? e : undefined);
-                }
-                break;
-              default:
-                throw new LocalPreviewError('local-preview-unsupported');
-            }
-          } else {
-            throw new LocalPreviewError('local-preview-unsupported');
-          }
-          const preview = {
-            ...localPreview,
-            dimensions: requestDimensions
-          };
-          let source;
-          switch (preview.source) {
-            case 'local':
-              source = 'cache-local';
-              break;
-            case 'remote':
-              source = 'cache-remote';
-              break;
-            case 'ssr-server':
-              source = 'cache-ssr-server';
-              break;
-            case 'ssr-client':
-              source = 'cache-ssr-client';
-              break;
-            default:
-              source = preview.source;
-          }
-          // We want to embed some meta context into dataURI for Copy/Paste to work.
-          const dataURI = mediaBlobUrlAttrs ? addFileAttrsToUrl(preview.dataURI, mediaBlobUrlAttrs) : preview.dataURI;
-          // We store new cardPreview into cache
-          cardPreviewCache.set(identifier.id, mode, {
-            ...preview,
-            source,
-            dataURI
-          });
-          setCardPreview({
-            ...preview,
-            dataURI
-          });
+          const localPreview = await getAndCacheLocalPreview(identifier.id, filePreview, requestDimensions || {}, mode, mediaBlobUrlAttrs);
+          setCardPreview(localPreview);
           return;
         }
       } catch (e) {
@@ -225,13 +137,13 @@ export const useFilePreview = ({
          * If remote preview is not ready, the call to getCardPreviewFromBackend
          * will generate a console error due to a 404 code
          */
-        throw new MediaCardError('remote-preview-not-ready');
+        throw new MediaFilePreviewError('remote-preview-not-ready');
       }
       const remotePreview = await fetchRemotePreviewRef.current(identifier);
       setCardPreview(remotePreview);
       return;
     } catch (e) {
-      const wrappedError = ensureMediaCardError('preview-fetch', e);
+      const wrappedError = ensureMediaFilePreviewError('preview-fetch', e);
       //  If remote preview fails, we set status 'error'
       //  If local preview fails (i.e, no remote preview available),
       //  we can stay in the same status until there is a remote preview available
@@ -293,7 +205,7 @@ export const useFilePreview = ({
       // refetchSRRPreview: If dimensions from Server have changed and are bigger,
       // we need to refetch
       fetchRemotePreviewRef.current(identifier).then(setCardPreview).catch(e => {
-        const wrappedError = ensureMediaCardError('remote-preview-fetch-ssr', e, true);
+        const wrappedError = ensureMediaFilePreviewError('remote-preview-fetch-ssr', e, true);
         setNonCriticalError(wrappedError);
       });
     }
@@ -301,15 +213,7 @@ export const useFilePreview = ({
     // Both compare dimensions, but the above is only for SSR in order to refetchSRRPreview and
     // will swallow any errors. Below logic only applies when there is no card preview or the dimensions
     // are bigger.
-    if (fileState && shouldResolvePreview({
-      status,
-      fileState: fileState,
-      prevDimensions: prevRequestDimensions,
-      dimensions: requestDimensions,
-      hasCardPreview: !!cardPreview,
-      isBannedLocalPreview,
-      wasResolvedUpfrontPreview: wasResolvedUpfrontPreviewRef.current
-    })) {
+    if (fileState && wasResolvedUpfrontPreviewRef.current && isPreviewableStatus(status, extractFilePreviewStatus(fileState, isBannedLocalPreview)) && (!cardPreview || isBigger(prevRequestDimensions, requestDimensions))) {
       resolvePreviewRef.current(identifier, fileState);
     }
     if (!skipRemote && ssr && !!cardPreview && isSSRClientPreview(cardPreview)) {
@@ -379,7 +283,7 @@ export const useFilePreview = ({
       } else {
         const e = new MediaFileStateError(fileState.id, fileState.reason, fileState.message, fileState.details);
         const errorReason = status === 'uploading' ? 'upload' : 'metadata-fetch';
-        setError(new MediaCardError(errorReason, e));
+        setError(new MediaFilePreviewError(errorReason, e));
         setStatus('error');
       }
     }
@@ -420,7 +324,7 @@ export const useFilePreview = ({
         setNonCriticalError(error);
       }
       const fileImageMode = imageResizeModeToFileImageMode(resizeMode);
-      removeCardPreviewFromCache(identifier.id, fileImageMode);
+      mediaFilePreviewCache.remove(identifier.id, fileImageMode);
       setCardPreview(undefined);
     } else {
       if (!['complete', 'error', 'failed-processing'].includes(status)) {
@@ -479,24 +383,6 @@ export const useFilePreview = ({
     getScriptProps
   };
 };
-const createRequestDimensions = dimensions => {
-  if (!dimensions) {
-    return;
-  }
-  const retinaFactor = isRetina() ? 2 : 1;
-  const {
-    width,
-    height
-  } = dimensions;
-  const result = {};
-  if (width) {
-    result.width = width * retinaFactor;
-  }
-  if (height) {
-    result.height = height * retinaFactor;
-  }
-  return result;
-};
 const initialSsrReliability = {
   server: {
     status: 'unknown'

package/dist/es2019/inline/loader.js

@@ -37,7 +37,7 @@ export default class MediaInlineCardLoader extends React.PureComponent {
     } = this.state;
     const analyticsContext = {
       packageVersion: "@atlaskit/media-card",
-      packageName: "77.4.10",
+      packageName: "77.5.1",
       componentName: 'mediaInlineCard',
       component: 'mediaInlineCard'
     };

package/dist/es2019/utils/ufoExperiences.js

@@ -4,7 +4,7 @@ import { extractErrorInfo, getRenderErrorRequestMetadata } from './analytics';
 import { MediaCardError } from '../errors';
 import { getMediaEnvironment, getMediaRegion } from '@atlaskit/media-client';
 const packageName = "@atlaskit/media-card";
-const packageVersion = "77.4.10";
+const packageVersion = "77.5.1";
 let concurrentExperience;
 const getExperience = id => {
   if (!concurrentExperience) {

package/dist/esm/card/card.js

@@ -40,7 +40,7 @@ import { getMediaCardCursor } from '../utils/getMediaCardCursor';
 import { completeUfoExperience, startUfoExperience, abortUfoExperience } from '../utils/ufoExperiences';
 import { generateUniqueId } from '../utils/generateUniqueId';
 var packageName = "@atlaskit/media-card";
-var packageVersion = "77.4.10";
+var packageVersion = "77.5.1";
 export var CardBase = /*#__PURE__*/function (_Component) {
   _inherits(CardBase, _Component);
   var _super = _createSuper(CardBase);

package/dist/esm/card/cardLoader.js

@@ -1,4 +1,3 @@
-import _extends from "@babel/runtime/helpers/extends";
 import React, { useContext } from 'react';
 import Loadable from 'react-loadable';
 import { CardLoading } from '../utils/lightCards/cardLoading';
@@ -7,55 +6,16 @@ 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" */'./card').then(function (mod) {
-      return mod.Card;
-    });
-  },
-  loading: function loading() {
-    return /*#__PURE__*/React.createElement(CardLoadingWithContext, null);
-  }
-});
-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-react" */'@atlaskit/media-client-react');
+    return import( /* webpackChunkName: "@atlaskit-internal_media-card-with-media-client" */'./cardWithMediaClient').then(function (mod) {
+      return mod.CardWithMediaClient;
+    });
   },
   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,
-    dimensions = props.dimensions,
-    onClick = props.onClick;
-  var Card = React.useMemo(function () {
-    return withMediaClient(MediaCard);
-  }, [withMediaClient]);
-  return (
-    /*#__PURE__*/
-    // onClick is passed into MediaCardErrorBoundary so MediaGroup items can get the toolbar menu in Editor
-    React.createElement(MediaCardErrorBoundary, {
-      dimensions: dimensions,
-      onClick: onClick
-    }, /*#__PURE__*/React.createElement(Card, props))
-  );
-};
 var CardLoader = function CardLoader(props) {
   return /*#__PURE__*/React.createElement(MediaCardContext.Provider, {
     value: props

package/dist/esm/card/cardWithMediaClient.js

@@ -0,0 +1,19 @@
+import React from 'react';
+import { withMediaClient } from '@atlaskit/media-client-react';
+import { Card as MediaCard } from './card';
+import MediaCardAnalyticsErrorBoundary from './media-card-analytics-error-boundary';
+export var CardWithMediaClient = function CardWithMediaClient(props) {
+  var dimensions = props.dimensions,
+    onClick = props.onClick;
+  var Card = React.useMemo(function () {
+    return withMediaClient(MediaCard);
+  }, []);
+  return (
+    /*#__PURE__*/
+    // onClick is passed into MediaCardErrorBoundary so MediaGroup items can get the toolbar menu in Editor
+    React.createElement(MediaCardAnalyticsErrorBoundary, {
+      dimensions: dimensions,
+      onClick: onClick
+    }, /*#__PURE__*/React.createElement(Card, props))
+  );
+};

package/dist/esm/card/media-card-analytics-error-boundary.js

@@ -83,7 +83,7 @@ var WrappedMediaCardAnalyticsErrorBoundary = /*#__PURE__*/function (_React$Compo
 }(React.Component);
 _defineProperty(WrappedMediaCardAnalyticsErrorBoundary, "displayName", 'MediaCardAnalyticsErrorBoundary');
 var packageName = "@atlaskit/media-card";
-var packageVersion = "77.4.10";
+var packageVersion = "77.5.1";
 var MediaCardAnalyticsErrorBoundary = withMediaAnalyticsContext({
   packageVersion: packageVersion,
   packageName: packageName,

package/dist/esm/card/v2/cardV2.js

@@ -9,7 +9,7 @@ import { IntlProvider, injectIntl } from 'react-intl-next';
 import { ExternalImageCard } from './externalImageCard';
 import { FileCard } from './fileCard';
 var packageName = "@atlaskit/media-card";
-var packageVersion = "77.4.10";
+var packageVersion = "77.5.1";
 export var CardV2Base = function CardV2Base(_ref) {
   var identifier = _ref.identifier,
     otherProps = _objectWithoutProperties(_ref, _excluded);

package/dist/esm/card/v2/cardV2Loader.js

@@ -1,7 +1,3 @@
-import _extends from "@babel/runtime/helpers/extends";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import React, { useContext } from 'react';
 import Loadable from 'react-loadable';
 import { CardLoading } from '../../utils/lightCards/cardLoading';
@@ -10,57 +6,14 @@ var CardLoadingWithContext = function CardLoadingWithContext() {
   var props = useContext(MediaCardContext);
   return /*#__PURE__*/React.createElement(CardLoading, props);
 };
-var MediaV2Card = Loadable({
-  loader: function loader() {
-    return import( /* webpackChunkName: "@atlaskit-internal_media-card-v2" */'./cardV2').then(function (mod) {
-      return mod.CardV2;
-    });
-  },
-  loading: function loading() {
-    return /*#__PURE__*/React.createElement(CardLoadingWithContext, null);
-  }
-});
-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 CardWithMediaClient = function CardWithMediaClient(props) {
-  var dimensions = props.dimensions,
-    onClick = props.onClick,
-    withMediaClient = props.withMediaClient,
-    featureFlags = props.featureFlags;
-  var Card = React.useMemo(function () {
-    return withMediaClient(MediaV2Card);
-  }, [withMediaClient]);
-  var featureFlagsWithMediaCardV2 = React.useMemo(function () {
-    return _objectSpread(_objectSpread({}, featureFlags), {}, {
-      mediaCardV2: true //used for analytics - internal use only
-    });
-  }, [featureFlags]);
-  return /*#__PURE__*/React.createElement(MediaCardErrorBoundary, {
-    dimensions: dimensions,
-    onClick: onClick
-  }, /*#__PURE__*/React.createElement(Card, _extends({}, props, {
-    featureFlags: featureFlagsWithMediaCardV2
-  })));
-};
 var MediaCardWithMediaClientProvider = Loadable({
   loader: function loader() {
-    return import( /* webpackChunkName: "@atlaskit-internal_media-client-react" */'@atlaskit/media-client-react');
+    return import( /* webpackChunkName: "@atlaskit-internal_media-card-with-media-client-v2" */'./cardWithMediaClientV2').then(function (mod) {
+      return mod.CardWithMediaClientV2;
+    });
   },
   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 CardLoader = function CardLoader(props) {

package/dist/esm/card/v2/cardViewV2.js

@@ -75,18 +75,19 @@ export var CardViewV2Base = function CardViewV2Base(_ref) {
     if (prevCardPreview.dataURI !== (cardPreview === null || cardPreview === void 0 ? void 0 : cardPreview.dataURI)) {
       return;
     }
-
     /*
       We render the icon & icon message always, even if there is cardPreview available.
-       If the image fails to load/render, the icon will remain, i.e. the user won't see a change until the root card decides to chage status to error.
-       If the image renders successfully, we switch this variable to hide the icon & icon message behind the thumbnail in case the image has transparency.
-       It is less likely that root component replaces a suceeded cardPreview for a failed one than the opposite case. Therefore we prefer to hide the icon instead show when the image fails, for a smoother transition
+      If the image fails to load/render, the icon will remain, i.e. the user won't see a change until the root card decides to chage status to error.
+      If the image renders successfully, we switch this variable to hide the icon & icon message behind the thumbnail in case the image has transparency.
+      It is less likely that root component replaces a suceeded cardPreview for a failed one than the opposite case. Therefore we prefer to hide the icon instead show when the image fails, for a smoother transition
     */
-
     setDidImageRender(true);
     onImageLoad === null || onImageLoad === void 0 || onImageLoad(cardPreview);
   };
-  var handleOnImageError = function handleOnImageError(cardPreview) {
+  var handleOnImageError = function handleOnImageError(prevCardPreview) {
+    if (prevCardPreview.dataURI !== (cardPreview === null || cardPreview === void 0 ? void 0 : cardPreview.dataURI)) {
+      return;
+    }
     setDidImageRender(false);
     onImageError === null || onImageError === void 0 || onImageError(cardPreview);
   };

package/dist/esm/card/v2/cardWithMediaClientV2.js

@@ -0,0 +1,27 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import React from 'react';
+import { withMediaClient } from '@atlaskit/media-client-react';
+import MediaCardAnalyticsErrorBoundary from '../media-card-analytics-error-boundary';
+import { CardV2 } from './cardV2';
+export var CardWithMediaClientV2 = function CardWithMediaClientV2(props) {
+  var dimensions = props.dimensions,
+    onClick = props.onClick,
+    featureFlags = props.featureFlags;
+  var Card = React.useMemo(function () {
+    return withMediaClient(CardV2);
+  }, []);
+  var featureFlagsWithMediaCardV2 = React.useMemo(function () {
+    return _objectSpread(_objectSpread({}, featureFlags), {}, {
+      mediaCardV2: true //used for analytics - internal use only
+    });
+  }, [featureFlags]);
+  return /*#__PURE__*/React.createElement(MediaCardAnalyticsErrorBoundary, {
+    dimensions: dimensions,
+    onClick: onClick
+  }, /*#__PURE__*/React.createElement(Card, _extends({}, props, {
+    featureFlags: featureFlagsWithMediaCardV2
+  })));
+};

package/dist/esm/card/v2/useFilePreview/errors.js

@@ -0,0 +1,124 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+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 _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+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; } }
+/**
+ * Primary reason is logged through Data Portal.
+ * Make sure all the values are whitelisted in Measure -> Event Regitry -> "mediaCardRender failed" event
+ */
+
+export var MediaFilePreviewError = /*#__PURE__*/function (_Error) {
+  _inherits(MediaFilePreviewError, _Error);
+  var _super = _createSuper(MediaFilePreviewError);
+  function MediaFilePreviewError(primaryReason, secondaryError) {
+    var _this;
+    _classCallCheck(this, MediaFilePreviewError);
+    _this = _super.call(this, primaryReason);
+    // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget
+    _this.primaryReason = primaryReason;
+    _this.secondaryError = secondaryError;
+    Object.setPrototypeOf(_assertThisInitialized(_this), (this instanceof MediaFilePreviewError ? this.constructor : void 0).prototype);
+
+    // https://v8.dev/docs/stack-trace-api
+    if ('captureStackTrace' in Error) {
+      Error.captureStackTrace(_assertThisInitialized(_this), this instanceof MediaFilePreviewError ? this.constructor : void 0);
+    }
+    return _this;
+  }
+  return _createClass(MediaFilePreviewError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export var LocalPreviewError = /*#__PURE__*/function (_MediaFilePreviewErro) {
+  _inherits(LocalPreviewError, _MediaFilePreviewErro);
+  var _super2 = _createSuper(LocalPreviewError);
+  function LocalPreviewError(primaryReason, secondaryError) {
+    var _this2;
+    _classCallCheck(this, LocalPreviewError);
+    _this2 = _super2.call(this, primaryReason, secondaryError);
+    _this2.primaryReason = primaryReason;
+    _this2.secondaryError = secondaryError;
+    return _this2;
+  }
+  return _createClass(LocalPreviewError);
+}(MediaFilePreviewError);
+export var RemotePreviewError = /*#__PURE__*/function (_MediaFilePreviewErro2) {
+  _inherits(RemotePreviewError, _MediaFilePreviewErro2);
+  var _super3 = _createSuper(RemotePreviewError);
+  function RemotePreviewError(primaryReason, secondaryError) {
+    var _this3;
+    _classCallCheck(this, RemotePreviewError);
+    _this3 = _super3.call(this, primaryReason, secondaryError);
+    _this3.primaryReason = primaryReason;
+    _this3.secondaryError = secondaryError;
+    return _this3;
+  }
+  return _createClass(RemotePreviewError);
+}(MediaFilePreviewError);
+export var SsrPreviewError = /*#__PURE__*/function (_MediaFilePreviewErro3) {
+  _inherits(SsrPreviewError, _MediaFilePreviewErro3);
+  var _super4 = _createSuper(SsrPreviewError);
+  function SsrPreviewError(primaryReason, secondaryError) {
+    var _this4;
+    _classCallCheck(this, SsrPreviewError);
+    _this4 = _super4.call(this, primaryReason, secondaryError);
+    _this4.primaryReason = primaryReason;
+    _this4.secondaryError = secondaryError;
+    return _this4;
+  }
+  return _createClass(SsrPreviewError);
+}(MediaFilePreviewError);
+var getImageLoadPrimaryReason = function getImageLoadPrimaryReason(source) {
+  switch (source) {
+    case 'cache-remote':
+      return 'cache-remote-uri';
+    case 'cache-local':
+      return 'cache-local-uri';
+    case 'external':
+      return 'external-uri';
+    case 'local':
+      return 'local-uri';
+    case 'remote':
+      return 'remote-uri';
+    // This fail reason will come from a bug, most likely.
+    default:
+      return "unknown-uri";
+  }
+};
+export var ImageLoadError = /*#__PURE__*/function (_MediaFilePreviewErro4) {
+  _inherits(ImageLoadError, _MediaFilePreviewErro4);
+  var _super5 = _createSuper(ImageLoadError);
+  function ImageLoadError(source) {
+    _classCallCheck(this, ImageLoadError);
+    return _super5.call(this, getImageLoadPrimaryReason(source));
+  }
+  return _createClass(ImageLoadError);
+}(MediaFilePreviewError);
+export function isMediaFilePreviewError(err) {
+  return err instanceof MediaFilePreviewError;
+}
+export var isLocalPreviewError = function isLocalPreviewError(err) {
+  return err instanceof LocalPreviewError;
+};
+export var isRemotePreviewError = function isRemotePreviewError(err) {
+  return err instanceof RemotePreviewError;
+};
+export var isUnsupportedLocalPreviewError = function isUnsupportedLocalPreviewError(err) {
+  return isMediaFilePreviewError(err) && err.primaryReason === 'local-preview-unsupported';
+};
+
+// In a try/catch statement, the error caught is the type of unknown.
+// We can use this helper to ensure that the error handled is the type of MediaFilePreviewError if unsure
+// If updatePrimaryReason is true, if it's a MediaFilePreviewError already, it will update it's primary reason
+export var ensureMediaFilePreviewError = function ensureMediaFilePreviewError(primaryReason, error, updatePrimaryReason) {
+  if (isMediaFilePreviewError(error)) {
+    if (updatePrimaryReason && error.primaryReason !== primaryReason) {
+      return new MediaFilePreviewError(primaryReason, error.secondaryError);
+    }
+    return error;
+  }
+  return new MediaFilePreviewError(primaryReason, error);
+};

package/dist/esm/card/v2/useFilePreview/getPreview/cache.js

@@ -0,0 +1,32 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { createObjectURLCache } from './objectURLCache';
+
+// Dimensions are used to create a key.
+// Cache is invalidated when different dimensions are provided.
+export var getCacheKey = function getCacheKey(id, mode) {
+  var resizeMode = mode || 'crop';
+  return [id, resizeMode].join('-');
+};
+export var CardPreviewCacheImpl = /*#__PURE__*/_createClass(function CardPreviewCacheImpl(previewCache) {
+  var _this = this;
+  _classCallCheck(this, CardPreviewCacheImpl);
+  _defineProperty(this, "get", function (id, mode) {
+    var cacheKey = getCacheKey(id, mode);
+    return _this.previewCache.get(cacheKey);
+  });
+  _defineProperty(this, "set", function (id, mode, cardPreview) {
+    var cacheKey = getCacheKey(id, mode);
+    _this.previewCache.set(cacheKey, cardPreview);
+  });
+  _defineProperty(this, "remove", function (id, mode) {
+    var cacheKey = getCacheKey(id, mode);
+    _this.previewCache.remove(cacheKey);
+  });
+  _defineProperty(this, "clear", function () {
+    _this.previewCache.clear();
+  });
+  this.previewCache = previewCache;
+});
+export var mediaFilePreviewCache = new CardPreviewCacheImpl(createObjectURLCache());