@atlaskit/media-file-preview 0.0.1

package/dist/esm/globalScope/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/helpers.js

@@ -0,0 +1,49 @@
+import { useRef } from 'react';
+/**
+ * Checks if at least one of next dimensions is bigger than current
+ * If a single dimension is undefined, returns false
+ */
+export var isBigger = function isBigger(current, next) {
+  var _ref = current || {},
+    currentWidth = _ref.width,
+    currentHeight = _ref.height;
+  var _ref2 = next || {},
+    nextWidth = _ref2.width,
+    nextHeight = _ref2.height;
+  if (!!currentWidth && !!currentHeight && !!nextWidth && !!nextHeight) {
+    var nextIsWider = currentWidth < nextWidth;
+    var nextIsHigher = currentHeight < nextHeight;
+    return nextIsHigher || nextIsWider;
+  } else {
+    return false;
+  }
+};
+
+/** Verifies if the current screen is retina display */
+function isRetina() {
+  var mediaQuery = '(-webkit-min-device-pixel-ratio: 1.5), (min--moz-device-pixel-ratio: 1.5), (-o-min-device-pixel-ratio: 3/2), (min-resolution: 1.5dppx)';
+  return window.devicePixelRatio > 1 || window.matchMedia && window.matchMedia(mediaQuery).matches;
+}
+export var createRequestDimensions = function createRequestDimensions(dimensions) {
+  if (!dimensions) {
+    return;
+  }
+  var retinaFactor = isRetina() ? 2 : 1;
+  var width = dimensions.width,
+    height = dimensions.height;
+  var result = {};
+  if (width) {
+    result.width = width * retinaFactor;
+  }
+  if (height) {
+    result.height = height * retinaFactor;
+  }
+  return result;
+};
+
+/** Stores the provided value in a ref object to avoid "component rerenders" when the value is used as a hook dependency */
+export function useCurrentValueRef(value) {
+  var ref = useRef(value);
+  ref.current = value;
+  return ref;
+}

package/dist/esm/index.js

@@ -0,0 +1 @@
+export { useFilePreview } from './useFilePreview';

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/useFilePreview.js

@@ -0,0 +1,348 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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 { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { imageResizeModeToFileImageMode, isImageRepresentationReady } from '@atlaskit/media-client';
+import { MediaFileStateError, useFileState, useMediaClient } from '@atlaskit/media-client-react';
+import { isMimeTypeSupportedByBrowser } from '@atlaskit/media-common';
+import { extractErrorInfo } from './analytics';
+import { ensureMediaFilePreviewError, ImageLoadError, MediaFilePreviewError } from './errors';
+import { getAndCacheLocalPreview, getAndCacheRemotePreview, getSSRPreview, isLocalPreview, isSSRClientPreview, isSSRDataPreview, isSupportedLocalPreview, mediaFilePreviewCache } from './getPreview';
+import { generateScriptProps, getSSRData } from './globalScope';
+import { createRequestDimensions, isBigger, useCurrentValueRef } from './helpers';
+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 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 _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
+      });
+    }
+  }, [getAndCacheRemotePreviewRef, preview, skipRemote, ssr]);
+
+  //----------------------------------------------------------------
+  // 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, preview, requestDimensions, skipRemote]);
+
+  //----------------------------------------------------------------
+  // Upfront Preview
+  //----------------------------------------------------------------
+  useEffect(function () {
+    if (!preview && !wasResolvedUpfrontPreviewRef.current && !skipRemote) {
+      // 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;
+      var fetchedDimensions = _objectSpread({}, requestDimensions);
+      getAndCacheRemotePreviewRef.current().then(function (newPreview) {
+        // 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 (!isBigger(fetchedDimensions, requestDimensionsRef.current)) {
+          setPreview(newPreview);
+        }
+      }).catch(function () {
+        // NO need to log error. If this call fails, a refetch will happen after
+      });
+    }
+  }, [getAndCacheRemotePreviewRef, preview, requestDimensions, requestDimensionsRef, skipRemote]);
+
+  //----------------------------------------------------------------
+  // Cache, Local & Remote Preview
+  //----------------------------------------------------------------
+
+  useEffect(function () {
+    var cachedPreview = mediaFilePreviewCache.get(identifier.id, imageURLParams.mode);
+
+    // Cached Preview ----------------------------------------------------------------
+    if (!preview && cachedPreview && !isBigger(cachedPreview === null || cachedPreview === void 0 ? void 0 : cachedPreview.dimensions, requestDimensions)) {
+      setPreview(cachedPreview);
+    }
+    // Local Preview ----------------------------------------------------------------
+    else if (!preview && !isBannedLocalPreview && !!fileState && 'preview' in fileState && !!fileState.preview && isSupportedLocalPreview(fileState.mediaType) && isMimeTypeSupportedByBrowser(fileState.mimeType)) {
+      // 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
+
+      getAndCacheLocalPreview(identifier.id, fileState.preview, requestDimensions || {}, imageURLParams.mode, mediaBlobUrlAttrs).then(setPreview).catch(function (e) {
+        setIsBannedLocalPreview(true);
+        // CXP-2723 TODO: We might have to wrap this error in MediaCardError
+        setNonCriticalError(e);
+      });
+    }
+    // Remote Preview ----------------------------------------------------------------
+    else if ((!preview || isBigger(preview.dimensions, requestDimensions)) && !skipRemote && wasResolvedUpfrontPreviewRef.current && !!fileState && isImageRepresentationReady(fileState)) {
+      getAndCacheRemotePreviewRef.current().then(setPreview).catch(function (e) {
+        setStatus('error');
+        setError(ensureMediaFilePreviewError('preview-fetch', e));
+      });
+    }
+  }, [fileState, getAndCacheRemotePreviewRef, identifier.id, imageURLParams.mode, isBannedLocalPreview, mediaBlobUrlAttrs, preview, requestDimensions, skipRemote]);
+
+  //----------------------------------------------------------------
+  // 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/analytics.d.ts

@@ -0,0 +1,28 @@
+import { MediaClientErrorReason } from '@atlaskit/media-client';
+import { MediaTraceContext, SuccessAttributes } 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/errors.d.ts

@@ -0,0 +1,42 @@
+import { MediaClientErrorReason } from '@atlaskit/media-client';
+import { MediaFileStateError } from '@atlaskit/media-client-react';
+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/getPreview/cache.d.ts

@@ -0,0 +1,21 @@
+import { ImageResizeMode } from '@atlaskit/media-client';
+import { MediaFilePreview } from '../types';
+import { ObjectURLCache } from './objectURLCache';
+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/getPreview/getPreview.d.ts

@@ -0,0 +1,9 @@
+import { FilePreview, MediaBlobUrlAttrs, MediaClient, MediaStoreGetFileImageParams } from '@atlaskit/media-client';
+import { MediaTraceContext, SSR } from '@atlaskit/media-common';
+import { MediaFilePreview, MediaFilePreviewDimensions } 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/getPreview/helpers.d.ts

@@ -0,0 +1,10 @@
+import { FilePreview, MediaClient, 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/getPreview/index.d.ts

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

package/dist/types/getPreview/objectURLCache.d.ts

@@ -0,0 +1,12 @@
+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/getPreview/videoSnapshot.d.ts

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

package/dist/types/globalScope/getSSRData.d.ts

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

package/dist/types/globalScope/globalScope.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { FileIdentifier } from '@atlaskit/media-client';
+import { NumericalCardDimensions } from '@atlaskit/media-common';
+import { MediaFilePreviewErrorInfo } from '../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?: MediaFilePreviewErrorInfo, globalScope?: any) => void;
+export declare const generateScriptProps: (identifier: FileIdentifier, dataURI?: string, dimensions?: Partial<NumericalCardDimensions>, error?: MediaFilePreviewErrorInfo) => React.ScriptHTMLAttributes<HTMLScriptElement>;

package/dist/types/globalScope/index.d.ts

@@ -0,0 +1,4 @@
+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/globalScope/printScript.d.ts

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

package/dist/types/globalScope/types.d.ts

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

package/dist/types/helpers.d.ts

@@ -0,0 +1,10 @@
+import { MutableRefObject } from 'react';
+import { MediaFilePreviewDimensions } from './types';
+/**
+ * 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>;

package/dist/types/index.d.ts

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

package/dist/types/types.d.ts

@@ -0,0 +1,12 @@
+export type MediaFilePreviewSource = 'local' | 'remote' | 'ssr-server' | 'ssr-client' | 'ssr-data' | 'cache-local' | 'cache-remote' | 'cache-ssr-client' | 'cache-ssr-server' | 'external';
+export type MediaFilePreviewDimensions = {
+    width?: number;
+    height?: number;
+};
+export interface MediaFilePreview {
+    dataURI: string;
+    orientation?: number;
+    dimensions?: MediaFilePreviewDimensions;
+    source: MediaFilePreviewSource;
+}
+export type MediaFilePreviewStatus = 'uploading' | 'loading' | 'processing' | 'loading-preview' | 'complete' | 'error' | 'failed-processing';

package/dist/types/useFilePreview.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="react" />
+import { FileIdentifier, ImageResizeMode, MediaBlobUrlAttrs } from '@atlaskit/media-client';
+import { MediaTraceContext, SSR } from '@atlaskit/media-common';
+import { SSRStatus } from './analytics';
+import { MediaFilePreviewError } from './errors';
+import { MediaFilePreview, MediaFilePreviewDimensions } from './types';
+export interface UseFilePreviewParams {
+    /** Instance of file identifier. */
+    readonly identifier: FileIdentifier;
+    /** Resize the media to 'crop' | 'fit' | 'full-fit' | 'stretchy-fit' */
+    readonly resizeMode?: ImageResizeMode;
+    /** Dimensions to be requested to the server. Will be scaled x2 in Retina Displays */
+    readonly dimensions?: MediaFilePreviewDimensions;
+    /** Server-Side-Rendering modes are "server" and "client" */
+    readonly ssr?: SSR;
+    /** Attributes to attach to the created Blob Url */
+    readonly mediaBlobUrlAttrs?: MediaBlobUrlAttrs;
+    /** Trace context to be passed to the backend requests */
+    readonly traceContext?: MediaTraceContext;
+    /** Notify the hook that the preview successfully rendered */
+    readonly previewDidRender?: boolean;
+    /** Do not fetch a remote preview. Helpful for lazy loading */
+    readonly skipRemote?: boolean;
+}
+export declare const useFilePreview: ({ resizeMode, identifier, ssr, dimensions, traceContext, previewDidRender, skipRemote, mediaBlobUrlAttrs, }: UseFilePreviewParams) => {
+    preview: MediaFilePreview | undefined;
+    error: MediaFilePreviewError | undefined;
+    nonCriticalError: MediaFilePreviewError | undefined;
+    ssrReliabilityRef: import("react").MutableRefObject<SSRStatus>;
+    onImageError: (newPreview?: MediaFilePreview) => void;
+    onImageLoad: (newPreview?: MediaFilePreview) => void;
+    getScriptProps: () => import("react").ScriptHTMLAttributes<HTMLScriptElement>;
+};