@atlaskit/media-card 74.1.6 → 74.1.8

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

@@ -0,0 +1,49 @@
+/**@jsx jsx */
+import { jsx } from '@emotion/react';
+import { Component, ReactNode } from 'react';
+import { MediaItemType, MediaType, ImageResizeMode } from '@atlaskit/media-client';
+import { CardStatus, CardPreview, CardDimensions } from '../../types';
+import { CardAction } from '../actions';
+export interface FileCardImageViewProps {
+    readonly mediaName?: string;
+    readonly mediaType?: MediaType;
+    readonly mimeType?: string;
+    readonly fileSize?: string;
+    readonly dataURI?: string;
+    readonly alt?: string;
+    readonly progress?: number;
+    readonly status: CardStatus;
+    readonly mediaItemType: MediaItemType;
+    readonly dimensions?: CardDimensions;
+    readonly resizeMode?: ImageResizeMode;
+    readonly disableOverlay?: boolean;
+    readonly selectable?: boolean;
+    readonly selected?: boolean;
+    readonly error?: ReactNode;
+    readonly actions?: CardAction[];
+    readonly onDisplayImage?: () => void;
+    readonly previewOrientation?: number;
+    readonly onImageError?: (cardPreview: CardPreview) => void;
+    readonly onImageLoad?: (cardPreview: CardPreview) => void;
+    readonly cardPreview: CardPreview;
+}
+export declare class FileCardImageView extends Component<FileCardImageViewProps> {
+    private wasThumbnailDisplayed;
+    static defaultProps: Partial<FileCardImageViewProps>;
+    render(): jsx.JSX.Element;
+    private renderCardContents;
+    private renderLoadingContents;
+    private renderErrorContents;
+    private renderFailedContents;
+    private renderUploadingCardOverlay;
+    private renderPlayButton;
+    onImageLoad: () => void;
+    onImageError: () => void;
+    private renderMediaImage;
+    private renderProgressBar;
+    private renderSuccessCardContents;
+    private renderSuccessCardOverlay;
+    private get isFileCardImageReadyForDisplay();
+    private get isCropped();
+    private get isStretched();
+}

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

@@ -0,0 +1,2 @@
+export { FileCardImageView } from './fileCardImageView';
+export type { FileCardImageViewProps } from './fileCardImageView';

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

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import { GlobalThemeTokens } from '@atlaskit/theme/components';
+import { CardStatus } from '../../types';
+export interface WrapperProps {
+    disableOverlay?: boolean;
+    selectable?: boolean;
+    selected?: boolean;
+    hasOnClick?: boolean;
+    mediaType?: string;
+    mediaName?: string;
+    progress?: number;
+    status?: CardStatus;
+    theme?: GlobalThemeTokens;
+    children?: JSX.Element | JSX.Element[];
+}
+export declare const wrapperStyles: (props: WrapperProps) => import("@emotion/react").SerializedStyles;
+export declare const playIconWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const playIconBackgroundStyles: import("@emotion/react").SerializedStyles;
+export declare const progressBarWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const overlayStyles: import("@emotion/react").SerializedStyles;
+export declare const titleStyles: import("@emotion/react").SerializedStyles;
+export declare const bodyStyles: import("@emotion/react").SerializedStyles;
+export declare const progressWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const cardActionsWrapperStyles: import("@emotion/react").SerializedStyles;

package/dist/types/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 declare type CardWithMediaClientConfigProps = WithMediaClientConfigProps<CardBaseProps>;
+declare const CardLoader: React.FC<CardWithMediaClientConfigProps>;
+export default CardLoader;

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

@@ -0,0 +1,5 @@
+import { FileState } from '@atlaskit/media-client';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { CardState } from '../types';
+export declare const createStateUpdater: (newState: Partial<CardState>) => (prevState: CardState) => Pick<CardState, keyof CardState>;
+export declare const getCardStateFromFileState: (fileState: FileState, isBannedLocalPreview: boolean, featureFlags?: MediaFeatureFlags | undefined) => Partial<CardState>;

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

@@ -0,0 +1,80 @@
+/** @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;
+}
+export interface CardViewState {
+    elementWidth?: number;
+    didImageRender: boolean;
+}
+export declare 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 width();
+    private get breakpoint();
+    saveElementWidth: () => void;
+    render(): jsx.JSX.Element;
+    private renderSpinner;
+    private shouldRenderPlayButton;
+    private renderPlayButton;
+    private renderBlanket;
+    private renderTitleBox;
+    private renderFailedTitleBox;
+    private renderProgressBar;
+    private renderImageRenderer;
+    private renderTickBox;
+    private renderMediaTypeIcon;
+    private renderActionsBar;
+    private renderFileNewExperience;
+    private renderFile;
+    private getRenderConfigByStatus;
+    private renderNewExperienceCard;
+}
+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/card/getCardPreview/cache.d.ts

@@ -0,0 +1,19 @@
+import { ImageResizeMode } from '@atlaskit/media-client';
+import { ObjectURLCache } from '../../utils/objectURLCache';
+import { CardPreview } from '../../types';
+declare 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;
+}
+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;
+}
+declare const _default: CardPreviewCacheImpl;
+export default _default;

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { CardDimensions } from '../../types';
+import { CardPreviewAttributes } from '../../utils/analytics';
+declare type cardAction = 'cache-hit' | 'remote-success';
+export declare const fireImageFetchingOperationalEvent: (createAnalyticsEvent: CreateUIAnalyticsEvent, action: cardAction, cardPreviewAttributes: CardPreviewAttributes) => void;
+export declare const calculatePercentageDifference: (prevDimensions: CardDimensions | undefined, currentDimensions: CardDimensions | undefined) => {
+    width: string;
+    height: string;
+} | undefined;
+export {};

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

@@ -0,0 +1,57 @@
+import { MediaClient, FilePreview, FileState, MediaStoreGetFileImageParams, MediaBlobUrlAttrs, FileIdentifier } from '@atlaskit/media-client';
+import { MediaFeatureFlags, SSR } from '@atlaskit/media-common';
+import { ImageResizeMode } from '@atlaskit/media-client';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+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 declare type CardPreviewParams = {
+    mediaClient: MediaClient;
+    id: string;
+    dimensions?: CardDimensions;
+    filePreview?: FilePreview | Promise<FilePreview>;
+    onLocalPreviewError?: (error: MediaCardError) => void;
+    isRemotePreviewReady: boolean;
+    imageUrlParams: MediaStoreGetFileImageParams;
+    mediaBlobUrlAttrs?: MediaBlobUrlAttrs;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    featureFlags?: MediaFeatureFlags;
+};
+/**
+ * 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, createAnalyticsEvent, featureFlags, }: CardPreviewParams) => Promise<CardPreview>;
+export declare const shouldResolvePreview: ({ status, fileState, prevDimensions, dimensions, identifier, fileImageMode, hasCardPreview, isBannedLocalPreview, featureFlags, }: {
+    status: CardStatus;
+    fileState: FileState;
+    prevDimensions?: CardDimensions | undefined;
+    dimensions?: CardDimensions | undefined;
+    identifier: FileIdentifier;
+    fileImageMode?: ImageResizeMode | undefined;
+    hasCardPreview: boolean;
+    isBannedLocalPreview: boolean;
+    featureFlags?: MediaFeatureFlags | undefined;
+}) => boolean;
+export declare const getSSRCardPreview: (ssr: SSR, mediaClient: MediaClient, id: string, params: MediaStoreGetFileImageParams, mediaBlobUrlAttrs?: MediaBlobUrlAttrs | undefined) => 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 | undefined) => Promise<CardPreview>;

package/dist/types/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, { hasFilesize, isPreviewable, hasPreview }: FilePreviewStatus) => CardStatus;

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

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

package/dist/types/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 declare 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/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/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/card/styles/animations.d.ts

@@ -0,0 +1 @@
+export declare const spin: import("@emotion/serialize").Keyframes;

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

@@ -0,0 +1 @@
+export declare const defaultTransitionDuration = ".3s";

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

@@ -0,0 +1,2 @@
+export declare const easeOutCubic = "cubic-bezier(0.215, 0.61, 0.355, 1)";
+export declare const easeOutExpo = "cubic-bezier(0.19, 1, 0.22, 1)";

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

@@ -0,0 +1,3 @@
+export declare const getSelectedBorderStyle: ({ selected, }: {
+    selected?: boolean | undefined;
+}) => string;

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

@@ -0,0 +1,9 @@
+export { defaultTransitionDuration } from './config';
+export { antialiased, borderRadiusLeft, capitalize, centerSelf, centerSelfX, centerSelfY, centerX, hexToRgb, rgba, spaceAround, transition, withAppearance, } from './mixins';
+export type { WithAppearanceProps } from './mixins';
+export { easeOutCubic, easeOutExpo } from './easing';
+export { spin } from './animations';
+export declare const rootStyles: () => import("@emotion/react").SerializedStyles;
+export declare const cardShadow = "\n  box-shadow: 0 1px 1px rgba(9, 30, 66, 0.2), 0 0 1px 0 rgba(9, 30, 66, 0.24);\n";
+export declare const fadeinImageStyles: () => import("@emotion/react").SerializedStyles;
+export default rootStyles;

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

@@ -0,0 +1,21 @@
+import { CardAppearance } from '../../types';
+export declare const centerX = "\n  display: flex;\n  justify-content: center;\n";
+export declare const antialiased = "\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n";
+export declare const centerSelfY = "\n  position: absolute;\n  top: 50%;\n  transform: translateY(-50%);\n";
+export declare const centerSelfX = "\n  position: absolute;\n  left: 50%;\n  transform: translateX(-50%);\n";
+export declare const centerSelf = "\n  position: absolute;\n  left: 50%;\n  top: 50%;\n  transform: translate(-50%, -50%);\n";
+export declare const borderRadiusLeft: string;
+export declare const spaceAround = "\n  display: flex;\n  flex-direction: column;\n  justify-content: space-around;\n";
+export declare const transition: (propertyName?: string) => string;
+export declare const hexToRgb: (hex: any) => string | null;
+export declare const rgba: (hex: any, opacity: any) => string;
+export declare const capitalize = "\n  &::first-letter {\n    text-transform: uppercase;\n  }\n";
+export interface WithAppearanceProps {
+    appearance?: CardAppearance;
+}
+export declare const withAppearance: (styleMap: {
+    auto?: string | undefined;
+    image?: string | undefined;
+    square?: string | undefined;
+    horizontal?: string | undefined;
+}) => ({ appearance }: WithAppearanceProps) => string;

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

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

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

@@ -0,0 +1,24 @@
+import React, { MouseEvent, ReactElement, RefObject } from 'react';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { CardDimensions } from '../types';
+import { BreakpointSizeValue } from '../utils/breakpoint';
+export interface WrapperProps {
+    testId?: string;
+    shouldUsePointerCursor?: boolean;
+    dimensions?: CardDimensions;
+    breakpointSize?: BreakpointSizeValue;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    onMouseEnter?: (event: MouseEvent<HTMLDivElement>) => void;
+    innerRef?: RefObject<HTMLDivElement>;
+    children?: JSX.Element;
+}
+export declare type InlinePlayerWrapperProps = {
+    testId?: string;
+    dimensions?: CardDimensions;
+    selected: {
+        selected?: boolean | undefined;
+    };
+    onClick?: (event: React.MouseEvent<HTMLDivElement>, analyticsEvent?: UIAnalyticsEvent) => void;
+    innerRef?: RefObject<HTMLDivElement> | ((instance: HTMLDivElement | null) => void) | undefined;
+    children?: JSX.Element[] | ReactElement<any, any> | null | any;
+};

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

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

package/dist/types/card/ui/actionsBar/actionsBarWrapper.d.ts

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

package/dist/types/card/ui/actionsBar/styles.d.ts

@@ -0,0 +1,6 @@
+export declare const actionsBarClassName = "media-card-actions-bar";
+export declare const fixedActionBarStyles = "opacity: 1;";
+export declare const wrapperStyles: {
+    (isFixed?: boolean | undefined): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

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

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { CardAction } from '../../actions';
+export interface ActionsBarProps {
+    actions: Array<CardAction>;
+    isFixed?: boolean;
+}
+export declare type ActionBarWrapperProps = {
+    isFixed?: boolean;
+    children?: ReactNode;
+};

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

@@ -0,0 +1,6 @@
+/**@jsx jsx */
+import { jsx } from '@emotion/react';
+export interface BlanketProps {
+    isFixed?: boolean;
+}
+export declare const Blanket: (props: BlanketProps) => jsx.JSX.Element;

package/dist/types/card/ui/blanket/styles.d.ts

@@ -0,0 +1,6 @@
+export declare const blanketClassName = "media-card-blanket";
+export declare const fixedBlanketStyles: string;
+export declare const blanketStyles: {
+    (isFixed?: boolean | undefined): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

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

@@ -0,0 +1,23 @@
+export declare enum Breakpoint {
+    SMALL = "small",
+    LARGE = "large"
+}
+export declare const responsiveSettings: {
+    small: {
+        fontSize: number;
+        lineHeight: number;
+        titleBox: {
+            verticalPadding: number;
+            horizontalPadding: number;
+        };
+    };
+    large: {
+        fontSize: number;
+        lineHeight: number;
+        titleBox: {
+            verticalPadding: number;
+            horizontalPadding: number;
+        };
+    };
+};
+export declare const getTitleBoxHeight: (breakpoint: Breakpoint) => number;

package/dist/types/card/ui/iconMessage/iconMessageWrapper.d.ts

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

package/dist/types/card/ui/iconMessage/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { InternalIconMessageProps, CreatingPreviewProps } from './types';
+export declare const IconMessage: React.FC<InternalIconMessageProps>;
+export declare const CreatingPreview: React.FC<CreatingPreviewProps>;
+export declare const PreviewUnavailable: React.FC;
+export declare const FailedToLoad: React.FC;
+export declare const FailedToUpload: React.FC;
+export declare const PreviewCurrentlyUnavailable: React.FC;

package/dist/types/card/ui/iconMessage/styles.d.ts

@@ -0,0 +1,5 @@
+import { StyledTextProps } from './types';
+export declare const iconMessageWrapperStyles: {
+    (props: StyledTextProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

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

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { MessageDescriptor } from 'react-intl-next';
+export declare type InternalIconMessageProps = {
+    messageDescriptor: MessageDescriptor;
+    animated?: boolean;
+    reducedFont?: boolean;
+};
+export declare type CreatingPreviewProps = {
+    disableAnimation?: boolean;
+};
+export declare type StyledTextProps = {
+    animated?: boolean;
+    reducedFont?: boolean;
+};
+export declare type IconMessageWrapperProps = {
+    animated?: boolean;
+    reducedFont?: boolean;
+    children?: ReactNode;
+};

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

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

package/dist/types/card/ui/iconWrapper/styles.d.ts

@@ -0,0 +1,7 @@
+import { Breakpoint } from '../common';
+import { IconWrapperProps } from './types';
+export declare function titleBoxHeight(hasTitleBox: boolean, breakpoint: Breakpoint): string;
+export declare const iconWrapperStyles: {
+    ({ hasTitleBox, breakpoint, }: IconWrapperProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};

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

@@ -0,0 +1,6 @@
+import { Breakpoint } from '../common';
+export declare type IconWrapperProps = {
+    hasTitleBox: boolean;
+    breakpoint: Breakpoint;
+    children?: any;
+};

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

@@ -0,0 +1,15 @@
+import React from 'react';
+import { MediaType, ImageResizeMode } from '@atlaskit/media-client';
+import { CardPreview } from '../../../types';
+export declare type ImageRendererProps = {
+    readonly cardPreview: CardPreview;
+    readonly mediaType: MediaType;
+    readonly alt?: string;
+    readonly resizeMode?: ImageResizeMode;
+    readonly onDisplayImage?: () => void;
+    readonly onImageError?: (cardPreview: CardPreview) => void;
+    readonly onImageLoad?: (cardPreview: CardPreview) => void;
+    readonly nativeLazyLoad?: boolean;
+    readonly forceSyncDisplay?: boolean;
+};
+export declare const ImageRenderer: React.FC<ImageRendererProps>;

package/dist/types/card/ui/loadingRateLimited/styles.d.ts

@@ -0,0 +1,13 @@
+import { Breakpoint } from '../common';
+export declare const loadingRateLimitedContainerStyles: import("@emotion/react").SerializedStyles;
+export declare const warningIconWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare type StyledTextProps = {
+    breakpoint: Breakpoint;
+    positionBottom: boolean;
+};
+export declare const loadingRateLimitedTextWrapperStyles: {
+    ({ breakpoint, positionBottom, }: StyledTextProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};
+export declare const couldntLoadWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const errorWrapperStyles: import("@emotion/react").SerializedStyles;

package/dist/types/card/ui/newFileExperience/newFileExperienceWrapper.d.ts

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

package/dist/types/card/ui/newFileExperience/styles.d.ts

@@ -0,0 +1,5 @@
+import { NewFileExperienceWrapperProps } from './types';
+export declare const newFileExperienceWrapperStyles: {
+    ({ breakpoint, dimensions, appearance, disableOverlay, displayBackground, selected, isPlayButtonClickable, isTickBoxSelectable, shouldDisplayTooltip, mediaCardCursor, }: NewFileExperienceWrapperProps): import("@emotion/react").SerializedStyles;
+    displayName: string;
+};