@atlaskit/media-card 77.1.2 → 77.2.1

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

@@ -0,0 +1,212 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import React, { useRef, useState, useEffect } from 'react';
+import { globalMediaEventEmitter } from '@atlaskit/media-client';
+import { CustomMediaPlayer, InactivityDetector } from '@atlaskit/media-ui';
+import { defaultImageCardDimensions } from '../../utils';
+import { CardLoading } from '../../utils/lightCards/cardLoading';
+import { ProgressBar } from '../ui/progressBar/progressBar';
+import { InlinePlayerWrapper } from '../inlinePlayerWrapper';
+import { useBreakpoint } from '../useBreakpoint';
+import { useFileState, useMediaClient } from '@atlaskit/media-client-react';
+export var getPreferredVideoArtifact = function getPreferredVideoArtifact(fileState) {
+  if (fileState.status === 'processed' || fileState.status === 'processing') {
+    var artifacts = fileState.artifacts;
+    if (!artifacts) {
+      return undefined;
+    }
+    return artifacts['video_1280.mp4'] ? 'video_1280.mp4' : artifacts['video_640.mp4'] ? 'video_640.mp4' : undefined;
+  }
+  return undefined;
+};
+export var InlinePlayerBaseV2 = function InlinePlayerBaseV2(_ref) {
+  var identifier = _ref.identifier,
+    onError = _ref.onError,
+    onClick = _ref.onClick,
+    _ref$dimensions = _ref.dimensions,
+    dimensions = _ref$dimensions === void 0 ? defaultImageCardDimensions : _ref$dimensions,
+    originalDimensions = _ref.originalDimensions,
+    selected = _ref.selected,
+    testId = _ref.testId,
+    forwardRef = _ref.forwardRef,
+    autoplay = _ref.autoplay,
+    cardPreview = _ref.cardPreview,
+    onFullscreenChange = _ref.onFullscreenChange;
+  // === States ===
+  var _useState = useState(),
+    _useState2 = _slicedToArray(_useState, 2),
+    fileSrc = _useState2[0],
+    setFileSrc = _useState2[1];
+  var _useState3 = useState(),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isUploading = _useState4[0],
+    setIsUploading = _useState4[1];
+  var _useState5 = useState(),
+    _useState6 = _slicedToArray(_useState5, 2),
+    progress = _useState6[0],
+    setProgress = _useState6[1];
+
+  // === Refs and Local Variables ===
+  var divRef = useRef(null);
+  var onErrorRef = useRef(onError);
+  onErrorRef.current = onError;
+  var id = identifier.id,
+    collectionName = identifier.collectionName,
+    occurrenceKey = identifier.occurrenceKey;
+  var breakpoint = useBreakpoint(dimensions === null || dimensions === void 0 ? void 0 : dimensions.width, divRef);
+  var mediaClient = useMediaClient();
+  var _useFileState = useFileState(id, {
+      collectionName: collectionName,
+      occurrenceKey: occurrenceKey
+    }),
+    fileState = _useFileState.fileState;
+  useEffect(function () {
+    var subscribeFileState = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(fileState) {
+        var _yield$fileState$prev, value, newFileSrc, artifactName, artifacts, _newFileSrc, _newFileSrc2;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (fileState.status === 'uploading') {
+                setIsUploading(true);
+                setProgress(fileState.progress);
+              } else {
+                setIsUploading(false);
+              }
+
+              // We reuse the existing fileSrc to prevent re renders, therefore we only perform fileSrc updates when there isn't any
+              if (!fileSrc) {
+                _context.next = 3;
+                break;
+              }
+              return _context.abrupt("return");
+            case 3:
+              if (!(fileState.status !== 'error' && fileState.preview)) {
+                _context.next = 12;
+                break;
+              }
+              _context.next = 6;
+              return fileState.preview;
+            case 6:
+              _yield$fileState$prev = _context.sent;
+              value = _yield$fileState$prev.value;
+              if (!(value instanceof Blob && value.type.indexOf('video/') === 0)) {
+                _context.next = 12;
+                break;
+              }
+              newFileSrc = URL.createObjectURL(value);
+              setFileSrc(newFileSrc);
+              return _context.abrupt("return");
+            case 12:
+              if (!(fileState.status === 'processed' || fileState.status === 'processing')) {
+                _context.next = 37;
+                break;
+              }
+              artifactName = getPreferredVideoArtifact(fileState);
+              artifacts = fileState.artifacts;
+              if (!(!artifactName || !artifacts)) {
+                _context.next = 27;
+                break;
+              }
+              _context.prev = 16;
+              _context.next = 19;
+              return mediaClient.file.getFileBinaryURL(id, collectionName);
+            case 19:
+              _newFileSrc = _context.sent;
+              setFileSrc(_newFileSrc);
+              _context.next = 26;
+              break;
+            case 23:
+              _context.prev = 23;
+              _context.t0 = _context["catch"](16);
+              if (onErrorRef.current && _context.t0 instanceof Error) {
+                onErrorRef.current(_context.t0);
+              }
+            case 26:
+              return _context.abrupt("return");
+            case 27:
+              _context.prev = 27;
+              _context.next = 30;
+              return mediaClient.file.getArtifactURL(artifacts, artifactName, collectionName);
+            case 30:
+              _newFileSrc2 = _context.sent;
+              setFileSrc(_newFileSrc2);
+              _context.next = 37;
+              break;
+            case 34:
+              _context.prev = 34;
+              _context.t1 = _context["catch"](27);
+              if (onErrorRef.current && _context.t1 instanceof Error) {
+                onErrorRef.current(_context.t1);
+              }
+            case 37:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[16, 23], [27, 34]]);
+      }));
+      return function subscribeFileState(_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+    if (fileState) {
+      subscribeFileState(fileState);
+    }
+  }, [fileState, collectionName, fileSrc, id, mediaClient]);
+  useEffect(function () {
+    return function () {
+      fileSrc && URL.revokeObjectURL(fileSrc);
+    };
+  }, [fileSrc]);
+
+  // === Render ===
+  return fileSrc ? /*#__PURE__*/React.createElement(InlinePlayerWrapper, {
+    testId: testId || 'media-card-inline-player',
+    selected: {
+      selected: selected
+    },
+    onClick: onClick,
+    innerRef: forwardRef || undefined,
+    dimensions: dimensions
+  }, /*#__PURE__*/React.createElement(InactivityDetector, null, function (checkMouseMovement) {
+    return /*#__PURE__*/React.createElement(CustomMediaPlayer, {
+      type: "video",
+      src: fileSrc,
+      onFullscreenChange: onFullscreenChange,
+      fileId: id,
+      isAutoPlay: autoplay,
+      isHDAvailable: false,
+      onDownloadClick: function onDownloadClick() {
+        mediaClient.file.downloadBinary(id, undefined, collectionName);
+      },
+      onFirstPlay: function onFirstPlay() {
+        globalMediaEventEmitter.emit('media-viewed', {
+          fileId: id,
+          viewingLevel: 'full'
+        });
+      },
+      lastWatchTimeConfig: {
+        contentId: id
+      },
+      originalDimensions: originalDimensions,
+      showControls: checkMouseMovement,
+      poster: cardPreview === null || cardPreview === void 0 ? void 0 : cardPreview.dataURI
+    });
+  }), isUploading && /*#__PURE__*/React.createElement(ProgressBar, {
+    progress: progress,
+    breakpoint: breakpoint,
+    positionBottom: true,
+    showOnTop: true
+  })) : /*#__PURE__*/React.createElement(CardLoading, {
+    testId: testId,
+    dimensions: dimensions
+  });
+};
+var InlinePlayerForwardRef = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  return /*#__PURE__*/React.createElement(InlinePlayerBaseV2, _extends({}, props, {
+    forwardRef: ref
+  }));
+});
+export var InlinePlayerV2 = InlinePlayerForwardRef;

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.1.2",
+        packageName: "77.2.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.1.2";
+var packageVersion = "77.2.1";
 var concurrentExperience;
 var getExperience = function getExperience(id) {
   if (!concurrentExperience) {

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

@@ -0,0 +1,3 @@
+import { Breakpoint } from './ui/common';
+import { CardDimensionValue } from '../types';
+export declare const useBreakpoint: (dimensionWidth: CardDimensionValue | undefined, divRef: React.RefObject<HTMLDivElement>) => Breakpoint;

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

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const InlinePlayerLazyV2: import("react").LazyExoticComponent<import("react").ForwardRefExoticComponent<Pick<import("./inlinePlayerV2").InlinePlayerProps, "createAnalyticsEvent" | keyof import("./inlinePlayerV2").InlinePlayerOwnProps> & import("react").RefAttributes<HTMLDivElement>>>;

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

@@ -0,0 +1,23 @@
+import React from 'react';
+import { FileIdentifier, FileState, MediaFileArtifacts } from '@atlaskit/media-client';
+import { NumericalCardDimensions } from '@atlaskit/media-common';
+import { CardDimensions } from '../../types';
+import { WithAnalyticsEventsProps, UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { CardPreview } from '../../types';
+export interface InlinePlayerOwnProps {
+    identifier: FileIdentifier;
+    dimensions?: CardDimensions;
+    originalDimensions?: NumericalCardDimensions;
+    autoplay: boolean;
+    selected?: boolean;
+    onFullscreenChange?: (fullscreen: boolean) => void;
+    onError?: (error: Error) => void;
+    readonly onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    testId?: string;
+    readonly cardPreview?: CardPreview;
+    readonly forwardRef?: React.Ref<HTMLDivElement>;
+}
+export type InlinePlayerProps = InlinePlayerOwnProps & WithAnalyticsEventsProps;
+export declare const getPreferredVideoArtifact: (fileState: FileState) => keyof MediaFileArtifacts | undefined;
+export declare const InlinePlayerBaseV2: ({ identifier, onError, onClick, dimensions, originalDimensions, selected, testId, forwardRef, autoplay, cardPreview, onFullscreenChange, }: InlinePlayerProps) => JSX.Element;
+export declare const InlinePlayerV2: React.ForwardRefExoticComponent<Pick<InlinePlayerProps, "createAnalyticsEvent" | keyof InlinePlayerOwnProps> & React.RefAttributes<HTMLDivElement>>;

package/dist/types-ts4.5/card/actions.d.ts

@@ -0,0 +1,9 @@
+import { FileItem, FileDetails } from '@atlaskit/media-client';
+import { ReactNode } from 'react';
+export interface CardAction {
+    label?: string;
+    handler: CardEventHandler;
+    icon?: ReactNode;
+}
+export type CardEventHandler = (item?: FileItem, event?: Event) => void;
+export declare function attachDetailsToActions(actions: Array<CardAction>, details: FileDetails): Array<CardAction>;

package/dist/types-ts4.5/card/card.d.ts

@@ -0,0 +1,64 @@
+import React, { Component } from 'react';
+import { UIAnalyticsEvent, WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import { FileIdentifier, FileState, MediaSubscription } from '@atlaskit/media-client';
+import { WrappedComponentProps } from 'react-intl-next';
+import { CardAction } from './actions';
+import { CardProps, CardState, CardStatus } from '../types';
+export type CardBaseProps = CardProps & WithAnalyticsEventsProps & Partial<WrappedComponentProps>;
+export declare class CardBase extends Component<CardBaseProps, CardState> {
+    private internalOccurrenceKey;
+    private hasBeenMounted;
+    private fileStateFlags;
+    private ssrReliability;
+    private timeElapsedTillCommenced;
+    subscription?: MediaSubscription;
+    private ssrData?;
+    private traceContext;
+    static defaultProps: Partial<CardProps>;
+    constructor(props: CardBaseProps);
+    private getSSRPreview;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: CardProps, prevState: CardState): void;
+    componentWillUnmount(): void;
+    updateStateForIdentifier(identifier: FileIdentifier): void;
+    private getImageURLParams;
+    private getMediaBlobUrlAttrs;
+    private getCardPreviewParams;
+    private setCacheSSRPreview;
+    private refetchSSRPreview;
+    private resolveUpfrontPreview;
+    private fetchAndCacheRemotePreview;
+    private resolvePreview;
+    updateFileStateFlag(fileState?: FileState): void;
+    subscribeInternalFile(identifier: FileIdentifier): void;
+    private get requestedDimensions();
+    private get metadata();
+    private get fileAttributes();
+    private getPerformanceAttributes;
+    private logSSRImageError;
+    private onImageError;
+    private onImageLoad;
+    private fireOperationalEvent;
+    private fireAbortedEvent;
+    private fireCommencedEvent;
+    private fireCopiedEvent;
+    private fireScreenEvent;
+    private fireNonCriticalErrorEvent;
+    private safeSetState;
+    unsubscribe: () => void;
+    get actions(): CardAction[];
+    onCardViewClick: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    onInlinePlayerError: () => void;
+    setRef: (cardRef: HTMLDivElement | null) => void;
+    renderInlinePlayer: () => JSX.Element;
+    onMediaViewerClose: () => void;
+    private onDisplayImage;
+    renderMediaViewer: () => React.ReactPortal | undefined;
+    renderCard: (withCallbacks?: boolean, cardStatusOverride?: CardStatus, izLazyOverride?: boolean) => JSX.Element;
+    private storeSSRData;
+    render(): JSX.Element;
+    private onCardInViewport;
+    onClick: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    onMouseEnter: (event: React.MouseEvent<HTMLDivElement>) => void;
+}
+export declare const Card: React.ComponentType<CardBaseProps>;

package/dist/types-ts4.5/card/cardAnalytics.d.ts

@@ -0,0 +1,10 @@
+import { FileAttributes, MediaTraceContext, PerformanceAttributes } from '@atlaskit/media-common';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { SSRStatus } from '../utils/analytics';
+import { CardStatus } from '../types';
+import { MediaCardError } from '../errors';
+export declare const fireOperationalEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, status: CardStatus, fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, ssrReliability: SSRStatus, error: MediaCardError | undefined, traceContext: MediaTraceContext, metadataTraceContext?: MediaTraceContext) => void;
+export declare const fireCommencedEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, traceContext: MediaTraceContext) => void;
+export declare const fireCopiedEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, fileId: string, cardRef: HTMLDivElement) => void;
+export declare const fireScreenEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, fileAttributes: FileAttributes) => void;
+export declare const fireNonCriticalErrorEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, cardStatus: CardStatus, fileAttributes: FileAttributes, ssrReliability: SSRStatus, error: MediaCardError | undefined, traceContext: MediaTraceContext, metadataTraceContext?: MediaTraceContext) => void;

package/dist/types-ts4.5/card/cardConstants.d.ts

@@ -0,0 +1 @@
+export declare const newFileExperienceClassName = "new-file-experience-wrapper";

package/dist/types-ts4.5/card/cardLoader.d.ts

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

package/dist/types-ts4.5/card/cardState.d.ts

@@ -0,0 +1,9 @@
+import { FileState } from '@atlaskit/media-client';
+import { CardState } from '../types';
+import { MediaCardError } from '../errors';
+/**
+ * From docs: "Both state and props received by the updater function are guaranteed to be up-to-date.
+ * The output of the updater is shallowly merged with state."
+ */
+export declare const createStateUpdater: (newState: Partial<CardState>, fireErrorEvent: (error: MediaCardError) => void) => (prevState: CardState) => Partial<CardState>;
+export declare const getCardStateFromFileState: (fileState: FileState, isBannedLocalPreview: boolean) => Partial<CardState>;

package/dist/types-ts4.5/card/cardSwitcher.d.ts

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

package/dist/types-ts4.5/card/cardView.d.ts

@@ -0,0 +1,78 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import React, { MouseEvent } from 'react';
+import { MessageDescriptor } from 'react-intl-next';
+import { MediaItemType, FileDetails } from '@atlaskit/media-client';
+import { WithAnalyticsEventsProps, UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { SharedCardProps, CardStatus } from '../types';
+import { MediaCardError } from '../errors';
+import { CardPreview } from '../types';
+import { MediaCardCursor } from '../types';
+export interface CardViewOwnProps extends SharedCardProps {
+    readonly status: CardStatus;
+    readonly mediaItemType: MediaItemType;
+    readonly mediaCardCursor?: MediaCardCursor;
+    readonly metadata?: FileDetails;
+    readonly error?: MediaCardError;
+    readonly onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    readonly onMouseEnter?: (event: MouseEvent<HTMLDivElement>) => void;
+    readonly onDisplayImage?: () => void;
+    readonly cardPreview?: CardPreview;
+    readonly progress?: number;
+    readonly innerRef?: (instance: HTMLDivElement | null) => void;
+    readonly onImageLoad: (cardPreview: CardPreview) => void;
+    readonly onImageError: (cardPreview: CardPreview) => void;
+    readonly nativeLazyLoad?: boolean;
+    readonly forceSyncDisplay?: boolean;
+    disableAnimation?: boolean;
+    shouldHideTooltip?: boolean;
+}
+export interface CardViewState {
+    elementWidth?: number;
+    didImageRender: boolean;
+}
+export type CardViewProps = CardViewOwnProps & WithAnalyticsEventsProps;
+export interface RenderConfigByStatus {
+    renderTypeIcon?: boolean;
+    iconMessage?: JSX.Element;
+    renderImageRenderer?: boolean;
+    renderPlayButton?: boolean;
+    renderTitleBox?: boolean;
+    renderBlanket?: boolean;
+    isFixedBlanket?: boolean;
+    renderProgressBar?: boolean;
+    renderSpinner?: boolean;
+    renderFailedTitleBox?: boolean;
+    renderTickBox?: boolean;
+    customTitleMessage?: MessageDescriptor;
+}
+/**
+ * This is classic vanilla CardView class. To create an instance of class one would need to supply
+ * `createAnalyticsEvent` prop to satisfy it's Analytics Events needs.
+ */
+export declare class CardViewBase extends React.Component<CardViewProps, CardViewState> {
+    state: CardViewState;
+    divRef: React.RefObject<HTMLDivElement>;
+    static defaultProps: Partial<CardViewOwnProps>;
+    componentDidMount(): void;
+    componentDidUpdate({ cardPreview: prevCardPreview }: CardViewProps): void;
+    private onImageLoad;
+    private onImageError;
+    private get breakpoint();
+    private saveElementWidth;
+    private renderSpinner;
+    private shouldRenderPlayButton;
+    private renderPlayButton;
+    private renderBlanket;
+    private renderTitleBox;
+    private renderFailedTitleBox;
+    private renderProgressBar;
+    private renderImageRenderer;
+    private renderTickBox;
+    private renderMediaTypeIcon;
+    private renderActionsBar;
+    render(): jsx.JSX.Element;
+    private getRenderConfigByStatus;
+    private renderContents;
+}
+export declare const CardView: React.ForwardRefExoticComponent<Pick<Omit<CardViewProps, keyof WithAnalyticsEventsProps>, never> & Partial<Pick<Omit<CardViewProps, keyof WithAnalyticsEventsProps>, keyof CardViewOwnProps>> & Partial<Pick<Partial<CardViewOwnProps>, never>> & React.RefAttributes<any>>;

package/dist/types-ts4.5/card/classnames.d.ts

@@ -0,0 +1,2 @@
+export declare const fileCardImageViewSelector = "media-file-card-view";
+export declare const fileCardImageViewSelectedSelector = "media-file-card-view-selected";

package/dist/types-ts4.5/card/getCardPreview/cache.d.ts

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

package/dist/types-ts4.5/card/getCardPreview/filePreviewStatus.d.ts

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

package/dist/types-ts4.5/card/getCardPreview/helpers.d.ts

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

package/dist/types-ts4.5/card/getCardPreview/index.d.ts

@@ -0,0 +1,53 @@
+import { MediaClient, FilePreview, FileState, MediaStoreGetFileImageParams, MediaBlobUrlAttrs } from '@atlaskit/media-client';
+import { SSR, MediaTraceContext } from '@atlaskit/media-common';
+import { ImageResizeMode } from '@atlaskit/media-client';
+import { CardDimensions } from '../../types';
+import { MediaCardError } from '../../errors';
+import { CardStatus, CardPreview } from '../../types';
+export { getCardPreviewFromFilePreview, getCardPreviewFromBackend, isSupportedLocalPreview, } from './helpers';
+export { extractFilePreviewStatus } from './filePreviewStatus';
+export declare const getCardPreviewFromCache: (id: string, mode: ImageResizeMode | undefined) => CardPreview | undefined;
+export declare const removeCardPreviewFromCache: (id: string, mode: ImageResizeMode | undefined) => void;
+/**
+ * Will return the preview if available and supported by the browser
+ * See extractFilePreviewStatus "hasLocalPreview" logic
+ */
+export declare const getFilePreviewFromFileState: (fileState: FileState) => FilePreview | Promise<FilePreview> | undefined;
+export type CardPreviewParams = {
+    mediaClient: MediaClient;
+    id: string;
+    dimensions?: CardDimensions;
+    filePreview?: FilePreview | Promise<FilePreview>;
+    onLocalPreviewError: (error: MediaCardError) => void;
+    isRemotePreviewReady: boolean;
+    imageUrlParams: MediaStoreGetFileImageParams;
+    mediaBlobUrlAttrs?: MediaBlobUrlAttrs;
+    traceContext?: MediaTraceContext;
+};
+/**
+ * This function will try to return a Card preview, either from cache, local preview or remote preview.
+ * It should only be called if there is a chance to get either a remote or a local preview, or both.
+ * This, in order to ensure there is always going to be a valid return value OR throw an error if the process fails.
+ * It is worth noting that local preview failures break the process if there is no remote preview available.
+ * In that case we throw an error immediately.
+ * Otherwise, if the local preview fails but there is a remote preview available, the failure does not break the process.
+ * In that case, we still want to report the local preview error to the caller, for feature realiability track.
+ * hence the use of the optional callback onLocalPreviewError
+ */
+export declare const getCardPreview: ({ mediaClient, id, dimensions, filePreview, onLocalPreviewError, isRemotePreviewReady, imageUrlParams, mediaBlobUrlAttrs, traceContext, }: CardPreviewParams) => Promise<CardPreview>;
+export declare const shouldResolvePreview: ({ status, fileState, prevDimensions, dimensions, hasCardPreview, isBannedLocalPreview, wasResolvedUpfrontPreview, }: {
+    status: CardStatus;
+    fileState: FileState;
+    prevDimensions?: CardDimensions | undefined;
+    dimensions?: CardDimensions | undefined;
+    hasCardPreview: boolean;
+    isBannedLocalPreview: boolean;
+    wasResolvedUpfrontPreview: boolean;
+}) => boolean;
+export declare const getSSRCardPreview: (ssr: SSR, mediaClient: MediaClient, id: string, params: MediaStoreGetFileImageParams, mediaBlobUrlAttrs?: MediaBlobUrlAttrs) => CardPreview;
+export declare const isLocalPreview: (preview: CardPreview) => boolean;
+export declare const isSSRPreview: (preview: CardPreview) => boolean;
+export declare const isSSRServerPreview: (preview: CardPreview) => boolean;
+export declare const isSSRClientPreview: (preview: CardPreview) => boolean;
+export declare const isSSRDataPreview: (preview: CardPreview) => boolean;
+export declare const fetchAndCacheRemotePreview: (mediaClient: MediaClient, id: string, dimensions: CardDimensions, params: MediaStoreGetFileImageParams, mediaBlobUrlAttrs?: MediaBlobUrlAttrs, traceContext?: MediaTraceContext) => Promise<CardPreview>;

package/dist/types-ts4.5/card/getCardStatus.d.ts

@@ -0,0 +1,4 @@
+import { FileStatus } from '@atlaskit/media-client';
+import { CardStatus, FilePreviewStatus } from '../types';
+export declare const isFinalCardStatus: (status: CardStatus) => boolean;
+export declare const getCardStatus: (fileStatus: FileStatus, { isPreviewable, hasPreview }: FilePreviewStatus) => CardStatus;

package/dist/types-ts4.5/card/index.d.ts

@@ -0,0 +1 @@
+export { default as Card } from './cardSwitcher';

package/dist/types-ts4.5/card/inlinePlayer.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+import { Component } from 'react';
+import { MediaClient, FileIdentifier, FileState, MediaFileArtifacts, MediaSubscription } from '@atlaskit/media-client';
+import { NumericalCardDimensions } from '@atlaskit/media-common';
+import { CardDimensions } from '../types';
+import { WithAnalyticsEventsProps, UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { CardPreview } from '../types';
+export interface InlinePlayerOwnProps {
+    identifier: FileIdentifier;
+    mediaClient: MediaClient;
+    dimensions?: CardDimensions;
+    originalDimensions?: NumericalCardDimensions;
+    autoplay: boolean;
+    selected?: boolean;
+    onFullscreenChange?: (fullscreen: boolean) => void;
+    onError?: (error: Error) => void;
+    readonly onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    testId?: string;
+    readonly cardPreview?: CardPreview;
+    readonly forwardRef?: React.Ref<HTMLDivElement>;
+}
+export type InlinePlayerProps = InlinePlayerOwnProps & WithAnalyticsEventsProps;
+export interface InlinePlayerState {
+    fileSrc?: string;
+    isUploading?: boolean;
+    progress?: number;
+    elementWidth?: number;
+}
+export declare const getPreferredVideoArtifact: (fileState: FileState) => keyof MediaFileArtifacts | undefined;
+export declare class InlinePlayerBase extends Component<InlinePlayerProps, InlinePlayerState> {
+    subscription?: MediaSubscription;
+    state: InlinePlayerState;
+    divRef: React.RefObject<HTMLDivElement>;
+    static defaultProps: {
+        dimensions: {
+            width: number;
+            height: number;
+        };
+    };
+    componentDidMount(): void;
+    setFileSrc: (fileSrc: string) => void;
+    setBinaryURL: () => Promise<void>;
+    unsubscribe: () => void;
+    revoke: () => void;
+    componentWillUnmount(): void;
+    onDownloadClick: () => void;
+    onFirstPlay: () => void;
+    private get breakpoint();
+    saveElementWidth: () => void;
+    render(): JSX.Element;
+}
+export declare const InlinePlayer: React.ForwardRefExoticComponent<Pick<InlinePlayerProps, "createAnalyticsEvent" | keyof InlinePlayerOwnProps> & React.RefAttributes<HTMLDivElement>>;

package/dist/types-ts4.5/card/inlinePlayerLazy.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const InlinePlayerLazy: import("react").LazyExoticComponent<import("react").ForwardRefExoticComponent<Pick<import("./inlinePlayer").InlinePlayerProps, "createAnalyticsEvent" | keyof import("./inlinePlayer").InlinePlayerOwnProps> & import("react").RefAttributes<HTMLDivElement>>>;

package/dist/types-ts4.5/card/inlinePlayerWrapper.d.ts

@@ -0,0 +1,4 @@
+/**@jsx jsx */
+import { jsx } from '@emotion/react';
+import { InlinePlayerWrapperProps } from './types';
+export declare const InlinePlayerWrapper: (props: InlinePlayerWrapperProps) => jsx.JSX.Element;

package/dist/types-ts4.5/card/inlinePlayerWrapperStyles.d.ts

@@ -0,0 +1,6 @@
+import { InlinePlayerWrapperProps } from './types';
+export declare const inlinePlayerClassName = "media-card-inline-player";
+export declare const inlinePlayerWrapperStyles: {
+    ({ dimensions, selected, }: InlinePlayerWrapperProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};