@atlaskit/media-card 77.6.4 → 77.6.6

package/dist/es2019/card/v2/useFilePreview/useFilePreview.js

@@ -1,390 +0,0 @@
-import { imageResizeModeToFileImageMode, isImageRepresentationReady } from '@atlaskit/media-client';
-import { MediaFileStateError, useFileState, useMediaClient } from '@atlaskit/media-client-react';
-import { isMimeTypeSupportedByBrowser } from '@atlaskit/media-common';
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { ensureMediaFilePreviewError, ImageLoadError, isLocalPreviewError, isUnsupportedLocalPreviewError, MediaFilePreviewError } from './errors';
-import { extractErrorInfo } from './analytics';
-import { isBigger, createRequestDimensions, useCurrentValueRef, usePrevious } from './helpers';
-import { generateScriptProps, getSSRData } from './globalScope';
-import { getAndCacheRemotePreview, getSSRPreview, isLocalPreview, isSSRClientPreview, isSSRDataPreview, isPreviewableStatus, extractFilePreviewStatus, mediaFilePreviewCache, getAndCacheLocalPreview } from './getPreview';
-export const useFilePreview = ({
-  resizeMode = 'crop',
-  identifier,
-  ssr,
-  dimensions,
-  traceContext,
-  previewDidRender,
-  skipRemote,
-  mediaBlobUrlAttrs
-}) => {
-  const mediaClient = useMediaClient();
-  const [status, setStatus] = useState('loading');
-  const [error, setError] = useState();
-  const [nonCriticalError, setNonCriticalError] = useState();
-  const [isBannedLocalPreview, setIsBannedLocalPreview] = useState(false);
-  const wasResolvedUpfrontPreviewRef = useRef(false);
-  const ssrReliabilityRef = useRef(initialSsrReliability);
-  const requestDimensions = useMemo(() => dimensions ? createRequestDimensions(dimensions) : undefined, [dimensions]);
-  const requestDimensionsRef = useCurrentValueRef(requestDimensions);
-  const prevRequestDimensions = usePrevious(requestDimensions);
-  const imageURLParams = useMemo(() => ({
-    collection: identifier.collectionName,
-    mode: resizeMode === 'stretchy-fit' ? 'full-fit' : resizeMode,
-    ...requestDimensions,
-    allowAnimated: true
-  }), [requestDimensions, identifier.collectionName, resizeMode]);
-  const previewInitializer = () => {
-    const fileImageMode = imageResizeModeToFileImageMode(resizeMode);
-    const preview = mediaFilePreviewCache.get(identifier.id, fileImageMode);
-    if (preview) {
-      return preview;
-    }
-    if (ssr) {
-      const ssrData = getSSRData(identifier);
-      if (ssrData !== null && ssrData !== void 0 && ssrData.error) {
-        ssrReliabilityRef.current.server = {
-          status: 'fail',
-          ...ssrData.error
-        };
-      }
-      if (!(ssrData !== null && ssrData !== void 0 && ssrData.dataURI)) {
-        try {
-          return getSSRPreview(ssr, mediaClient, identifier.id, imageURLParams, mediaBlobUrlAttrs);
-        } catch (e) {
-          ssrReliabilityRef.current[ssr] = {
-            status: 'fail',
-            ...extractErrorInfo(e)
-          };
-        }
-      } else {
-        const {
-          dimensions,
-          dataURI
-        } = ssrData;
-        return {
-          dataURI,
-          dimensions,
-          source: 'ssr-data'
-        };
-      }
-    }
-  };
-  const [preview, setPreview] = useState(previewInitializer);
-  const prevPreview = usePrevious(preview);
-  const {
-    fileState
-  } = useFileState(identifier.id, {
-    skipRemote,
-    collectionName: identifier.collectionName,
-    occurrenceKey: identifier.occurrenceKey
-  });
-
-  //----------------------------------------------------------------
-  // Update status
-  //----------------------------------------------------------------
-
-  // TOOD: make a full hook reset (remount) on New identifier or client
-  useEffect(() => {
-    setStatus('loading');
-  }, [identifier]);
-  const updateFileStateRef = useCurrentValueRef(() => {
-    if (fileState) {
-      // do not update the status if the status is final
-      if (['complete', 'error', 'failed-processing'].includes(status)) {
-        return;
-      }
-      if (fileState.status !== 'error') {
-        const mediaType = 'mediaType' in fileState ? fileState.mediaType : undefined;
-        const isPreviewable = !!mediaType && ['audio', 'video', 'image', 'doc'].indexOf(mediaType) > -1;
-        const isPreviewableFileState = !!fileState.preview;
-        const isSupportedLocalPreview = mediaType === 'image' || mediaType === 'video';
-        const hasLocalPreview = !isBannedLocalPreview && isPreviewableFileState && isSupportedLocalPreview && !!fileState.mimeType && isMimeTypeSupportedByBrowser(fileState.mimeType);
-        const hasRemotePreview = isImageRepresentationReady(fileState);
-        const hasPreview = hasLocalPreview || hasRemotePreview;
-        let newStatus;
-        switch (fileState.status) {
-          case 'uploading':
-          case 'failed-processing':
-          case 'processing':
-            newStatus = fileState.status;
-            break;
-          case 'processed':
-            if (!isPreviewable || !hasPreview) {
-              newStatus = 'complete';
-              break;
-            }
-            newStatus = 'loading-preview';
-            break;
-          default:
-            newStatus = 'loading';
-        }
-        setStatus(newStatus);
-      } else {
-        const e = new MediaFileStateError(fileState.id, fileState.reason, fileState.message, fileState.details);
-        const errorReason = status === 'uploading' ? 'upload' : 'metadata-fetch';
-        setError(new MediaFilePreviewError(errorReason, e));
-        setStatus('error');
-      }
-    }
-  });
-  useEffect(() => {
-    updateFileStateRef.current();
-  }, [fileState, updateFileStateRef]);
-  useEffect(() => {
-    if (previewDidRender &&
-    // We should't complete if status is uploading
-    ['loading-preview', 'processing'].includes(status)) {
-      setStatus('complete');
-      // TODO MEX-788: add test for "do not remove the preview when unsubscribing".
-      setIsBannedLocalPreview(false); // CXP-2723 TODO: we might be able to remove this??
-    }
-  }, [previewDidRender, status]);
-
-  // CXP-2723 TODO: Create test cases for banning local preview after status is complete
-
-  //----------------------------------------------------------------
-  // Preview Fetch Helper
-  //----------------------------------------------------------------
-  const getAndCacheRemotePreviewRef = useCurrentValueRef(() => {
-    return getAndCacheRemotePreview(mediaClient, identifier.id, requestDimensions || {}, imageURLParams, mediaBlobUrlAttrs, traceContext);
-  });
-
-  //----------------------------------------------------------------
-  // Cache SSR Preview
-  //----------------------------------------------------------------
-  useEffect(() => {
-    if (!skipRemote && ssr && !!preview && isSSRClientPreview(preview)) {
-      // Since the SSR preview brings the token in the query params,
-      // We need to fetch the remote preview to be able to cache it,
-      getAndCacheRemotePreviewRef.current().catch(() => {
-        // No need to log this error.
-        // If preview fails, it will be refetched later
-        //TODO: test this catch
-        // https://product-fabric.atlassian.net/browse/MEX-1071
-      });
-    }
-  }, [preview, identifier, skipRemote, ssr, getAndCacheRemotePreviewRef]);
-
-  //----------------------------------------------------------------
-  // Refetch SRR Preview if dimensions from Server have changed and are bigger,
-  //----------------------------------------------------------------
-  useEffect(() => {
-    // CXP-2813 TODO: This is called too many times if the refetch failed. Should be called only once
-    if (preview && !skipRemote && isSSRDataPreview(preview) && isBigger(preview.dimensions, requestDimensions)) {
-      getAndCacheRemotePreviewRef.current().then(setPreview).catch(e => {
-        const wrappedError = ensureMediaFilePreviewError('remote-preview-fetch-ssr', e, true);
-        setNonCriticalError(wrappedError);
-      });
-    }
-  }, [getAndCacheRemotePreviewRef, identifier, preview, requestDimensions, skipRemote]);
-
-  //----------------------------------------------------------------
-  // Upfront Preview
-  //----------------------------------------------------------------
-  useEffect(() => {
-    const resolveUpfrontPreview = async () => {
-      // We block any possible future call to this method regardless of the outcome (success or fail)
-      // If it fails, the normal preview fetch should occur after the file state is fetched anyways
-      wasResolvedUpfrontPreviewRef.current = true;
-      try {
-        const fetchedDimensions = {
-          ...requestDimensions
-        };
-        const newPreview = await getAndCacheRemotePreviewRef.current();
-        const areValidFetchedDimensions = !isBigger(fetchedDimensions, requestDimensionsRef.current);
-
-        // If there are new and bigger dimensions in the props, and the upfront preview is still resolving,
-        // the fetched preview is no longer valid, and thus, we dismiss it
-        if (areValidFetchedDimensions) {
-          setPreview(newPreview);
-        }
-      } catch (e) {
-        // NO need to log error. If this call fails, a refetch will happen after
-      }
-    };
-
-    // CXP-2723 TODO: `hadSSRPreview` is most likely redundant
-    const hadSSRPreview = ssr === 'client' && !!prevPreview && isSSRClientPreview(prevPreview);
-    if (!preview && !wasResolvedUpfrontPreviewRef.current && (!skipRemote || hadSSRPreview)) {
-      resolveUpfrontPreview();
-    }
-  }, [preview, requestDimensions, requestDimensionsRef, getAndCacheRemotePreviewRef, identifier, skipRemote, prevPreview, ssr]);
-
-  //----------------------------------------------------------------
-  // Fetch Preview
-  //----------------------------------------------------------------
-
-  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 = mediaFilePreviewCache.get(identifier.id, mode);
-      const dimensionsAreBigger = isBigger(cachedPreview === null || cachedPreview === void 0 ? void 0 : cachedPreview.dimensions, requestDimensions);
-      if (cachedPreview && !dimensionsAreBigger) {
-        return cachedPreview;
-      }
-      try {
-        if (filePreview) {
-          const localPreview = await getAndCacheLocalPreview(identifier.id, filePreview, requestDimensions || {}, mode, mediaBlobUrlAttrs);
-          setPreview(localPreview);
-          return;
-        }
-      } catch (e) {
-        /**
-         * 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(e) || isUnsupportedLocalPreviewError(e) && !isRemotePreviewReady) {
-          // CXP-2723 TODO: We might have to wrap this error in MediaCardError
-          setNonCriticalError(e);
-        }
-        /**
-         * No matter the reason why the local preview failed, we break the process
-         * if there is no remote preview available
-         */
-        if (!isRemotePreviewReady) {
-          throw e;
-        }
-      }
-      if (!isRemotePreviewReady) {
-        /**
-         * We throw this in case this function has been called
-         * without checking isRemotePreviewReady first.
-         * If remote preview is not ready, the call to getCardPreviewFromBackend
-         * will generate a console error due to a 404 code
-         */
-        throw new MediaFilePreviewError('remote-preview-not-ready');
-      }
-      const remotePreview = await getAndCacheRemotePreviewRef.current();
-      setPreview(remotePreview);
-      return;
-    } catch (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
-      //  If it's any other error we set status 'error'
-      if (isLocalPreviewError(wrappedError)) {
-        // This error should already been logged inside the getCardPreview. No need to log it here.
-        setIsBannedLocalPreview(true);
-      } else {
-        if (!['complete', 'error', 'failed-processing'].includes(status)) {
-          setStatus('error');
-          setError(wrappedError);
-        }
-      }
-    }
-  });
-  useEffect(() => {
-    if (fileState && wasResolvedUpfrontPreviewRef.current && isPreviewableStatus(status, extractFilePreviewStatus(fileState, isBannedLocalPreview)) && (!preview || isBigger(prevRequestDimensions, requestDimensions))) {
-      resolvePreviewRef.current(identifier, fileState);
-    }
-  }, [fileState, identifier, isBannedLocalPreview, prevRequestDimensions, preview, requestDimensions, resolvePreviewRef, status]);
-
-  //----------------------------------------------------------------
-  // RETURN
-  //----------------------------------------------------------------
-
-  const onImageError = useCallback(newPreview => {
-    if (newPreview) {
-      const failedSSRObject = {
-        status: 'fail',
-        ...extractErrorInfo(new ImageLoadError(newPreview.source))
-      };
-      if (isSSRClientPreview(newPreview)) {
-        ssrReliabilityRef.current.client = failedSSRObject;
-      }
-
-      /*
-      If the preview failed and it comes from server (global scope / ssrData), it means that we have reused it in client and the error counts for both: server & client.
-      */
-
-      if (isSSRDataPreview(newPreview)) {
-        ssrReliabilityRef.current.server = failedSSRObject;
-        ssrReliabilityRef.current.client = failedSSRObject;
-      }
-    }
-
-    // If the dataURI has been replaced, we can dismiss this error
-    if ((newPreview === null || newPreview === void 0 ? void 0 : newPreview.dataURI) !== (preview === null || preview === void 0 ? void 0 : preview.dataURI)) {
-      return;
-    }
-    const error = new ImageLoadError(newPreview === null || newPreview === void 0 ? void 0 : newPreview.source);
-    const isLocal = newPreview && isLocalPreview(newPreview);
-    const isSSR = newPreview && (isSSRClientPreview(newPreview) || isSSRDataPreview(newPreview));
-    if (isLocal || isSSR) {
-      if (isLocal) {
-        setIsBannedLocalPreview(true);
-        setNonCriticalError(error);
-      }
-      const fileImageMode = imageResizeModeToFileImageMode(resizeMode);
-      mediaFilePreviewCache.remove(identifier.id, fileImageMode);
-      setPreview(undefined);
-    } else {
-      if (!['complete', 'error', 'failed-processing'].includes(status)) {
-        setStatus('error');
-        setError(error);
-      }
-    }
-  }, [identifier.id, preview === null || preview === void 0 ? void 0 : preview.dataURI, resizeMode, status]);
-  const onImageLoad = useCallback(newPreview => {
-    if (newPreview) {
-      if (isSSRClientPreview(newPreview) && ssrReliabilityRef.current.client.status === 'unknown') {
-        ssrReliabilityRef.current.client = {
-          status: 'success'
-        };
-      }
-
-      /*
-      If the image loads successfully and it comes from server (global scope / ssrData), it means that we have reused it in client and the success counts for both: server & client.
-      */
-
-      if (isSSRDataPreview(newPreview) && ssrReliabilityRef.current.server.status === 'unknown') {
-        ssrReliabilityRef.current.server = {
-          status: 'success'
-        };
-        ssrReliabilityRef.current.client = {
-          status: 'success'
-        };
-      }
-    }
-
-    // If the dataURI has been replaced, we can dismiss this callback
-    if ((newPreview === null || newPreview === void 0 ? void 0 : newPreview.dataURI) !== (preview === null || preview === void 0 ? void 0 : preview.dataURI)) {
-      return;
-    }
-  }, [preview === null || preview === void 0 ? void 0 : preview.dataURI]);
-
-  // FOR SSR
-  const getScriptProps = () => {
-    var _ssrReliabilityRef$cu;
-    return generateScriptProps(identifier, preview === null || preview === void 0 ? void 0 : preview.dataURI, requestDimensions, ((_ssrReliabilityRef$cu = ssrReliabilityRef.current.server) === null || _ssrReliabilityRef$cu === void 0 ? void 0 : _ssrReliabilityRef$cu.status) === 'fail' ? ssrReliabilityRef.current.server : undefined);
-  };
-
-  // CXP-2723 TODO: should consider simplifying our analytics, and how
-  // we might get rid of ssrReliabiltyRef from our hook
-  return {
-    preview,
-    error,
-    nonCriticalError,
-    ssrReliabilityRef,
-    onImageError,
-    onImageLoad,
-    getScriptProps
-  };
-};
-const initialSsrReliability = {
-  server: {
-    status: 'unknown'
-  },
-  client: {
-    status: 'unknown'
-  }
-};

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

@@ -1,44 +0,0 @@
-import { getMediaClientErrorReason, isRequestError } from '@atlaskit/media-client';
-import { isMediaFilePreviewError, getFileStateErrorReason, isMediaFileStateError } from './errors';
-export var getErrorTraceContext = function getErrorTraceContext(error) {
-  if (isMediaFilePreviewError(error) && !!error.secondaryError) {
-    if (isRequestError(error.secondaryError)) {
-      var _error$secondaryError;
-      return (_error$secondaryError = error.secondaryError.metadata) === null || _error$secondaryError === void 0 ? void 0 : _error$secondaryError.traceContext;
-    } else if (isMediaFileStateError(error.secondaryError)) {
-      var _error$secondaryError2;
-      return (_error$secondaryError2 = error.secondaryError.details) === null || _error$secondaryError2 === void 0 || (_error$secondaryError2 = _error$secondaryError2.metadata) === null || _error$secondaryError2 === void 0 ? void 0 : _error$secondaryError2.traceContext;
-    }
-  }
-};
-export var getRenderErrorFailReason = function getRenderErrorFailReason(error) {
-  if (isMediaFilePreviewError(error)) {
-    return error.primaryReason;
-  } else {
-    return 'nativeError';
-  }
-};
-export var getRenderErrorErrorReason = function getRenderErrorErrorReason(error) {
-  if (isMediaFilePreviewError(error) && error.secondaryError) {
-    var mediaClientReason = isMediaFileStateError(error.secondaryError) ? getFileStateErrorReason(error.secondaryError) : getMediaClientErrorReason(error.secondaryError);
-    if (mediaClientReason !== 'unknown') {
-      return mediaClientReason;
-    }
-  }
-  return 'nativeError';
-};
-export var getRenderErrorErrorDetail = function getRenderErrorErrorDetail(error) {
-  if (isMediaFilePreviewError(error) && error.secondaryError) {
-    return error.secondaryError.message;
-  } else {
-    return error.message;
-  }
-};
-export var extractErrorInfo = function extractErrorInfo(error, metadataTraceContext) {
-  return {
-    failReason: getRenderErrorFailReason(error),
-    error: getRenderErrorErrorReason(error),
-    errorDetail: getRenderErrorErrorDetail(error),
-    metadataTraceContext: metadataTraceContext !== null && metadataTraceContext !== void 0 ? metadataTraceContext : getErrorTraceContext(error)
-  };
-};

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

@@ -1,133 +0,0 @@
-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; } }
-import { MediaFileStateError } from '@atlaskit/media-client-react';
-
-/**
- * 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);
-};
-export function isMediaFileStateError(err) {
-  return err instanceof MediaFileStateError;
-}
-export function getFileStateErrorReason(err) {
-  var _err$details$reason, _err$details;
-  return (_err$details$reason = (_err$details = err.details) === null || _err$details === void 0 ? void 0 : _err$details.reason) !== null && _err$details$reason !== void 0 ? _err$details$reason : 'unknown';
-}

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

@@ -1,32 +0,0 @@
-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());

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

@@ -1,40 +0,0 @@
-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) {
-  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);
-
-  // 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
-  };
-};
-
-// CXP-2723 TODO: Review this in relation to removing status from the hook
-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' ||
-  // For Video, we can have local or remote preview while processing.
-  // Then, we only want to show the thumbnail if the file is supported by the browser,
-  // this way we prevent playing unsupported videos that are not procesed
-  cardStatus === 'processing' && isSupportedByBrowser);
-};