@atlaskit/media-card 77.1.2 → 77.2.1

package/dist/types-ts4.5/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/classnames.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Entry Point: @atlaskit/media-card/classnames
+ * tsconfig.entry-points.json
+ */
+export { fileCardImageViewSelector } from './card/classnames';

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

@@ -0,0 +1,53 @@
+import { MediaClientErrorReason } from '@atlaskit/media-client';
+import { CardPreview } 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 MediaCardErrorPrimaryReason = '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 MediaFileStateError extends Error {
+    readonly id: string;
+    readonly reason?: string | undefined;
+    readonly message: string;
+    readonly details?: Record<string, any> | undefined;
+    constructor(id: string, reason?: string | undefined, message?: string, details?: Record<string, any> | undefined);
+}
+export declare function isMediaFileStateError(err: Error): err is MediaFileStateError;
+export declare function getFileStateErrorReason(err: MediaFileStateError): MediaClientErrorReason | 'unknown';
+export declare function isPollingError(err?: Error): boolean;
+export declare function isRateLimitedError(error?: Error): boolean;
+export declare class MediaCardError extends Error {
+    readonly primaryReason: MediaCardErrorPrimaryReason;
+    readonly secondaryError?: Error | undefined;
+    constructor(primaryReason: MediaCardErrorPrimaryReason, secondaryError?: Error | undefined);
+}
+export declare class LocalPreviewError extends MediaCardError {
+    readonly primaryReason: LocalPreviewPrimaryReason;
+    readonly secondaryError?: Error | undefined;
+    constructor(primaryReason: LocalPreviewPrimaryReason, secondaryError?: Error | undefined);
+}
+export declare class RemotePreviewError extends MediaCardError {
+    readonly primaryReason: RemotePreviewPrimaryReason;
+    readonly secondaryError?: Error | undefined;
+    constructor(primaryReason: RemotePreviewPrimaryReason, secondaryError?: Error | undefined);
+}
+export declare class SsrPreviewError extends MediaCardError {
+    readonly primaryReason: SsrPreviewPrimaryReason;
+    readonly secondaryError?: Error | undefined;
+    constructor(primaryReason: SsrPreviewPrimaryReason, secondaryError?: Error | undefined);
+}
+export declare const getImageLoadPrimaryReason: (source?: CardPreview['source']) => ImageLoadPrimaryReason;
+export declare class ImageLoadError extends MediaCardError {
+    constructor(source?: CardPreview['source']);
+}
+export declare function isMediaCardError(err: Error): err is MediaCardError;
+export declare const isLocalPreviewError: (err: Error) => err is LocalPreviewError;
+export declare const isRemotePreviewError: (err: Error) => err is LocalPreviewError;
+export declare const isUnsupportedLocalPreviewError: (err: Error) => boolean;
+export declare function isImageLoadError(err: Error): err is ImageLoadError;
+export declare const ensureMediaCardError: (primaryReason: MediaCardErrorPrimaryReason, error: Error, updatePrimaryReason?: boolean) => MediaCardError;
+export declare const isUploadError: (error?: MediaCardError) => boolean | undefined;

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

@@ -0,0 +1,15 @@
+/**
+ * Entry Point: @atlaskit/media-card
+ * tsconfig.entry-points.json
+ */
+export type { NumericalCardDimensions } from '@atlaskit/media-common';
+export type { CardAction, CardEventHandler } from './card/actions';
+export type { CardStatus, CardAppearance, CardDimensionValue, CardPreview, TitleBoxIcon, CardEvent, InlineCardEvent, SharedCardProps, CardOnClickCallback, InlineCardOnClickCallback, CardProps, CardState, CardDimensions, } from './types';
+export { Card } from './card';
+export { MediaInlineCard } from './inline';
+export { CardLoading } from './utils/lightCards/cardLoading';
+export { CardError } from './utils/lightCards/cardError';
+export { defaultImageCardDimensions } from './utils/cardDimensions';
+export { fileCardImageViewSelector } from './card/classnames';
+export { inlinePlayerClassName } from './card/inlinePlayerWrapperStyles';
+export { newFileExperienceClassName } from './card/cardConstants';

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

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

package/dist/types-ts4.5/inline/loader.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { WithMediaClientConfigProps } from '@atlaskit/media-client';
+import { MediaInlineCardProps } from './mediaInlineCard';
+export type MediaInlineCardWithMediaClientConfigProps = WithMediaClientConfigProps<MediaInlineCardProps>;
+type MediaInlineCardWithMediaClientConfigComponent = React.ComponentType<MediaInlineCardWithMediaClientConfigProps>;
+type ErrorBoundaryComponent = React.ComponentType<{
+    data?: {
+        [k: string]: any;
+    };
+    isSelected?: boolean;
+}>;
+export interface MediaInlineCardLoaderState {
+    MediaInlineCard?: MediaInlineCardWithMediaClientConfigComponent;
+    ErrorBoundary?: ErrorBoundaryComponent;
+}
+export default class MediaInlineCardLoader extends React.PureComponent<MediaInlineCardWithMediaClientConfigProps & MediaInlineCardLoaderState, MediaInlineCardLoaderState> {
+    static displayName: string;
+    static MediaInlineCard?: MediaInlineCardWithMediaClientConfigComponent;
+    static ErrorBoundary?: ErrorBoundaryComponent;
+    mounted: boolean;
+    state: MediaInlineCardLoaderState;
+    componentDidMount(): Promise<void>;
+    componentWillUnmount(): Promise<void>;
+    render(): JSX.Element;
+}
+export {};

package/dist/types-ts4.5/inline/mediaInlineAnalyticsErrorBoundary.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+export type MediaInlineAnalyticsErrorBoundaryProps = {
+    isSelected?: boolean;
+    data?: {
+        [k: string]: any;
+    };
+    featureFlags?: MediaFeatureFlags;
+} & WithAnalyticsEventsProps;
+declare const MediaInlineAnalyticsErrorBoundary: React.ComponentType<MediaInlineAnalyticsErrorBoundaryProps & WithAnalyticsEventsProps>;
+export default MediaInlineAnalyticsErrorBoundary;

package/dist/types-ts4.5/inline/mediaInlineCard.d.ts

@@ -0,0 +1,15 @@
+import React, { FC } from 'react';
+import { FileIdentifier, Identifier, MediaClient } from '@atlaskit/media-client';
+import { WrappedComponentProps } from 'react-intl-next';
+import { InlineCardOnClickCallback } from '../types';
+export interface MediaInlineCardProps {
+    identifier: FileIdentifier;
+    mediaClient: MediaClient;
+    shouldOpenMediaViewer?: boolean;
+    shouldDisplayToolTip?: boolean;
+    isSelected?: boolean;
+    onClick?: InlineCardOnClickCallback;
+    mediaViewerItems?: Identifier[];
+}
+export declare const MediaInlineCardInternal: FC<MediaInlineCardProps & WrappedComponentProps>;
+export declare const MediaInlineCard: React.FC<MediaInlineCardProps>;

package/dist/types-ts4.5/inline/mediaInlineCardAnalytics.d.ts

@@ -0,0 +1,6 @@
+import { FileState } from '@atlaskit/media-client';
+import { RenderInlineCardFailedEventPayload, RenderInlineCardSucceededEventPayload } from '../utils/analytics';
+import { MediaCardError } from '../errors';
+export declare const getSucceededStatusPayload: (fileState?: FileState) => RenderInlineCardSucceededEventPayload;
+export declare const getErrorStatusPayload: (error: MediaCardError, fileState?: FileState) => RenderInlineCardFailedEventPayload;
+export declare const getFailedProcessingStatusPayload: (fileState?: FileState) => RenderInlineCardFailedEventPayload;

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

@@ -0,0 +1,105 @@
+/**
+ * Entry Point: @atlaskit/media-card/types
+ * tsconfig.entry-points.json
+ */
+import { MouseEvent } from 'react';
+import { FileDetails, MediaClient, Identifier, ImageResizeMode, FileState } from '@atlaskit/media-client';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { MediaFeatureFlags, NumericalCardDimensions, SSR } from '@atlaskit/media-common';
+import { CardAction } from './card/actions';
+import { MediaCardError } from './errors';
+export type CardStatus = 'uploading' | 'loading' | 'processing' | 'loading-preview' | 'complete' | 'error' | 'failed-processing';
+export type FilePreviewStatus = {
+    hasFilesize: boolean;
+    isPreviewable: boolean;
+    hasPreview: boolean;
+    isSupportedByBrowser: boolean;
+};
+export type FileStateFlags = {
+    wasStatusProcessing: boolean;
+    wasStatusUploading: boolean;
+};
+export type CardAppearance = 'auto' | 'image' | 'square' | 'horizontal';
+export declare type CardDimensionValue = number | string;
+export type CardPreviewSource = 'local' | 'remote' | 'ssr-server' | 'ssr-client' | 'ssr-data' | 'cache-local' | 'cache-remote' | 'cache-ssr-client' | 'cache-ssr-server' | 'external';
+export interface CardPreview {
+    dataURI: string;
+    orientation?: number;
+    dimensions?: CardDimensions;
+    source: CardPreviewSource;
+}
+export declare enum MediaCardCursor {
+    Action = "pointer",
+    NotReady = "wait"
+}
+export interface CardDimensions {
+    width?: CardDimensionValue;
+    height?: CardDimensionValue;
+}
+export type TitleBoxIcon = 'LockFilledIcon';
+export interface CardEvent {
+    event: MouseEvent<HTMLElement>;
+    mediaItemDetails?: FileDetails;
+}
+export interface InlineCardEvent {
+    event: MouseEvent<HTMLElement> | React.KeyboardEvent;
+    mediaItemDetails?: FileDetails;
+}
+export interface SharedCardProps {
+    readonly disableOverlay?: boolean;
+    readonly resizeMode?: ImageResizeMode;
+    readonly featureFlags?: MediaFeatureFlags;
+    readonly appearance?: CardAppearance;
+    readonly dimensions?: CardDimensions;
+    readonly originalDimensions?: NumericalCardDimensions;
+    readonly actions?: Array<CardAction>;
+    readonly selectable?: boolean;
+    readonly selected?: boolean;
+    readonly alt?: string;
+    readonly testId?: string;
+    readonly titleBoxBgColor?: string;
+    readonly titleBoxIcon?: TitleBoxIcon;
+}
+export interface CardOnClickCallback {
+    (result: CardEvent, analyticsEvent?: UIAnalyticsEvent): void;
+}
+export interface InlineCardOnClickCallback {
+    (result: InlineCardEvent, analyticsEvent?: UIAnalyticsEvent): void;
+}
+export interface CardEventProps {
+    readonly onClick?: CardOnClickCallback;
+    readonly onMouseEnter?: (result: CardEvent) => void;
+    /** Callback function to be called when video enters and exit fullscreen.
+     * `fullscreen = true` indicates video enters fullscreen
+     * `fullscreen = false` indicates video exits fullscreen
+     */
+    readonly onFullscreenChange?: (fullscreen: boolean) => void;
+}
+export interface CardProps extends SharedCardProps, CardEventProps {
+    readonly mediaClient: MediaClient;
+    readonly identifier: Identifier;
+    readonly isLazy?: boolean;
+    readonly useInlinePlayer?: boolean;
+    readonly shouldOpenMediaViewer?: boolean;
+    readonly mediaViewerItems?: Identifier[];
+    readonly contextId?: string;
+    readonly shouldEnableDownloadButton?: boolean;
+    readonly ssr?: SSR;
+    readonly shouldHideTooltip?: boolean;
+}
+export interface CardState {
+    status: CardStatus;
+    isCardVisible: boolean;
+    shouldAutoplay?: boolean;
+    isPlayingFile: boolean;
+    mediaViewerSelectedItem?: Identifier;
+    fileState?: FileState;
+    progress?: number;
+    cardPreview?: CardPreview;
+    error?: MediaCardError;
+    cardRef: HTMLDivElement | null;
+    isBannedLocalPreview: boolean;
+    previewDidRender: boolean;
+    wasResolvedUpfrontPreview: boolean;
+    shouldUpdateStateForIdentifier?: boolean;
+}

package/dist/types-ts4.5/utils/analytics.d.ts

@@ -0,0 +1,101 @@
+import { FileDetails, FileStatus, MediaClientErrorReason, RequestMetadata } from '@atlaskit/media-client';
+import { FileAttributes, PerformanceAttributes, OperationalEventPayload, UIEventPayload, WithFileAttributes, WithPerformanceAttributes, SuccessAttributes, FailureAttributes, ScreenEventPayload, ScreenAttributes, MediaTraceContext, WithTraceContext } from '@atlaskit/media-common';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { MediaCardError, MediaCardErrorPrimaryReason } from '../errors';
+import { CardPreviewSource, CardDimensions, CardStatus } from '../types';
+export type CardPreviewAttributes = {
+    fileId: string;
+    prevDimensions: CardDimensions | undefined;
+    currentDimensions: CardDimensions | undefined;
+    dimensionsPercentageDiff?: CardDimensions | undefined;
+    source: CardPreviewSource;
+};
+type WithCardPreviewCacheAttributes = {
+    cardPreviewAttributes: CardPreviewAttributes;
+};
+export type FileUriFailReason = 'local-uri' | 'remote-uri' | `unknown-uri`;
+export type FailedErrorFailReason = MediaCardErrorPrimaryReason | 'nativeError';
+export type MediaCardErrorInfo = {
+    failReason: FailedErrorFailReason;
+    error: MediaClientErrorReason | 'nativeError';
+    errorDetail: string;
+    metadataTraceContext?: MediaTraceContext;
+};
+export type SSRStatusFail = MediaCardErrorInfo & {
+    status: 'fail';
+};
+type SSRStatusSuccess = SuccessAttributes;
+type SSRStatusUnknown = {
+    status: 'unknown';
+};
+type SSRStatusAttributes = SSRStatusSuccess | SSRStatusFail | SSRStatusUnknown;
+export type SSRStatus = {
+    server: SSRStatusAttributes;
+    client: SSRStatusAttributes;
+};
+export type WithSSRReliability = {
+    ssrReliability?: SSRStatus;
+};
+export type RenderFailedEventPayload = OperationalEventPayload<WithFileAttributes & WithPerformanceAttributes & WithSSRReliability & WithTraceContext & FailureAttributes & {
+    failReason: FailedErrorFailReason | 'failed-processing';
+    error?: MediaClientErrorReason | 'nativeError';
+    request?: RequestMetadata;
+}, 'failed', 'mediaCardRender'>;
+export type ErrorEventPayload = OperationalEventPayload<WithFileAttributes & WithPerformanceAttributes & WithSSRReliability & WithTraceContext & FailureAttributes & {
+    cardStatus: CardStatus;
+    failReason: FailedErrorFailReason | 'failed-processing';
+    error?: MediaClientErrorReason | 'nativeError';
+    request?: RequestMetadata;
+}, 'nonCriticalFail', 'mediaCardRender'>;
+export type ErrorBoundaryErrorInfo = {
+    componentStack: string;
+};
+export type AnalyticsErrorBoundaryAttributes = {
+    error?: Error | string;
+    info?: ErrorBoundaryErrorInfo;
+    browserInfo: string;
+    failReason: string;
+};
+export type AnalyticsErrorBoundaryCardPayload = OperationalEventPayload<AnalyticsErrorBoundaryAttributes, 'failed', 'mediaCardRender'>;
+export type AnalyticsErrorBoundaryInlinePayload = OperationalEventPayload<AnalyticsErrorBoundaryAttributes, 'failed', 'mediaInlineRender'>;
+export type RenderInlineCardSucceededEventPayload = OperationalEventPayload<WithFileAttributes & WithPerformanceAttributes & SuccessAttributes, 'succeeded', 'mediaInlineRender'>;
+export type RenderInlineCardFailedEventPayload = OperationalEventPayload<WithFileAttributes & WithPerformanceAttributes & FailureAttributes & {
+    failReason: FailedErrorFailReason | 'failed-processing';
+    error?: MediaClientErrorReason | 'nativeError';
+    request?: RequestMetadata;
+}, 'failed', 'mediaInlineRender'>;
+export type RenderSucceededEventPayload = OperationalEventPayload<WithFileAttributes & WithPerformanceAttributes & WithSSRReliability & SuccessAttributes & WithTraceContext, 'succeeded', 'mediaCardRender'>;
+export type RenderCommencedEventPayload = OperationalEventPayload<WithFileAttributes & WithPerformanceAttributes & WithTraceContext, 'commenced', 'mediaCardRender'>;
+export type CacheHitEventPayload = OperationalEventPayload<WithCardPreviewCacheAttributes, 'cache-hit', 'mediaCardCache'>;
+export type RemoteSuccessEventPayload = OperationalEventPayload<WithCardPreviewCacheAttributes, 'Remote-success', 'mediaCardCache'>;
+export type CopiedFileEventPayload = UIEventPayload<{}, 'copied', string>;
+export type ClickedEventPayload = UIEventPayload<{
+    label?: string;
+}, 'clicked', string>;
+export type RenderScreenEventPayload = Omit<ScreenEventPayload<ScreenAttributes, 'mediaCardRenderScreen'>, 'attributes'> & {
+    attributes: {
+        type: string | undefined;
+        fileAttributes: FileAttributes;
+    };
+};
+export type MediaCardAnalyticsEventPayload = RenderCommencedEventPayload | RenderSucceededEventPayload | RenderFailedEventPayload | CopiedFileEventPayload | ClickedEventPayload | RenderScreenEventPayload | CacheHitEventPayload | RemoteSuccessEventPayload | ErrorEventPayload | AnalyticsErrorBoundaryCardPayload | AnalyticsErrorBoundaryInlinePayload | RenderInlineCardFailedEventPayload | RenderInlineCardSucceededEventPayload;
+export declare const getFileAttributes: (metadata: FileDetails, fileStatus?: FileStatus) => FileAttributes;
+export declare const getRenderPreviewableCardPayload: (fileAttributes: FileAttributes) => RenderScreenEventPayload;
+export declare const getRenderCommencedEventPayload: (fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, traceContext: MediaTraceContext) => RenderCommencedEventPayload;
+export declare const getRenderSucceededEventPayload: (fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, ssrReliability: SSRStatus, traceContext: MediaTraceContext, metadataTraceContext?: MediaTraceContext) => RenderSucceededEventPayload;
+export declare const getCacheHitEventPayload: (cardPreviewAttributes: CardPreviewAttributes) => CacheHitEventPayload;
+export declare const getRemoteSuccessEventPayload: (cardPreviewAttributes: CardPreviewAttributes) => RemoteSuccessEventPayload;
+export declare const getRenderFailedExternalUriPayload: (fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes) => RenderFailedEventPayload;
+export declare const getRenderErrorFailReason: (error: MediaCardError) => FailedErrorFailReason;
+export declare const getRenderErrorErrorReason: (error: MediaCardError) => MediaClientErrorReason | 'nativeError';
+export declare const getRenderErrorErrorDetail: (error: MediaCardError) => string;
+export declare const getErrorTraceContext: (error: MediaCardError) => MediaTraceContext | undefined;
+export declare const getRenderErrorRequestMetadata: (error: MediaCardError) => RequestMetadata | undefined;
+export declare const extractErrorInfo: (error: MediaCardError, metadataTraceContext?: MediaTraceContext) => MediaCardErrorInfo;
+export declare const getRenderErrorEventPayload: (fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, error: MediaCardError, ssrReliability: SSRStatus, traceContext: MediaTraceContext, metadataTraceContext?: MediaTraceContext) => RenderFailedEventPayload;
+export declare const getErrorEventPayload: (cardStatus: CardStatus, fileAttributes: FileAttributes, error: MediaCardError, ssrReliability: SSRStatus, traceContext: MediaTraceContext, metadataTraceContext?: MediaTraceContext) => ErrorEventPayload;
+export declare const getRenderFailedFileStatusPayload: (fileAttributes: FileAttributes, performanceAttributes: PerformanceAttributes, ssrReliability: SSRStatus, traceContext: MediaTraceContext, metadataTraceContext?: MediaTraceContext) => RenderFailedEventPayload;
+export declare const getCopiedFilePayload: (fileId: string) => CopiedFileEventPayload;
+export declare function fireMediaCardEvent(payload: MediaCardAnalyticsEventPayload, createAnalyticsEvent?: CreateUIAnalyticsEvent): void;
+export declare const createAndFireMediaCardEvent: (payload: MediaCardAnalyticsEventPayload) => (createAnalyticsEvent: CreateUIAnalyticsEvent) => import("@atlaskit/analytics-next").UIAnalyticsEvent;
+export {};

package/dist/types-ts4.5/utils/cardDimensions.d.ts

@@ -0,0 +1,14 @@
+import { CardAppearance, CardDimensions } from '../types';
+export declare const defaultImageCardDimensions: {
+    width: number;
+    height: number;
+};
+export declare const defaultHorizontalCardDimensions: {
+    width: number;
+    height: number;
+};
+export declare const defaultSquareCardDimensions: {
+    width: number;
+    height: number;
+};
+export declare const getDefaultCardDimensions: (appearance?: CardAppearance) => Required<CardDimensions>;

package/dist/types-ts4.5/utils/containsPixelUnit.d.ts

@@ -0,0 +1 @@
+export declare const containsPixelUnit: (value: string) => boolean;

package/dist/types-ts4.5/utils/dimensionComparer.d.ts

@@ -0,0 +1,3 @@
+import { CardDimensionValue, CardDimensions } from '../types';
+export declare const canCompareDimension: (current?: CardDimensionValue, next?: CardDimensionValue) => boolean;
+export declare const isBigger: (current?: CardDimensions, next?: CardDimensions) => boolean;

package/dist/types-ts4.5/utils/document.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Document | undefined;
+export default _default;

package/dist/types-ts4.5/utils/generateUniqueId.d.ts

@@ -0,0 +1 @@
+export declare const generateUniqueId: () => string;

package/dist/types-ts4.5/utils/getCSSUnitValue.d.ts

@@ -0,0 +1 @@
+export declare function getCSSUnitValue(value: number | string): string;

package/dist/types-ts4.5/utils/getDataURIDimension.d.ts

@@ -0,0 +1,9 @@
+import { CardDimensions } from '../types';
+import { ElementDimension } from './getElementDimension';
+import { NumericalCardDimensions } from '@atlaskit/media-common';
+export type getDataURIDimensionOptions = {
+    element?: Element | null;
+    dimensions?: CardDimensions;
+};
+export declare const getDataURIDimension: (dimension: ElementDimension, options: getDataURIDimensionOptions) => number;
+export declare const getRequestedDimensions: (options: getDataURIDimensionOptions) => NumericalCardDimensions;

package/dist/types-ts4.5/utils/getElementDimension.d.ts

@@ -0,0 +1,2 @@
+export type ElementDimension = 'height' | 'width';
+export declare const getElementDimension: (element: Element, dimension: ElementDimension) => number;

package/dist/types-ts4.5/utils/getMediaCardCursor.d.ts

@@ -0,0 +1,6 @@
+import { MediaCardCursor } from '../types';
+import { MediaType } from '@atlaskit/media-client';
+/**
+ * When the returned value is undefined, we'd expect the media card to take the parent's cursor style.
+ */
+export declare const getMediaCardCursor: (useInlinePlayer: boolean, useMediaViewer: boolean, isErrorStatus: boolean, hasCardPreview: boolean, mediaType?: MediaType) => MediaCardCursor | undefined;

package/dist/types-ts4.5/utils/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-ts4.5/utils/globalScope/globalScope.d.ts

@@ -0,0 +1,21 @@
+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?: NumericalCardDimensions, error?: MediaCardErrorInfo, globalScope?: any) => void;
+export type StoreSSRDataScriptProps = {
+    identifier: FileIdentifier;
+    dataURI?: string;
+    dimensions?: NumericalCardDimensions;
+    error?: MediaCardErrorInfo;
+};
+export declare const StoreSSRDataScript: React.FC<StoreSSRDataScriptProps>;

package/dist/types-ts4.5/utils/globalScope/index.d.ts

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

package/dist/types-ts4.5/utils/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?: NumericalCardDimensions;
+    error?: MediaCardErrorInfo;
+};
+export type MediaCardSsr = Record<string, MediaCardSsrData>;

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

@@ -0,0 +1,6 @@
+export { isRetina } from './isRetina';
+export { defaultHorizontalCardDimensions, defaultImageCardDimensions, defaultSquareCardDimensions, getDefaultCardDimensions, } from './cardDimensions';
+export { isValidPercentageUnit } from './isValidPercentageUnit';
+export { getElementDimension } from './getElementDimension';
+export type { ElementDimension } from './getElementDimension';
+export { containsPixelUnit } from './containsPixelUnit';

package/dist/types-ts4.5/utils/isRetina.d.ts

@@ -0,0 +1 @@
+export declare function isRetina(): boolean;

package/dist/types-ts4.5/utils/isValidPercentageUnit.d.ts

@@ -0,0 +1 @@
+export declare const isValidPercentageUnit: (value: string | number) => boolean;

package/dist/types-ts4.5/utils/lightCards/cardError.d.ts

@@ -0,0 +1,12 @@
+import { Component } from 'react';
+import { StaticCardProps } from './types';
+export interface ErrorCardProps extends StaticCardProps {
+    readonly size: 'small' | 'medium' | 'large' | 'xlarge';
+}
+export declare class CardError extends Component<ErrorCardProps, {}> {
+    static defaultProps: {
+        size: string;
+    };
+    render(): JSX.Element;
+    get icon(): JSX.Element;
+}

package/dist/types-ts4.5/utils/lightCards/cardLoading.d.ts

@@ -0,0 +1,5 @@
+import { Component } from 'react';
+import { StaticCardProps } from './types';
+export declare class CardLoading extends Component<StaticCardProps, {}> {
+    render(): JSX.Element;
+}

package/dist/types-ts4.5/utils/lightCards/errorIcon/index.d.ts

@@ -0,0 +1,12 @@
+/**@jsx jsx */
+import { jsx } from '@emotion/react';
+import { Component } from 'react';
+export interface ErrorIconProps {
+    readonly size: 'small' | 'medium' | 'large' | 'xlarge';
+}
+export declare class ErrorIcon extends Component<ErrorIconProps, {}> {
+    static defaultProps: {
+        size: string;
+    };
+    render(): jsx.JSX.Element;
+}

package/dist/types-ts4.5/utils/lightCards/errorIcon/styles.d.ts

@@ -0,0 +1 @@
+export declare const errorIconWrapperStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/utils/lightCards/getDimensionsWithDefault.d.ts

@@ -0,0 +1,2 @@
+import { CardDimensions } from '../../types';
+export declare const getDimensionsWithDefault: (dimensions?: CardDimensions) => CardDimensions;

package/dist/types-ts4.5/utils/lightCards/lightCardWrappers.d.ts

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

package/dist/types-ts4.5/utils/lightCards/styles.d.ts

@@ -0,0 +1,2 @@
+import { WrapperProps } from './types';
+export declare const wrapperStyles: ({ dimensions, theme }: WrapperProps) => import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/utils/lightCards/types.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { CardDimensions } from '../../types';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { GlobalThemeTokens } from '@atlaskit/theme/components';
+export interface StaticCardProps {
+    dimensions?: CardDimensions;
+    testId?: string;
+    featureFlags?: MediaFeatureFlags;
+}
+export interface WrapperProps {
+    dimensions: CardDimensions;
+    testId?: string;
+    children?: JSX.Element;
+    theme?: GlobalThemeTokens;
+}

package/dist/types-ts4.5/utils/metadata.d.ts

@@ -0,0 +1,2 @@
+import { FileState, FileDetails, Identifier } from '@atlaskit/media-client';
+export declare const getFileDetails: (identifier: Identifier, fileState?: FileState) => FileDetails;

package/dist/types-ts4.5/utils/mockIntersectionObserver.d.ts

@@ -0,0 +1,20 @@
+type NestedPartial<T> = {
+    [K in keyof T]?: Partial<T[K]>;
+};
+type SetupOptions = {
+    observe?: () => void;
+    disconnect?: () => void;
+};
+export declare class MockIntersectionObserver {
+    private callback;
+    private originalObserver?;
+    private mockObserver?;
+    private mockObserverInstance?;
+    private storeMockObserver;
+    private addMockObserverToWindow;
+    private removeMockObserverFromWindow;
+    setup(options?: SetupOptions): void;
+    cleanup(): void;
+    triggerIntersect(entry: NestedPartial<IntersectionObserverEntry>): void;
+}
+export {};

package/dist/types-ts4.5/utils/objectURLCache.d.ts

@@ -0,0 +1,12 @@
+import { CardPreview } 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): CardPreview | undefined;
+    set(key: string, value: CardPreview): void;
+    remove(key: string): void;
+    clear(): void;
+}
+export declare const createObjectURLCache: () => ObjectURLCache;

package/dist/types-ts4.5/utils/preventClickThrough.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ReactNode } from 'react';
+export type PreventClickThroughProps = {
+    readonly children?: ReactNode;
+};
+export declare function PreventClickThrough({ children, }: PreventClickThroughProps): JSX.Element;
+export type CreatePreventClickThrough = <T>(onClick: () => void) => (event: React.MouseEvent<T, MouseEvent>) => void;
+export declare const createPreventClickThrough: CreatePreventClickThrough;

package/dist/types-ts4.5/utils/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-ts4.5/utils/ufoExperiences.d.ts

@@ -0,0 +1,14 @@
+import { CardStatus } from '../types';
+import { FileAttributes } from '@atlaskit/media-common';
+import { SSRStatus } from './analytics';
+import { MediaCardError } from '../errors';
+import { FileStateFlags } from '../types';
+type SucceedUfoPayload = {
+    fileAttributes: FileAttributes;
+    ssrReliability: SSRStatus;
+    fileStateFlags: FileStateFlags;
+};
+export declare const startUfoExperience: (id: string) => void;
+export declare const completeUfoExperience: (id: string, status: CardStatus, fileAttributes: FileAttributes, fileStateFlags: FileStateFlags, ssrReliability: SSRStatus, error?: MediaCardError) => void;
+export declare const abortUfoExperience: (id: string, properties?: Partial<SucceedUfoPayload>) => void;
+export {};