@atlaskit/media-card 77.6.4 → 77.6.6

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

@@ -1,453 +0,0 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-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 { 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 var useFilePreview = function useFilePreview(_ref) {
-  var _ref$resizeMode = _ref.resizeMode,
-    resizeMode = _ref$resizeMode === void 0 ? 'crop' : _ref$resizeMode,
-    identifier = _ref.identifier,
-    ssr = _ref.ssr,
-    dimensions = _ref.dimensions,
-    traceContext = _ref.traceContext,
-    previewDidRender = _ref.previewDidRender,
-    skipRemote = _ref.skipRemote,
-    mediaBlobUrlAttrs = _ref.mediaBlobUrlAttrs;
-  var mediaClient = useMediaClient();
-  var _useState = useState('loading'),
-    _useState2 = _slicedToArray(_useState, 2),
-    status = _useState2[0],
-    setStatus = _useState2[1];
-  var _useState3 = useState(),
-    _useState4 = _slicedToArray(_useState3, 2),
-    error = _useState4[0],
-    setError = _useState4[1];
-  var _useState5 = useState(),
-    _useState6 = _slicedToArray(_useState5, 2),
-    nonCriticalError = _useState6[0],
-    setNonCriticalError = _useState6[1];
-  var _useState7 = useState(false),
-    _useState8 = _slicedToArray(_useState7, 2),
-    isBannedLocalPreview = _useState8[0],
-    setIsBannedLocalPreview = _useState8[1];
-  var wasResolvedUpfrontPreviewRef = useRef(false);
-  var ssrReliabilityRef = useRef(initialSsrReliability);
-  var requestDimensions = useMemo(function () {
-    return dimensions ? createRequestDimensions(dimensions) : undefined;
-  }, [dimensions]);
-  var requestDimensionsRef = useCurrentValueRef(requestDimensions);
-  var prevRequestDimensions = usePrevious(requestDimensions);
-  var imageURLParams = useMemo(function () {
-    return _objectSpread(_objectSpread({
-      collection: identifier.collectionName,
-      mode: resizeMode === 'stretchy-fit' ? 'full-fit' : resizeMode
-    }, requestDimensions), {}, {
-      allowAnimated: true
-    });
-  }, [requestDimensions, identifier.collectionName, resizeMode]);
-  var previewInitializer = function previewInitializer() {
-    var fileImageMode = imageResizeModeToFileImageMode(resizeMode);
-    var preview = mediaFilePreviewCache.get(identifier.id, fileImageMode);
-    if (preview) {
-      return preview;
-    }
-    if (ssr) {
-      var ssrData = getSSRData(identifier);
-      if (ssrData !== null && ssrData !== void 0 && ssrData.error) {
-        ssrReliabilityRef.current.server = _objectSpread({
-          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] = _objectSpread({
-            status: 'fail'
-          }, extractErrorInfo(e));
-        }
-      } else {
-        var _dimensions = ssrData.dimensions,
-          dataURI = ssrData.dataURI;
-        return {
-          dataURI: dataURI,
-          dimensions: _dimensions,
-          source: 'ssr-data'
-        };
-      }
-    }
-  };
-  var _useState9 = useState(previewInitializer),
-    _useState10 = _slicedToArray(_useState9, 2),
-    preview = _useState10[0],
-    setPreview = _useState10[1];
-  var prevPreview = usePrevious(preview);
-  var _useFileState = useFileState(identifier.id, {
-      skipRemote: skipRemote,
-      collectionName: identifier.collectionName,
-      occurrenceKey: identifier.occurrenceKey
-    }),
-    fileState = _useFileState.fileState;
-
-  //----------------------------------------------------------------
-  // Update status
-  //----------------------------------------------------------------
-
-  // TOOD: make a full hook reset (remount) on New identifier or client
-  useEffect(function () {
-    setStatus('loading');
-  }, [identifier]);
-  var updateFileStateRef = useCurrentValueRef(function () {
-    if (fileState) {
-      // do not update the status if the status is final
-      if (['complete', 'error', 'failed-processing'].includes(status)) {
-        return;
-      }
-      if (fileState.status !== 'error') {
-        var mediaType = 'mediaType' in fileState ? fileState.mediaType : undefined;
-        var isPreviewable = !!mediaType && ['audio', 'video', 'image', 'doc'].indexOf(mediaType) > -1;
-        var isPreviewableFileState = !!fileState.preview;
-        var isSupportedLocalPreview = mediaType === 'image' || mediaType === 'video';
-        var hasLocalPreview = !isBannedLocalPreview && isPreviewableFileState && isSupportedLocalPreview && !!fileState.mimeType && isMimeTypeSupportedByBrowser(fileState.mimeType);
-        var hasRemotePreview = isImageRepresentationReady(fileState);
-        var hasPreview = hasLocalPreview || hasRemotePreview;
-        var 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 {
-        var e = new MediaFileStateError(fileState.id, fileState.reason, fileState.message, fileState.details);
-        var errorReason = status === 'uploading' ? 'upload' : 'metadata-fetch';
-        setError(new MediaFilePreviewError(errorReason, e));
-        setStatus('error');
-      }
-    }
-  });
-  useEffect(function () {
-    updateFileStateRef.current();
-  }, [fileState, updateFileStateRef]);
-  useEffect(function () {
-    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
-  //----------------------------------------------------------------
-  var getAndCacheRemotePreviewRef = useCurrentValueRef(function () {
-    return getAndCacheRemotePreview(mediaClient, identifier.id, requestDimensions || {}, imageURLParams, mediaBlobUrlAttrs, traceContext);
-  });
-
-  //----------------------------------------------------------------
-  // Cache SSR Preview
-  //----------------------------------------------------------------
-  useEffect(function () {
-    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(function () {
-        // 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(function () {
-    // 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(function (e) {
-        var wrappedError = ensureMediaFilePreviewError('remote-preview-fetch-ssr', e, true);
-        setNonCriticalError(wrappedError);
-      });
-    }
-  }, [getAndCacheRemotePreviewRef, identifier, preview, requestDimensions, skipRemote]);
-
-  //----------------------------------------------------------------
-  // Upfront Preview
-  //----------------------------------------------------------------
-  useEffect(function () {
-    var resolveUpfrontPreview = /*#__PURE__*/function () {
-      var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        var fetchedDimensions, newPreview, areValidFetchedDimensions;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              // 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;
-              _context.prev = 1;
-              fetchedDimensions = _objectSpread({}, requestDimensions);
-              _context.next = 5;
-              return getAndCacheRemotePreviewRef.current();
-            case 5:
-              newPreview = _context.sent;
-              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);
-              }
-              _context.next = 12;
-              break;
-            case 10:
-              _context.prev = 10;
-              _context.t0 = _context["catch"](1);
-            case 12:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, null, [[1, 10]]);
-      }));
-      return function resolveUpfrontPreview() {
-        return _ref2.apply(this, arguments);
-      };
-    }();
-
-    // CXP-2723 TODO: `hadSSRPreview` is most likely redundant
-    var hadSSRPreview = ssr === 'client' && !!prevPreview && isSSRClientPreview(prevPreview);
-    if (!preview && !wasResolvedUpfrontPreviewRef.current && (!skipRemote || hadSSRPreview)) {
-      resolveUpfrontPreview();
-    }
-  }, [preview, requestDimensions, requestDimensionsRef, getAndCacheRemotePreviewRef, identifier, skipRemote, prevPreview, ssr]);
-
-  //----------------------------------------------------------------
-  // Fetch Preview
-  //----------------------------------------------------------------
-
-  var resolvePreviewRef = useCurrentValueRef( /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(identifier, fileState) {
-      var filePreview, isRemotePreviewReady, mode, cachedPreview, dimensionsAreBigger, localPreview, remotePreview, wrappedError;
-      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
-          case 0:
-            filePreview = isBannedLocalPreview ? undefined : fileState.status !== 'error' && 'mimeType' in fileState && isMimeTypeSupportedByBrowser(fileState.mimeType) ? fileState.preview : undefined;
-            isRemotePreviewReady = isImageRepresentationReady(fileState);
-            _context2.prev = 2;
-            mode = imageURLParams.mode;
-            cachedPreview = mediaFilePreviewCache.get(identifier.id, mode);
-            dimensionsAreBigger = isBigger(cachedPreview === null || cachedPreview === void 0 ? void 0 : cachedPreview.dimensions, requestDimensions);
-            if (!(cachedPreview && !dimensionsAreBigger)) {
-              _context2.next = 8;
-              break;
-            }
-            return _context2.abrupt("return", cachedPreview);
-          case 8:
-            _context2.prev = 8;
-            if (!filePreview) {
-              _context2.next = 15;
-              break;
-            }
-            _context2.next = 12;
-            return getAndCacheLocalPreview(identifier.id, filePreview, requestDimensions || {}, mode, mediaBlobUrlAttrs);
-          case 12:
-            localPreview = _context2.sent;
-            setPreview(localPreview);
-            return _context2.abrupt("return");
-          case 15:
-            _context2.next = 22;
-            break;
-          case 17:
-            _context2.prev = 17;
-            _context2.t0 = _context2["catch"](8);
-            /**
-             * 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(_context2.t0) || isUnsupportedLocalPreviewError(_context2.t0) && !isRemotePreviewReady) {
-              // CXP-2723 TODO: We might have to wrap this error in MediaCardError
-              setNonCriticalError(_context2.t0);
-            }
-            /**
-             * No matter the reason why the local preview failed, we break the process
-             * if there is no remote preview available
-             */
-            if (isRemotePreviewReady) {
-              _context2.next = 22;
-              break;
-            }
-            throw _context2.t0;
-          case 22:
-            if (isRemotePreviewReady) {
-              _context2.next = 24;
-              break;
-            }
-            throw new MediaFilePreviewError('remote-preview-not-ready');
-          case 24:
-            _context2.next = 26;
-            return getAndCacheRemotePreviewRef.current();
-          case 26:
-            remotePreview = _context2.sent;
-            setPreview(remotePreview);
-            return _context2.abrupt("return");
-          case 31:
-            _context2.prev = 31;
-            _context2.t1 = _context2["catch"](2);
-            wrappedError = ensureMediaFilePreviewError('preview-fetch', _context2.t1); //  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);
-              }
-            }
-          case 35:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2, null, [[2, 31], [8, 17]]);
-    }));
-    return function (_x, _x2) {
-      return _ref3.apply(this, arguments);
-    };
-  }());
-  useEffect(function () {
-    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
-  //----------------------------------------------------------------
-
-  var onImageError = useCallback(function (newPreview) {
-    if (newPreview) {
-      var failedSSRObject = _objectSpread({
-        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;
-    }
-    var error = new ImageLoadError(newPreview === null || newPreview === void 0 ? void 0 : newPreview.source);
-    var isLocal = newPreview && isLocalPreview(newPreview);
-    var isSSR = newPreview && (isSSRClientPreview(newPreview) || isSSRDataPreview(newPreview));
-    if (isLocal || isSSR) {
-      if (isLocal) {
-        setIsBannedLocalPreview(true);
-        setNonCriticalError(error);
-      }
-      var 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]);
-  var onImageLoad = useCallback(function (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
-  var getScriptProps = function 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: preview,
-    error: error,
-    nonCriticalError: nonCriticalError,
-    ssrReliabilityRef: ssrReliabilityRef,
-    onImageError: onImageError,
-    onImageLoad: onImageLoad,
-    getScriptProps: getScriptProps
-  };
-};
-var initialSsrReliability = {
-  server: {
-    status: 'unknown'
-  },
-  client: {
-    status: 'unknown'
-  }
-};

package/dist/types/card/v2/useFilePreview/analytics.d.ts

@@ -1,28 +0,0 @@
-import { MediaClientErrorReason } from '@atlaskit/media-client';
-import { SuccessAttributes, MediaTraceContext } from '@atlaskit/media-common';
-import { MediaFilePreviewError, MediaFilePreviewErrorPrimaryReason } from './errors';
-export type FailedErrorFailReason = MediaFilePreviewErrorPrimaryReason | 'nativeError';
-export type MediaFilePreviewErrorInfo = {
-    failReason: FailedErrorFailReason;
-    error: MediaClientErrorReason | 'nativeError';
-    errorDetail: string;
-    metadataTraceContext?: MediaTraceContext;
-};
-export type SSRStatusFail = MediaFilePreviewErrorInfo & {
-    status: 'fail';
-};
-type SSRStatusSuccess = SuccessAttributes;
-type SSRStatusUnknown = {
-    status: 'unknown';
-};
-type SSRStatusAttributes = SSRStatusSuccess | SSRStatusFail | SSRStatusUnknown;
-export type SSRStatus = {
-    server: SSRStatusAttributes;
-    client: SSRStatusAttributes;
-};
-export declare const getErrorTraceContext: (error: MediaFilePreviewError) => MediaTraceContext | undefined;
-export declare const getRenderErrorFailReason: (error: MediaFilePreviewError) => FailedErrorFailReason;
-export declare const getRenderErrorErrorReason: (error: MediaFilePreviewError) => MediaClientErrorReason | 'nativeError';
-export declare const getRenderErrorErrorDetail: (error: MediaFilePreviewError) => string;
-export declare const extractErrorInfo: (error: MediaFilePreviewError, metadataTraceContext?: MediaTraceContext) => MediaFilePreviewErrorInfo;
-export {};

package/dist/types/card/v2/useFilePreview/errors.d.ts

@@ -1,42 +0,0 @@
-import { MediaFileStateError } from '@atlaskit/media-client-react';
-import { MediaClientErrorReason } from '@atlaskit/media-client';
-import { MediaFilePreview } from './types';
-/**
- * Primary reason is logged through Data Portal.
- * Make sure all the values are whitelisted in Measure -> Event Regitry -> "mediaCardRender failed" event
- */
-export type MediaFilePreviewErrorPrimaryReason = 'upload' | 'metadata-fetch' | 'error-file-state' | RemotePreviewPrimaryReason | LocalPreviewPrimaryReason | ImageLoadPrimaryReason | SsrPreviewPrimaryReason | 'missing-error-data' | 'preview-fetch';
-export type ImageLoadPrimaryReason = 'cache-remote-uri' | 'cache-local-uri' | 'local-uri' | 'remote-uri' | 'external-uri' | 'unknown-uri';
-export type RemotePreviewPrimaryReason = 'remote-preview-fetch' | 'remote-preview-not-ready' | 'remote-preview-fetch-ssr';
-export type LocalPreviewPrimaryReason = 'local-preview-get' | 'local-preview-unsupported' | 'local-preview-rejected' | 'local-preview-image' | 'local-preview-video';
-export type SsrPreviewPrimaryReason = 'ssr-client-uri' | 'ssr-client-load' | 'ssr-server-uri' | 'ssr-server-load';
-export declare class MediaFilePreviewError extends Error {
-    readonly primaryReason: MediaFilePreviewErrorPrimaryReason;
-    readonly secondaryError?: Error | undefined;
-    constructor(primaryReason: MediaFilePreviewErrorPrimaryReason, secondaryError?: Error | undefined);
-}
-export declare class LocalPreviewError extends MediaFilePreviewError {
-    readonly primaryReason: LocalPreviewPrimaryReason;
-    readonly secondaryError?: Error | undefined;
-    constructor(primaryReason: LocalPreviewPrimaryReason, secondaryError?: Error | undefined);
-}
-export declare class RemotePreviewError extends MediaFilePreviewError {
-    readonly primaryReason: RemotePreviewPrimaryReason;
-    readonly secondaryError?: Error | undefined;
-    constructor(primaryReason: RemotePreviewPrimaryReason, secondaryError?: Error | undefined);
-}
-export declare class SsrPreviewError extends MediaFilePreviewError {
-    readonly primaryReason: SsrPreviewPrimaryReason;
-    readonly secondaryError?: Error | undefined;
-    constructor(primaryReason: SsrPreviewPrimaryReason, secondaryError?: Error | undefined);
-}
-export declare class ImageLoadError extends MediaFilePreviewError {
-    constructor(source?: MediaFilePreview['source']);
-}
-export declare function isMediaFilePreviewError(err: Error): err is MediaFilePreviewError;
-export declare const isLocalPreviewError: (err: Error) => err is LocalPreviewError;
-export declare const isRemotePreviewError: (err: Error) => err is RemotePreviewError;
-export declare const isUnsupportedLocalPreviewError: (err: Error) => boolean;
-export declare const ensureMediaFilePreviewError: (primaryReason: MediaFilePreviewErrorPrimaryReason, error: Error, updatePrimaryReason?: boolean) => MediaFilePreviewError;
-export declare function isMediaFileStateError(err: Error): err is MediaFileStateError;
-export declare function getFileStateErrorReason(err: MediaFileStateError): MediaClientErrorReason | 'unknown';

package/dist/types/card/v2/useFilePreview/getPreview/cache.d.ts

@@ -1,21 +0,0 @@
-import { ImageResizeMode } from '@atlaskit/media-client';
-import { ObjectURLCache } from './objectURLCache';
-import { MediaFilePreview } from '../types';
-type Mode = ImageResizeMode | undefined;
-export declare const getCacheKey: (id: string, mode: Mode) => string;
-export interface MediaFilePreviewCache {
-    get(id: string, mode: Mode): MediaFilePreview | undefined;
-    set(id: string, mode: Mode, cardPreview: MediaFilePreview): void;
-    remove(id: string, mode: Mode): void;
-    clear(): void;
-}
-export declare class CardPreviewCacheImpl implements MediaFilePreviewCache {
-    private previewCache;
-    constructor(previewCache: ObjectURLCache);
-    get: (id: string, mode: Mode) => MediaFilePreview | undefined;
-    set: (id: string, mode: Mode, cardPreview: MediaFilePreview) => void;
-    remove: (id: string, mode: Mode) => void;
-    clear: () => void;
-}
-export declare const mediaFilePreviewCache: CardPreviewCacheImpl;
-export {};

package/dist/types/card/v2/useFilePreview/getPreview/filePreviewStatus.d.ts

@@ -1,4 +0,0 @@
-import { MediaFilePreviewStatus, FilePreviewStatus } from '../types';
-import { FileState } from '@atlaskit/media-client';
-export declare const extractFilePreviewStatus: (fileState: FileState, isBannedLocalPreview: boolean) => FilePreviewStatus;
-export declare const isPreviewableStatus: (cardStatus: MediaFilePreviewStatus, { isPreviewable, hasPreview, isSupportedByBrowser }: FilePreviewStatus) => boolean;

package/dist/types/card/v2/useFilePreview/getPreview/getPreview.d.ts

@@ -1,9 +0,0 @@
-import { MediaClient, MediaStoreGetFileImageParams, MediaBlobUrlAttrs, FilePreview } from '@atlaskit/media-client';
-import { SSR, MediaTraceContext } from '@atlaskit/media-common';
-import { MediaFilePreviewDimensions, MediaFilePreview } from '../types';
-export declare const getSSRPreview: (ssr: SSR, mediaClient: MediaClient, id: string, params: MediaStoreGetFileImageParams, mediaBlobUrlAttrs?: MediaBlobUrlAttrs) => MediaFilePreview;
-export declare const isLocalPreview: (preview: MediaFilePreview) => boolean;
-export declare const isSSRClientPreview: (preview: MediaFilePreview) => boolean;
-export declare const isSSRDataPreview: (preview: MediaFilePreview) => boolean;
-export declare const getAndCacheRemotePreview: (mediaClient: MediaClient, id: string, dimensions: MediaFilePreviewDimensions, params: MediaStoreGetFileImageParams, mediaBlobUrlAttrs?: MediaBlobUrlAttrs, traceContext?: MediaTraceContext) => Promise<MediaFilePreview>;
-export declare const getAndCacheLocalPreview: (id: string, filePreview: FilePreview | Promise<FilePreview>, dimensions: MediaFilePreviewDimensions, mode: MediaStoreGetFileImageParams['mode'], mediaBlobUrlAttrs?: MediaBlobUrlAttrs) => Promise<MediaFilePreview>;

package/dist/types/card/v2/useFilePreview/getPreview/helpers.d.ts

@@ -1,10 +0,0 @@
-import { MediaClient, FilePreview, MediaStoreGetFileImageParams, MediaType } from '@atlaskit/media-client';
-import { MediaTraceContext } from '@atlaskit/media-common';
-import { MediaFilePreview } from '../types';
-/**
- * This method tells the support for the media
- * types covered in getCardPreviewFromFilePreview
- */
-export declare const isSupportedLocalPreview: (mediaType?: MediaType) => boolean;
-export declare const getLocalPreview: (filePreview: FilePreview | Promise<FilePreview>) => Promise<MediaFilePreview>;
-export declare const getRemotePreview: (mediaClient: MediaClient, id: string, params: MediaStoreGetFileImageParams, traceContext?: MediaTraceContext) => Promise<MediaFilePreview>;

package/dist/types/card/v2/useFilePreview/getPreview/index.d.ts

@@ -1,3 +0,0 @@
-export { mediaFilePreviewCache } from './cache';
-export { isPreviewableStatus, extractFilePreviewStatus, } from './filePreviewStatus';
-export { getSSRPreview, isLocalPreview, isSSRClientPreview, isSSRDataPreview, getAndCacheRemotePreview, getAndCacheLocalPreview, } from './getPreview';

package/dist/types/card/v2/useFilePreview/getPreview/objectURLCache.d.ts

@@ -1,12 +0,0 @@
-import { MediaFilePreview } from '../types';
-export declare const PREVIEW_CACHE_LRU_SIZE = 50;
-export declare class ObjectURLCache {
-    private readonly cache;
-    constructor(size: number);
-    has(key: string): boolean;
-    get(key: string): MediaFilePreview | undefined;
-    set(key: string, value: MediaFilePreview): void;
-    remove(key: string): void;
-    clear(): void;
-}
-export declare const createObjectURLCache: () => ObjectURLCache;

package/dist/types/card/v2/useFilePreview/getPreview/videoSnapshot.d.ts

@@ -1 +0,0 @@
-export declare const takeSnapshot: (blob: Blob) => Promise<string>;

package/dist/types/card/v2/useFilePreview/globalScope/getSSRData.d.ts

@@ -1,3 +0,0 @@
-import type { MediaCardSsrData } from './types';
-import { FileIdentifier } from '@atlaskit/media-client';
-export declare const getSSRData: (identifier: FileIdentifier) => MediaCardSsrData | undefined;

package/dist/types/card/v2/useFilePreview/globalScope/globalScope.d.ts

@@ -1,15 +0,0 @@
-import React from 'react';
-import { FileIdentifier } from '@atlaskit/media-client';
-import { NumericalCardDimensions } from '@atlaskit/media-common';
-import { MediaCardErrorInfo } from '../../../../utils/analytics';
-import { MediaCardSsr } from './types';
-export declare const GLOBAL_MEDIA_CARD_SSR = "mediaCardSsr";
-export declare const GLOBAL_MEDIA_NAMESPACE = "__MEDIA_INTERNAL";
-export type MediaGlobalScope = {
-    [GLOBAL_MEDIA_CARD_SSR]?: MediaCardSsr;
-};
-export declare function getMediaGlobalScope(globalScope?: any): MediaGlobalScope;
-export declare function getMediaCardSSR(globalScope?: any): MediaCardSsr;
-export declare const getKey: ({ id, collectionName, occurrenceKey }: FileIdentifier) => string;
-export declare const storeDataURI: (key: string, dataURI?: string, dimensions?: Partial<NumericalCardDimensions>, error?: MediaCardErrorInfo, globalScope?: any) => void;
-export declare const generateScriptProps: (identifier: FileIdentifier, dataURI?: string, dimensions?: Partial<NumericalCardDimensions>, error?: MediaCardErrorInfo) => React.ScriptHTMLAttributes<HTMLScriptElement>;

package/dist/types/card/v2/useFilePreview/globalScope/index.d.ts

@@ -1,4 +0,0 @@
-export { GLOBAL_MEDIA_NAMESPACE, GLOBAL_MEDIA_CARD_SSR, generateScriptProps, getKey, } from './globalScope';
-export { getSSRData } from './getSSRData';
-export type { MediaCardSsrData, MediaCardSsr } from './types';
-export type { MediaGlobalScope } from './globalScope';

package/dist/types/card/v2/useFilePreview/globalScope/printScript.d.ts

@@ -1,2 +0,0 @@
-export declare const printFunctionCall: <T extends any[]>(fn: (...args: T) => void, ...args: T) => string;
-export declare const printScript: (statements: string[]) => string;

package/dist/types/card/v2/useFilePreview/globalScope/types.d.ts

@@ -1,8 +0,0 @@
-import { NumericalCardDimensions } from '@atlaskit/media-common';
-import { MediaCardErrorInfo } from '../../../../utils/analytics';
-export type MediaCardSsrData = {
-    dataURI?: string;
-    dimensions?: Partial<NumericalCardDimensions>;
-    error?: MediaCardErrorInfo;
-};
-export type MediaCardSsr = Record<string, MediaCardSsrData>;

package/dist/types/card/v2/useFilePreview/helpers.d.ts

@@ -1,11 +0,0 @@
-import { MediaFilePreviewDimensions } from './types';
-import { MutableRefObject } from 'react';
-/**
- * Checks if at least one of next dimensions is bigger than current
- * If a single dimension is undefined, returns false
- */
-export declare const isBigger: (current?: MediaFilePreviewDimensions, next?: MediaFilePreviewDimensions) => boolean;
-export declare const createRequestDimensions: (dimensions: Partial<MediaFilePreviewDimensions>) => Partial<MediaFilePreviewDimensions> | undefined;
-/** Stores the provided value in a ref object to avoid "component rerenders" when the value is used as a hook dependency */
-export declare function useCurrentValueRef<T>(value: T): MutableRefObject<T>;
-export declare function usePrevious<T>(value: T | undefined): T | undefined;

package/dist/types/card/v2/useFilePreview/index.d.ts

@@ -1,2 +0,0 @@
-export { useFilePreview } from './useFilePreview';
-export type { MediaFilePreview } from './types';