@atlaskit/media-card 77.4.10 → 77.5.1

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

@@ -4,21 +4,15 @@ 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 { addFileAttrsToUrl, imageResizeModeToFileImageMode, isImageRepresentationReady } from '@atlaskit/media-client';
+import { imageResizeModeToFileImageMode, isImageRepresentationReady } from '@atlaskit/media-client';
 import { MediaFileStateError, useFileState, useMediaClient } from '@atlaskit/media-client-react';
-import { getMediaTypeFromMimeType, isMimeTypeSupportedByBrowser } from '@atlaskit/media-common';
-import { getOrientation } from '@atlaskit/media-ui';
+import { isMimeTypeSupportedByBrowser } from '@atlaskit/media-common';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { ensureMediaCardError, ImageLoadError, isLocalPreviewError, isUnsupportedLocalPreviewError, LocalPreviewError, MediaCardError } from '../../errors';
-import { extractErrorInfo } from '../../utils/analytics';
-import { isBigger } from '../../utils/dimensionComparer';
-import { isRetina } from '../../utils/isRetina';
-import { generateScriptProps, getSSRData } from '../../utils/globalScope';
-import { useCurrentValueRef } from '../../utils/useCurrentValueRef';
-import { usePrevious } from '../../utils/usePrevious';
-import { takeSnapshot } from '../../utils/videoSnapshot';
-import { fetchAndCacheRemotePreview, getCardPreviewFromCache, getSSRCardPreview, isLocalPreview, isSSRClientPreview, isSSRDataPreview, removeCardPreviewFromCache, shouldResolvePreview } from '../getCardPreview';
-import cardPreviewCache from '../getCardPreview/cache';
+import { ensureMediaFilePreviewError, ImageLoadError, isLocalPreviewError, isUnsupportedLocalPreviewError, MediaFilePreviewError } from './errors';
+import { extractErrorInfo } from '../../../utils/analytics';
+import { isBigger, createRequestDimensions, useCurrentValueRef, usePrevious } from './helpers';
+import { generateScriptProps, getSSRData } from './globalScope';
+import { getAndCacheRemotePreview, getSSRCardPreview, isLocalPreview, isSSRClientPreview, isSSRDataPreview, isPreviewableStatus, extractFilePreviewStatus, mediaFilePreviewCache, getAndCacheLocalPreview } from './getPreview';
 export var useFilePreview = function useFilePreview(_ref) {
   var _ref$resizeMode = _ref.resizeMode,
     resizeMode = _ref$resizeMode === void 0 ? 'crop' : _ref$resizeMode,
@@ -88,7 +82,7 @@ export var useFilePreview = function useFilePreview(_ref) {
     var cardPreview;
     var id = identifier.id;
     var fileImageMode = imageResizeModeToFileImageMode(resizeMode);
-    cardPreview = getCardPreviewFromCache(id, fileImageMode);
+    cardPreview = mediaFilePreviewCache.get(id, fileImageMode);
     if (!cardPreview && ssr) {
       cardPreview = getSSRPreview(ssr, identifier, mediaClient);
     }
@@ -113,11 +107,11 @@ export var useFilePreview = function useFilePreview(_ref) {
   //----------------------------------------------------------------//
 
   var fetchRemotePreviewRef = useCurrentValueRef(function (identifier) {
-    return fetchAndCacheRemotePreview(mediaClient, identifier.id, requestDimensions || {}, imageURLParams, mediaBlobUrlAttrs, traceContext);
+    return getAndCacheRemotePreview(mediaClient, identifier.id, requestDimensions || {}, imageURLParams, mediaBlobUrlAttrs, traceContext);
   });
   var resolvePreviewRef = useCurrentValueRef( /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(identifier, fileState) {
-      var filePreview, isRemotePreviewReady, mode, cachedPreview, dimensionsAreBigger, localPreview, value, resolvedFilePreview, _value, type, mediaType, orientation, _dataURI, _dataURI2, preview, source, dataURI, remotePreview, wrappedError;
+      var filePreview, isRemotePreviewReady, mode, cachedPreview, dimensionsAreBigger, localPreview, remotePreview, wrappedError;
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
@@ -125,7 +119,7 @@ export var useFilePreview = function useFilePreview(_ref) {
             isRemotePreviewReady = isImageRepresentationReady(fileState);
             _context.prev = 2;
             mode = imageURLParams.mode;
-            cachedPreview = cardPreviewCache.get(identifier.id, mode);
+            cachedPreview = mediaFilePreviewCache.get(identifier.id, mode);
             dimensionsAreBigger = isBigger(cachedPreview === null || cachedPreview === void 0 ? void 0 : cachedPreview.dimensions, requestDimensions);
             if (!(cachedPreview && !dimensionsAreBigger)) {
               _context.next = 8;
@@ -135,127 +129,21 @@ export var useFilePreview = function useFilePreview(_ref) {
           case 8:
             _context.prev = 8;
             if (!filePreview) {
-              _context.next = 74;
+              _context.next = 15;
               break;
             }
-            _context.prev = 10;
-            _context.next = 13;
-            return filePreview;
-          case 13:
-            resolvedFilePreview = _context.sent;
-            value = resolvedFilePreview.value;
-            _context.next = 20;
+            _context.next = 12;
+            return getAndCacheLocalPreview(identifier.id, filePreview, requestDimensions || {}, mode, mediaBlobUrlAttrs);
+          case 12:
+            localPreview = _context.sent;
+            setCardPreview(localPreview);
+            return _context.abrupt("return");
+          case 15:
+            _context.next = 22;
             break;
           case 17:
             _context.prev = 17;
-            _context.t0 = _context["catch"](10);
-            throw new LocalPreviewError('local-preview-rejected', _context.t0 instanceof Error ? _context.t0 : undefined);
-          case 20:
-            if (!(typeof value === 'string')) {
-              _context.next = 24;
-              break;
-            }
-            localPreview = {
-              dataURI: value,
-              orientation: 1,
-              source: 'local'
-            };
-            _context.next = 57;
-            break;
-          case 24:
-            if (!(value instanceof Blob)) {
-              _context.next = 56;
-              break;
-            }
-            _value = value, type = _value.type;
-            mediaType = getMediaTypeFromMimeType(type);
-            _context.t1 = mediaType;
-            _context.next = _context.t1 === 'image' ? 30 : _context.t1 === 'video' ? 42 : 53;
-            break;
-          case 30:
-            _context.prev = 30;
-            _context.next = 33;
-            return getOrientation(value);
-          case 33:
-            orientation = _context.sent;
-            _dataURI = URL.createObjectURL(value);
-            localPreview = {
-              dataURI: _dataURI,
-              orientation: orientation,
-              source: 'local'
-            };
-            _context.next = 41;
-            break;
-          case 38:
-            _context.prev = 38;
-            _context.t2 = _context["catch"](30);
-            throw new LocalPreviewError('local-preview-image', _context.t2 instanceof Error ? _context.t2 : undefined);
-          case 41:
-            return _context.abrupt("break", 54);
-          case 42:
-            _context.prev = 42;
-            _context.next = 45;
-            return takeSnapshot(value);
-          case 45:
-            _dataURI2 = _context.sent;
-            localPreview = {
-              dataURI: _dataURI2,
-              orientation: 1,
-              source: 'local'
-            };
-            _context.next = 52;
-            break;
-          case 49:
-            _context.prev = 49;
-            _context.t3 = _context["catch"](42);
-            throw new LocalPreviewError('local-preview-video', _context.t3 instanceof Error ? _context.t3 : undefined);
-          case 52:
-            return _context.abrupt("break", 54);
-          case 53:
-            throw new LocalPreviewError('local-preview-unsupported');
-          case 54:
-            _context.next = 57;
-            break;
-          case 56:
-            throw new LocalPreviewError('local-preview-unsupported');
-          case 57:
-            preview = _objectSpread(_objectSpread({}, localPreview), {}, {
-              dimensions: requestDimensions
-            });
-            _context.t4 = preview.source;
-            _context.next = _context.t4 === 'local' ? 61 : _context.t4 === 'remote' ? 63 : _context.t4 === 'ssr-server' ? 65 : _context.t4 === 'ssr-client' ? 67 : 69;
-            break;
-          case 61:
-            source = 'cache-local';
-            return _context.abrupt("break", 70);
-          case 63:
-            source = 'cache-remote';
-            return _context.abrupt("break", 70);
-          case 65:
-            source = 'cache-ssr-server';
-            return _context.abrupt("break", 70);
-          case 67:
-            source = 'cache-ssr-client';
-            return _context.abrupt("break", 70);
-          case 69:
-            source = preview.source;
-          case 70:
-            // We want to embed some meta context into dataURI for Copy/Paste to work.
-            dataURI = mediaBlobUrlAttrs ? addFileAttrsToUrl(preview.dataURI, mediaBlobUrlAttrs) : preview.dataURI; // We store new cardPreview into cache
-            cardPreviewCache.set(identifier.id, mode, _objectSpread(_objectSpread({}, preview), {}, {
-              source: source,
-              dataURI: dataURI
-            }));
-            setCardPreview(_objectSpread(_objectSpread({}, preview), {}, {
-              dataURI: dataURI
-            }));
-            return _context.abrupt("return");
-          case 74:
-            _context.next = 81;
-            break;
-          case 76:
-            _context.prev = 76;
-            _context.t5 = _context["catch"](8);
+            _context.t0 = _context["catch"](8);
             /**
              * We report the error if:
              * - local preview is supported and fails
@@ -266,36 +154,36 @@ export var useFilePreview = function useFilePreview(_ref) {
              *   i.e. local preview is available and not supported,
              *   but we are after the remote preview instead.
              */
-            if (!isUnsupportedLocalPreviewError(_context.t5) || isUnsupportedLocalPreviewError(_context.t5) && !isRemotePreviewReady) {
+            if (!isUnsupportedLocalPreviewError(_context.t0) || isUnsupportedLocalPreviewError(_context.t0) && !isRemotePreviewReady) {
               // CXP-2723 TODO: We might have to wrap this error in MediaCardError
-              setNonCriticalError(_context.t5);
+              setNonCriticalError(_context.t0);
             }
             /**
              * No matter the reason why the local preview failed, we break the process
              * if there is no remote preview available
              */
             if (isRemotePreviewReady) {
-              _context.next = 81;
+              _context.next = 22;
               break;
             }
-            throw _context.t5;
-          case 81:
+            throw _context.t0;
+          case 22:
             if (isRemotePreviewReady) {
-              _context.next = 83;
+              _context.next = 24;
               break;
             }
-            throw new MediaCardError('remote-preview-not-ready');
-          case 83:
-            _context.next = 85;
+            throw new MediaFilePreviewError('remote-preview-not-ready');
+          case 24:
+            _context.next = 26;
             return fetchRemotePreviewRef.current(identifier);
-          case 85:
+          case 26:
             remotePreview = _context.sent;
             setCardPreview(remotePreview);
             return _context.abrupt("return");
-          case 90:
-            _context.prev = 90;
-            _context.t6 = _context["catch"](2);
-            wrappedError = ensureMediaCardError('preview-fetch', _context.t6); //  If remote preview fails, we set status 'error'
+          case 31:
+            _context.prev = 31;
+            _context.t1 = _context["catch"](2);
+            wrappedError = ensureMediaFilePreviewError('preview-fetch', _context.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'
@@ -308,11 +196,11 @@ export var useFilePreview = function useFilePreview(_ref) {
                 setError(wrappedError);
               }
             }
-          case 94:
+          case 35:
           case "end":
             return _context.stop();
         }
-      }, _callee, null, [[2, 90], [8, 76], [10, 17], [30, 38], [42, 49]]);
+      }, _callee, null, [[2, 31], [8, 17]]);
     }));
     return function (_x, _x2) {
       return _ref2.apply(this, arguments);
@@ -379,7 +267,7 @@ export var useFilePreview = function useFilePreview(_ref) {
       // refetchSRRPreview: If dimensions from Server have changed and are bigger,
       // we need to refetch
       fetchRemotePreviewRef.current(identifier).then(setCardPreview).catch(function (e) {
-        var wrappedError = ensureMediaCardError('remote-preview-fetch-ssr', e, true);
+        var wrappedError = ensureMediaFilePreviewError('remote-preview-fetch-ssr', e, true);
         setNonCriticalError(wrappedError);
       });
     }
@@ -387,15 +275,7 @@ export var useFilePreview = function useFilePreview(_ref) {
     // Both compare dimensions, but the above is only for SSR in order to refetchSRRPreview and
     // will swallow any errors. Below logic only applies when there is no card preview or the dimensions
     // are bigger.
-    if (fileState && shouldResolvePreview({
-      status: status,
-      fileState: fileState,
-      prevDimensions: prevRequestDimensions,
-      dimensions: requestDimensions,
-      hasCardPreview: !!cardPreview,
-      isBannedLocalPreview: isBannedLocalPreview,
-      wasResolvedUpfrontPreview: wasResolvedUpfrontPreviewRef.current
-    })) {
+    if (fileState && wasResolvedUpfrontPreviewRef.current && isPreviewableStatus(status, extractFilePreviewStatus(fileState, isBannedLocalPreview)) && (!cardPreview || isBigger(prevRequestDimensions, requestDimensions))) {
       resolvePreviewRef.current(identifier, fileState);
     }
     if (!skipRemote && ssr && !!cardPreview && isSSRClientPreview(cardPreview)) {
@@ -465,7 +345,7 @@ export var useFilePreview = function useFilePreview(_ref) {
       } else {
         var e = new MediaFileStateError(fileState.id, fileState.reason, fileState.message, fileState.details);
         var errorReason = status === 'uploading' ? 'upload' : 'metadata-fetch';
-        setError(new MediaCardError(errorReason, e));
+        setError(new MediaFilePreviewError(errorReason, e));
         setStatus('error');
       }
     }
@@ -505,7 +385,7 @@ export var useFilePreview = function useFilePreview(_ref) {
         setNonCriticalError(error);
       }
       var fileImageMode = imageResizeModeToFileImageMode(resizeMode);
-      removeCardPreviewFromCache(identifier.id, fileImageMode);
+      mediaFilePreviewCache.remove(identifier.id, fileImageMode);
       setCardPreview(undefined);
     } else {
       if (!['complete', 'error', 'failed-processing'].includes(status)) {
@@ -564,22 +444,6 @@ export var useFilePreview = function useFilePreview(_ref) {
     getScriptProps: getScriptProps
   };
 };
-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;
-};
 var initialSsrReliability = {
   server: {
     status: 'unknown'

package/dist/esm/inline/loader.js

@@ -103,7 +103,7 @@ var MediaInlineCardLoader = /*#__PURE__*/function (_React$PureComponent) {
         ErrorBoundary = _this$state.ErrorBoundary;
       var analyticsContext = {
         packageVersion: "@atlaskit/media-card",
-        packageName: "77.4.10",
+        packageName: "77.5.1",
         componentName: 'mediaInlineCard',
         component: 'mediaInlineCard'
       };

package/dist/esm/utils/ufoExperiences.js

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

package/dist/types/card/cardLoader.d.ts

@@ -1,6 +1,4 @@
 import React from 'react';
-import type { WithMediaClientConfigProps } from '@atlaskit/media-client-react';
-import type { CardBaseProps } from './card';
-export type CardWithMediaClientConfigProps = WithMediaClientConfigProps<CardBaseProps>;
+import type { CardWithMediaClientConfigProps } from './types';
 declare const CardLoader: React.FC<CardWithMediaClientConfigProps>;
 export default CardLoader;

package/dist/types/card/cardSwitcher.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
-import { CardWithMediaClientConfigProps } from './cardLoader';
+import { CardWithMediaClientConfigProps } from './types';
 declare function CardSwitcher(props: CardWithMediaClientConfigProps): JSX.Element;
 export default CardSwitcher;

package/dist/types/card/cardWithMediaClient.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { CardWithMediaClientConfigProps } from './types';
+export declare const CardWithMediaClient: React.FC<CardWithMediaClientConfigProps>;

package/dist/types/card/types.d.ts

@@ -1,5 +1,7 @@
 import React, { ReactElement, RefObject } from 'react';
 import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { WithMediaClientConfigProps } from '@atlaskit/media-client-react';
+import type { CardBaseProps } from './card';
 import { CardDimensions } from '../types';
 export type InlinePlayerWrapperProps = {
     testId?: string;
@@ -11,3 +13,4 @@ export type InlinePlayerWrapperProps = {
     innerRef?: RefObject<HTMLDivElement> | ((instance: HTMLDivElement | null) => void) | undefined;
     children?: JSX.Element[] | ReactElement<any, any> | null | any;
 };
+export type CardWithMediaClientConfigProps = WithMediaClientConfigProps<CardBaseProps>;

package/dist/types/card/v2/cardV2Loader.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import { CardWithMediaClientConfigProps } from '../cardLoader';
+import { CardWithMediaClientConfigProps } from '../types';
 declare const CardLoader: React.FC<CardWithMediaClientConfigProps>;
 export default CardLoader;

package/dist/types/card/v2/cardViewV2.d.ts

@@ -4,7 +4,8 @@ import React, { MouseEvent } from 'react';
 import { MessageDescriptor } from 'react-intl-next';
 import { MediaItemType, FileDetails, ImageResizeMode } from '@atlaskit/media-client';
 import { WithAnalyticsEventsProps, UIAnalyticsEvent } from '@atlaskit/analytics-next';
-import { CardStatus, CardPreview, MediaCardCursor, CardDimensions, TitleBoxIcon } from '../../types';
+import { CardStatus, MediaCardCursor, CardDimensions, TitleBoxIcon } from '../../types';
+import { MediaFilePreview } from './useFilePreview';
 import { CardAction } from '../actions';
 import { MediaCardError } from '../../errors';
 export interface CardViewV2Props {
@@ -26,11 +27,11 @@ export interface CardViewV2Props {
     readonly onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
     readonly onMouseEnter?: (event: MouseEvent<HTMLDivElement>) => void;
     readonly onDisplayImage?: () => void;
-    readonly cardPreview?: CardPreview;
+    readonly cardPreview?: MediaFilePreview;
     readonly progress?: number;
     readonly innerRef?: (instance: HTMLDivElement | null) => void;
-    readonly onImageLoad?: (cardPreview: CardPreview) => void;
-    readonly onImageError?: (cardPreview: CardPreview) => void;
+    readonly onImageLoad?: (cardPreview: MediaFilePreview) => void;
+    readonly onImageError?: (cardPreview: MediaFilePreview) => void;
     readonly nativeLazyLoad?: boolean;
     readonly forceSyncDisplay?: boolean;
     disableAnimation?: boolean;

package/dist/types/card/v2/cardWithMediaClientV2.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { CardWithMediaClientConfigProps } from '../types';
+export declare const CardWithMediaClientV2: React.FC<CardWithMediaClientConfigProps>;

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

@@ -0,0 +1,38 @@
+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;

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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,9 @@
+import { MediaClient, MediaStoreGetFileImageParams, MediaBlobUrlAttrs, FilePreview } from '@atlaskit/media-client';
+import { SSR, MediaTraceContext } from '@atlaskit/media-common';
+import { MediaFilePreviewDimensions, MediaFilePreview } from '../types';
+export declare const getSSRCardPreview: (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

@@ -0,0 +1,10 @@
+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

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

package/dist/types/card/v2/useFilePreview/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/card/v2/useFilePreview/getPreview/videoSnapshot.d.ts

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

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -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/card/v2/useFilePreview/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/card/v2/useFilePreview/globalScope/types.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,11 @@
+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   */
+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

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

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

@@ -0,0 +1,18 @@
+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';
+export type FilePreviewStatus = {
+    hasFilesize: boolean;
+    isPreviewable: boolean;
+    hasPreview: boolean;
+    isSupportedByBrowser: boolean;
+};