@atlaskit/media-ui 22.1.2 → 22.1.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @atlaskit/media-ui
 
+## 22.1.3
+
+### Patch Changes
+
+- [`8cc2f888c83`](https://bitbucket.org/atlassian/atlassian-frontend/commits/8cc2f888c83) - Upgrade Typescript from `4.3.5` to `4.5.5`
+
 ## 22.1.2
 
 ### Patch Changes

package/browser/package.json

@@ -4,5 +4,12 @@
   "module": "../dist/esm/browser.js",
   "module:es2019": "../dist/es2019/browser.js",
   "sideEffects": false,
-  "types": "../dist/types/browser.d.ts"
+  "types": "../dist/types/browser.d.ts",
+  "typesVersions": {
+    ">=4.0 <4.5": {
+      "*": [
+        "../dist/types-ts4.0/browser.d.ts"
+      ]
+    }
+  }
 }

package/classNames/package.json

@@ -4,5 +4,12 @@
   "module": "../dist/esm/classNames.js",
   "module:es2019": "../dist/es2019/classNames.js",
   "sideEffects": false,
-  "types": "../dist/types/classNames.d.ts"
+  "types": "../dist/types/classNames.d.ts",
+  "typesVersions": {
+    ">=4.0 <4.5": {
+      "*": [
+        "../dist/types-ts4.0/classNames.d.ts"
+      ]
+    }
+  }
 }

package/codeViewer/package.json

@@ -4,5 +4,12 @@
   "module": "../dist/esm/codeViewer.js",
   "module:es2019": "../dist/es2019/codeViewer.js",
   "sideEffects": false,
-  "types": "../dist/types/codeViewer.d.ts"
+  "types": "../dist/types/codeViewer.d.ts",
+  "typesVersions": {
+    ">=4.0 <4.5": {
+      "*": [
+        "../dist/types-ts4.0/codeViewer.d.ts"
+      ]
+    }
+  }
 }

package/dist/cjs/customMediaPlayer/index.js

@@ -96,7 +96,7 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 var packageName = "@atlaskit/media-ui";
-var packageVersion = "22.1.2";
+var packageVersion = "22.1.3";
 var MEDIUM_VIDEO_MAX_WIDTH = 400;
 var SMALL_VIDEO_MAX_WIDTH = 160;
 var MINIMUM_DURATION_BEFORE_SAVING_TIME = 60;

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/media-ui",
-	"version": "22.1.2",
+	"version": "22.1.3",
 	"sideEffects": false
 }

package/dist/es2019/customMediaPlayer/index.js

@@ -31,7 +31,7 @@ import Tooltip from '@atlaskit/tooltip';
 import { SkipTenBackwardIcon, SkipTenForwardIcon } from './icons';
 import { getControlsWrapperClassName } from './getControlsWrapperClassName';
 const packageName = "@atlaskit/media-ui";
-const packageVersion = "22.1.2";
+const packageVersion = "22.1.3";
 const MEDIUM_VIDEO_MAX_WIDTH = 400;
 const SMALL_VIDEO_MAX_WIDTH = 160;
 const MINIMUM_DURATION_BEFORE_SAVING_TIME = 60;

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/media-ui",
-	"version": "22.1.2",
+	"version": "22.1.3",
 	"sideEffects": false
 }

package/dist/esm/customMediaPlayer/index.js

@@ -46,7 +46,7 @@ import Tooltip from '@atlaskit/tooltip';
 import { SkipTenBackwardIcon, SkipTenForwardIcon } from './icons';
 import { getControlsWrapperClassName } from './getControlsWrapperClassName';
 var packageName = "@atlaskit/media-ui";
-var packageVersion = "22.1.2";
+var packageVersion = "22.1.3";
 var MEDIUM_VIDEO_MAX_WIDTH = 400;
 var SMALL_VIDEO_MAX_WIDTH = 160;
 var MINIMUM_DURATION_BEFORE_SAVING_TIME = 60;

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/media-ui",
-	"version": "22.1.2",
+	"version": "22.1.3",
 	"sideEffects": false
 }

package/dist/types-ts4.0/MediaButton.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from 'react';
+import { ButtonProps } from '@atlaskit/button/types';
+import { CustomThemeButtonProps, Appearance } from '@atlaskit/button/types';
+declare type MediaButtonAppearance = Appearance;
+declare type WithMediaButtonAppearance<T> = Omit<T, 'appearance'> & {
+    appearance?: MediaButtonAppearance;
+};
+export interface MediaButtonProps extends ButtonProps {
+    buttonRef?: RefObject<HTMLButtonElement>;
+}
+declare type Props = WithMediaButtonAppearance<CustomThemeButtonProps> & {
+    buttonRef?: RefObject<HTMLButtonElement>;
+};
+export default function MediaButton({ appearance, buttonRef, ...rest }: Props): JSX.Element;
+export {};

package/dist/types-ts4.0/MediaInlineCard/ErroredView/index.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+export interface MediaInlineCardErroredViewProps {
+    /** The error message to display */
+    message: string;
+    /** The optional click handler */
+    onClick?: React.EventHandler<React.MouseEvent | React.KeyboardEvent>;
+    /** A flag that determines whether the card is selected in edit mode. */
+    isSelected?: boolean;
+    /** A `testId` prop is provided for specified elements, which is a unique string that appears as a data attribute `data-testid` in the rendered code, serving as a hook for automated tests */
+    testId?: string;
+    icon?: React.ReactNode;
+}
+export declare class MediaInlineCardErroredView extends React.Component<MediaInlineCardErroredViewProps> {
+    renderMessage: () => JSX.Element;
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/MediaInlineCard/Frame/index.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+export interface FrameViewProps {
+    /** A flag that determines whether the card is selected in edit mode. */
+    isSelected?: boolean;
+    isInteractive?: boolean;
+    children?: React.ReactNode;
+    /** The optional click handler */
+    onClick?: React.EventHandler<React.MouseEvent | React.KeyboardEvent>;
+    /** A `testId` prop is provided for specified elements, which is a unique string that appears as a data attribute `data-testid` in the rendered code, serving as a hook for automated tests */
+    testId?: string;
+}
+export declare class Frame extends React.Component<FrameViewProps> {
+    handleClick: (event: React.MouseEvent<HTMLDivElement>) => void;
+    handleKeyPress: (event: React.KeyboardEvent<HTMLDivElement>) => void;
+    handleMouseDown: (e: React.MouseEvent) => void;
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/MediaInlineCard/Frame/styled.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export interface WrapperProps {
+    isSelected?: boolean;
+}
+export declare const Wrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, WrapperProps, object>;

package/dist/types-ts4.0/MediaInlineCard/Icon.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const Icon: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, Pick<import("react").ClassAttributes<HTMLImageElement> & import("react").ImgHTMLAttributes<HTMLImageElement>, keyof import("react").ImgHTMLAttributes<HTMLImageElement>>, object>;
+export declare const AKIconWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;

package/dist/types-ts4.0/MediaInlineCard/IconAndTitleLayout/index.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+export interface IconAndTitleLayoutProps {
+    emoji?: React.ReactNode;
+    icon?: React.ReactNode;
+    title: React.ReactNode;
+    right?: React.ReactNode;
+    titleColor?: string;
+    children?: React.ReactNode;
+    defaultIcon?: React.ReactNode;
+    testId?: string;
+}
+export declare class IconAndTitleLayout extends React.Component<IconAndTitleLayoutProps> {
+    private renderAtlaskitIcon;
+    private renderImageIcon;
+    private renderIconPlaceholder;
+    renderIcon(testId: string): JSX.Element;
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/MediaInlineCard/IconAndTitleLayout/styled.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export declare const IconObjectOverrides = "\n  & > span {\n    height: 16px;\n    width: 14px;\n    position: absolute;\n    top: 0;\n    left: 0;\n    line-height: 14px;\n    & > svg {\n      position: absolute;\n      top: 50%;\n      left: 50%;\n      transform: translate(-50%, -50%);\n    }\n  }\n";
+export declare const IconOverrides = "\n  & > * > span {\n    height: 16px;\n    width: 14px;\n    position: absolute;\n    top: 0;\n    left: 0;\n    & > svg {\n      position: absolute;\n      top: 50%;\n      left: 50%;\n      transform: translate(-50%, -50%);\n    }\n  }\n";
+export declare const IconWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
+export declare const EmojiWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
+export declare const IconTitleWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
+export declare const LozengeWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
+export declare const LozengeBlockWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
+export declare const RightIconPositionWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
+export declare const IconPositionWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
+export declare const IconEmptyWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
+export declare const TitleWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;

package/dist/types-ts4.0/MediaInlineCard/LoadedView/index.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+export interface MediaInlineCardLoadedViewProps {
+    /** The optional con of the service (e.g. Dropbox/Asana/Google/etc) to display */
+    icon?: React.ReactNode;
+    /** The name of the resource */
+    title?: string;
+    /** A flag that determines whether the card is selected in edit mode. */
+    isSelected?: boolean;
+    /** The optional click handler */
+    onClick?: React.EventHandler<React.MouseEvent | React.KeyboardEvent>;
+    /** A `testId` prop is provided for specified elements, which is a unique string that appears as a data attribute `data-testid` in the rendered code, serving as a hook for automated tests */
+    testId?: string;
+    /** The Emoji icon prefix that was added to the title text via Add emoji button */
+    titlePrefix?: React.ReactNode;
+}
+export declare class MediaInlineCardLoadedView extends React.Component<MediaInlineCardLoadedViewProps> {
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/MediaInlineCard/LoadingView/index.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { InlinePreloaderStyle } from '../../types';
+export interface MediaInlineCardLoadingViewProps {
+    /** The file name to display */
+    message: string;
+    inlinePreloaderStyle?: InlinePreloaderStyle;
+    /** The optional click handler */
+    onClick?: React.EventHandler<React.MouseEvent | React.KeyboardEvent>;
+    /** A flag that determines whether the card is selected in edit mode. */
+    isSelected?: boolean;
+    /** A `testId` prop is provided for specified elements, which is a unique string that appears as a data attribute `data-testid` in the rendered code, serving as a hook for automated tests */
+    testId?: string;
+    withoutHover?: boolean;
+}
+export declare class MediaInlineCardLoadingView extends React.Component<MediaInlineCardLoadingViewProps> {
+    render(): JSX.Element;
+}

package/dist/types-ts4.0/MediaInlineCard/LoadingView/styled.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+export declare const SpinnerWrapper: import("@emotion/styled-base").StyledComponent<Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement> & Pick<Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, keyof import("react").HTMLAttributes<HTMLSpanElement>> & {
+    theme?: object | undefined;
+} & {
+    children?: import("react").ReactNode;
+}, "key" | keyof import("react").HTMLAttributes<HTMLSpanElement> | "theme"> & {
+    ref?: ((instance: HTMLSpanElement | null) => void) | import("react").RefObject<HTMLSpanElement> | null | undefined;
+}, Pick<Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement> & Pick<Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, keyof import("react").HTMLAttributes<HTMLSpanElement>> & {
+    theme?: object | undefined;
+} & {
+    children?: import("react").ReactNode;
+}, "key" | keyof import("react").HTMLAttributes<HTMLSpanElement> | "theme"> & {
+    ref?: ((instance: HTMLSpanElement | null) => void) | import("react").RefObject<HTMLSpanElement> | null | undefined;
+}, keyof import("react").HTMLAttributes<HTMLSpanElement> | "theme">, object>;

package/dist/types-ts4.0/MediaInlineCard/index.d.ts

@@ -0,0 +1,6 @@
+export { MediaInlineCardLoadingView } from './LoadingView';
+export type { MediaInlineCardLoadingViewProps } from './LoadingView';
+export { MediaInlineCardLoadedView } from './LoadedView';
+export type { MediaInlineCardLoadedViewProps } from './LoadedView';
+export { MediaInlineCardErroredView } from './ErroredView';
+export type { MediaInlineCardErroredViewProps } from './ErroredView';

package/dist/types-ts4.0/MediaInlineCard/styled.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare const NoLinkAppearance: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("@emotion/styled-base/types/helper").Overwrapped<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, import("@atlaskit/theme").ThemeProps | undefined>, never>, {
+    __ATLASKIT_THEME__: import("@atlaskit/theme").Theme;
+}>;

package/dist/types-ts4.0/browser.d.ts

@@ -0,0 +1,6 @@
+declare type mockedNavigator = {
+    userAgent: string;
+    platform: string;
+};
+export declare function isWebkitSupported(mockedNavigator?: mockedNavigator): boolean;
+export {};

package/dist/types-ts4.0/camera.d.ts

@@ -0,0 +1,62 @@
+export declare class Vector2 {
+    readonly x: number;
+    readonly y: number;
+    constructor(x: number, y: number);
+    add({ x: thatX, y: thatY }: Vector2): Vector2;
+    sub({ x: thatX, y: thatY }: Vector2): Vector2;
+    scaled(scalar: number): Vector2;
+    map(fn: (component: number) => number): Vector2;
+    clone(): Vector2;
+    rounded(): Vector2;
+    toString(): string;
+}
+export declare class Rectangle {
+    readonly width: number;
+    readonly height: number;
+    constructor(width: number, height: number);
+    get aspectRatio(): number;
+    get center(): Vector2;
+    scaled(scale: number): Rectangle;
+    resized(width: number, height: number): Rectangle;
+    flipped(): Rectangle;
+    scaleToFit(containing: Rectangle): number;
+    scaleToFitLargestSide(containing: Rectangle): number;
+    scaleToFitSmallestSide(containing: Rectangle): number;
+    clone(): Rectangle;
+}
+export declare class Bounds extends Rectangle {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    constructor(x: number, y: number, width: number, height: number);
+    get origin(): Vector2;
+    get corner(): Vector2;
+    get center(): Vector2;
+    get rect(): Rectangle;
+    get left(): number;
+    get top(): number;
+    get right(): number;
+    get bottom(): number;
+    flipped(): Bounds;
+    scaled(scale: number): Bounds;
+    relativeTo(bounds: Bounds): Bounds;
+    clone(): Bounds;
+    map(fn: (value: number) => number): Bounds;
+    hFlipWithin(containerBounds: Bounds): Bounds;
+    vFlipWithin(containerBounds: Bounds): Bounds;
+    rotate90DegWithin(containerBounds: Bounds): Bounds;
+    translated(xDelta: number, yDelta: number): Bounds;
+    equals(bounds: Bounds): boolean;
+}
+export declare class Camera {
+    readonly viewport: Rectangle;
+    readonly originalImg: Rectangle;
+    constructor(viewport: Rectangle, originalImg: Rectangle);
+    resizedViewport(newViewport: Rectangle): Camera;
+    get scaleToFit(): number;
+    get scaleDownToFit(): number;
+    get fittedImg(): Rectangle;
+    scaledImg(newScale: number): Rectangle;
+    scaledOffset(prevOffset: Vector2, prevScale: number, newScale: number): Vector2;
+}

package/dist/types-ts4.0/classNames.d.ts

@@ -0,0 +1 @@
+export declare const hideControlsClassName = "mvng-hide-controls";

package/dist/types-ts4.0/codeViewer.d.ts

@@ -0,0 +1,8 @@
+import type { SupportedLanguages } from '@atlaskit/code/types';
+/**
+ * Given an item, it grabs the file name of that item. For example, an item with the filename item.txt
+ * would return the extension txt
+ */
+export declare function getExtension(filename: string): string;
+export declare function isCodeViewerItem(name: string, mimetype?: string): boolean;
+export declare function getLanguageType(name: string, mimetype?: string): SupportedLanguages | null;

package/dist/types-ts4.0/customMediaPlayer/analytics/events/screen/customMediaPlayer.d.ts

@@ -0,0 +1,5 @@
+import { ScreenAttributes, ScreenEventPayload } from '@atlaskit/media-common';
+import { PlaybackState, WithPlaybackAttributes } from '../../utils/playbackAttributes';
+import { CustomMediaPlayerType, WithCustomMediaPlayerType } from '../../../types';
+export declare type CustomMediaPlayerScreenEventPayload = ScreenEventPayload<ScreenAttributes & WithPlaybackAttributes & WithCustomMediaPlayerType, 'customMediaPlayerScreen'>;
+export declare const createCustomMediaPlayerScreenEvent: (type: CustomMediaPlayerType, playbackState: PlaybackState, fileId?: string | undefined) => CustomMediaPlayerScreenEventPayload;

package/dist/types-ts4.0/customMediaPlayer/analytics/events/track/playCount.d.ts

@@ -0,0 +1,5 @@
+import { TrackAttributes, TrackEventPayload } from '@atlaskit/media-common';
+import { PlaybackState, WithPlaybackAttributes } from '../../utils/playbackAttributes';
+import { CustomMediaPlayerType, WithCustomMediaPlayerType } from '../../../types';
+export declare type FirstPlayedTrackEventPayload = TrackEventPayload<TrackAttributes & WithPlaybackAttributes & WithCustomMediaPlayerType, 'firstPlayed', 'customMediaPlayer'>;
+export declare const createFirstPlayedTrackEvent: (type: CustomMediaPlayerType, playbackState: PlaybackState, fileId?: string | undefined) => FirstPlayedTrackEventPayload;

package/dist/types-ts4.0/customMediaPlayer/analytics/events/track/played.d.ts

@@ -0,0 +1,5 @@
+import { TrackAttributes, TrackEventPayload } from '@atlaskit/media-common';
+import { PlaybackState, WithPlaybackAttributes } from '../../utils/playbackAttributes';
+import { CustomMediaPlayerType, WithCustomMediaPlayerType } from '../../../types';
+export declare type PlayedTrackEventPayload = TrackEventPayload<TrackAttributes & WithPlaybackAttributes & WithCustomMediaPlayerType, 'played', 'customMediaPlayer'>;
+export declare const createPlayedTrackEvent: (type: CustomMediaPlayerType, playbackState: PlaybackState, fileId?: string | undefined) => PlayedTrackEventPayload;

package/dist/types-ts4.0/customMediaPlayer/analytics/events/ui/mediaButtonClicked.d.ts

@@ -0,0 +1,5 @@
+import { UIAttributes, UIEventPayload } from '@atlaskit/media-common';
+import { PlaybackState, WithPlaybackAttributes } from '../../utils/playbackAttributes';
+import { CustomMediaPlayerType, WithCustomMediaPlayerType } from '../../../types';
+export declare type MediaButtonClickEventPayload = UIEventPayload<UIAttributes & WithPlaybackAttributes & WithCustomMediaPlayerType, 'clicked', 'button'>;
+export declare function createMediaButtonClickedEvent(type: CustomMediaPlayerType, playbackState: PlaybackState, buttonType?: string, fileId?: string): MediaButtonClickEventPayload;

package/dist/types-ts4.0/customMediaPlayer/analytics/events/ui/playPauseBlanketClicked.d.ts

@@ -0,0 +1,5 @@
+import { UIAttributes, UIEventPayload } from '@atlaskit/media-common';
+import { PlaybackState, WithPlaybackAttributes } from '../../utils/playbackAttributes';
+import { CustomMediaPlayerType, WithCustomMediaPlayerType } from '../../../types';
+export declare type PlayPauseBlanketClickEventPayload = UIEventPayload<UIAttributes & WithPlaybackAttributes & WithCustomMediaPlayerType, 'clicked', 'playPauseBlanket'>;
+export declare function createPlayPauseBlanketClickedEvent(type: CustomMediaPlayerType, playbackState: PlaybackState, fileId?: string): PlayPauseBlanketClickEventPayload;

package/dist/types-ts4.0/customMediaPlayer/analytics/events/ui/playbackSpeedChanged.d.ts

@@ -0,0 +1,5 @@
+import { UIAttributes, UIEventPayload } from '@atlaskit/media-common';
+import { PlaybackState, WithPlaybackAttributes } from '../../utils/playbackAttributes';
+import { CustomMediaPlayerType, WithCustomMediaPlayerType } from '../../../types';
+export declare type PlaybackSpeedChangeEventPayload = UIEventPayload<UIAttributes & WithPlaybackAttributes & WithCustomMediaPlayerType, 'changed', 'playbackSpeed'>;
+export declare function createPlaybackSpeedChangedEvent(type: CustomMediaPlayerType, playbackState: PlaybackState, fileId?: string): PlaybackSpeedChangeEventPayload;

package/dist/types-ts4.0/customMediaPlayer/analytics/events/ui/shortcutPressed.d.ts

@@ -0,0 +1,5 @@
+import { UIAttributes, UIEventPayload } from '@atlaskit/media-common';
+import { PlaybackState, WithPlaybackAttributes } from '../../utils/playbackAttributes';
+import { CustomMediaPlayerType, WithCustomMediaPlayerType } from '../../../types';
+export declare type ShortcutPressEventPayload = UIEventPayload<UIAttributes & WithPlaybackAttributes & WithCustomMediaPlayerType, 'pressed', 'shortcut'>;
+export declare function createMediaShortcutPressedEvent(type: CustomMediaPlayerType, playbackState: PlaybackState, shortcutType?: string, fileId?: string): ShortcutPressEventPayload;

package/dist/types-ts4.0/customMediaPlayer/analytics/events/ui/timeRangeNavigated.d.ts

@@ -0,0 +1,5 @@
+import { UIAttributes, UIEventPayload } from '@atlaskit/media-common';
+import { PlaybackState, WithPlaybackAttributes } from '../../utils/playbackAttributes';
+import { CustomMediaPlayerType, WithCustomMediaPlayerType } from '../../../types';
+export declare type TimeRangeNavigateEventPayload = UIEventPayload<UIAttributes & WithPlaybackAttributes & WithCustomMediaPlayerType, 'navigated', 'timeRange'>;
+export declare function createTimeRangeNavigatedEvent(type: CustomMediaPlayerType, playbackState: PlaybackState, actionSubjectId?: string, fileId?: string): TimeRangeNavigateEventPayload;

package/dist/types-ts4.0/customMediaPlayer/analytics/index.d.ts

@@ -0,0 +1,11 @@
+export { createCustomMediaPlayerScreenEvent } from './events/screen/customMediaPlayer';
+export { createMediaButtonClickedEvent } from './events/ui/mediaButtonClicked';
+export { createPlaybackSpeedChangedEvent } from './events/ui/playbackSpeedChanged';
+export { createPlayPauseBlanketClickedEvent } from './events/ui/playPauseBlanketClicked';
+export { createMediaShortcutPressedEvent } from './events/ui/shortcutPressed';
+export { createTimeRangeNavigatedEvent } from './events/ui/timeRangeNavigated';
+export { createFirstPlayedTrackEvent } from './events/track/playCount';
+export { createPlayedTrackEvent } from './events/track/played';
+export type { CustomMediaPlayerUIEvent, CustomMediaPlayerUIEventPayload, CustomMediaPlayerAnalyticsEventPayload, } from './utils/analytics';
+export { createAndFireMediaCustomMediaPlayerEvent, fireAnalyticsEvent, relevantFeatureFlagNames, } from './utils/analytics';
+export type { PlaybackAttributes, PlaybackState, WithPlaybackProps, WithMediaPlayerState, } from './utils/playbackAttributes';

package/dist/types-ts4.0/customMediaPlayer/analytics/utils/analytics.d.ts

@@ -0,0 +1,19 @@
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { MediaFeatureFlags, UIAttributes, UIEventPayload } from '@atlaskit/media-common';
+import { CustomMediaPlayerScreenEventPayload } from '../events/screen/customMediaPlayer';
+import { MediaButtonClickEventPayload } from '../events/ui/mediaButtonClicked';
+import { PlaybackSpeedChangeEventPayload } from '../events/ui/playbackSpeedChanged';
+import { PlayPauseBlanketClickEventPayload } from '../events/ui/playPauseBlanketClicked';
+import { ShortcutPressEventPayload } from '../events/ui/shortcutPressed';
+import { TimeRangeNavigateEventPayload } from '../events/ui/timeRangeNavigated';
+import { FirstPlayedTrackEventPayload } from '../events/track/playCount';
+import { PlayedTrackEventPayload } from '../events/track/played';
+import { CustomMediaPlayerType } from '../../types';
+export declare type CustomMediaPlayerUIEventPayload = UIEventPayload<UIAttributes & {
+    type: CustomMediaPlayerType;
+}, 'default', 'customMediaPlayer'>;
+export declare type CustomMediaPlayerUIEvent = 'mediaButtonClick' | 'shortcutPress' | 'playPauseBlanketClick' | 'timeRangeNavigate' | 'volumeRangeNavigate' | 'playbackSpeedChange';
+export declare type CustomMediaPlayerAnalyticsEventPayload = CustomMediaPlayerScreenEventPayload | MediaButtonClickEventPayload | PlaybackSpeedChangeEventPayload | PlayPauseBlanketClickEventPayload | ShortcutPressEventPayload | TimeRangeNavigateEventPayload | CustomMediaPlayerUIEventPayload | FirstPlayedTrackEventPayload | PlayedTrackEventPayload;
+export declare const relevantFeatureFlagNames: Array<keyof MediaFeatureFlags>;
+export declare function fireAnalyticsEvent(payload: CustomMediaPlayerAnalyticsEventPayload, createAnalyticsEvent?: CreateUIAnalyticsEvent): void;
+export declare const createAndFireMediaCustomMediaPlayerEvent: (payload: CustomMediaPlayerAnalyticsEventPayload) => (createAnalyticsEvent: CreateUIAnalyticsEvent) => import("@atlaskit/analytics-next").UIAnalyticsEvent;

package/dist/types-ts4.0/customMediaPlayer/analytics/utils/playbackAttributes.d.ts

@@ -0,0 +1,24 @@
+import { VideoState, VideoStatus } from 'react-video-renderer';
+export declare type WithPlaybackProps = {
+    readonly isAutoPlay: boolean;
+    readonly isHDAvailable?: boolean;
+    readonly isHDActive?: boolean;
+};
+export declare type WithMediaPlayerState = {
+    playerSize: 'small' | 'medium' | 'large';
+    isFullScreenEnabled: boolean;
+    playbackSpeed: number;
+};
+export declare type PlaybackState = WithPlaybackProps & WithMediaPlayerState & Partial<VideoState>;
+export declare type PlaybackAttributes = WithPlaybackProps & WithMediaPlayerState & {
+    durationInSec?: number;
+    absoluteTimeInSec?: number;
+    relativeTime?: number;
+    status?: VideoStatus;
+    volume?: number;
+    isMuted?: boolean;
+};
+export declare type WithPlaybackAttributes = {
+    playbackAttributes: Partial<PlaybackAttributes>;
+};
+export declare function createPlaybackAttributes(playbackState: PlaybackState): Partial<PlaybackAttributes>;

package/dist/types-ts4.0/customMediaPlayer/fullscreen.d.ts

@@ -0,0 +1,5 @@
+export declare const findVendorSpecificProp: (object: any, propNames: string | string[]) => any;
+export declare const requestFullscreen: (element: HTMLElement) => void;
+export declare const exitFullscreen: () => void;
+export declare const getFullscreenElement: () => HTMLElement | undefined;
+export declare const toggleFullscreen: (element?: HTMLElement | undefined) => void;

package/dist/types-ts4.0/customMediaPlayer/getControlsWrapperClassName.d.ts

@@ -0,0 +1 @@
+export declare const getControlsWrapperClassName: (wasPlayedOnce: boolean) => "mvng-hide-controls" | "";

package/dist/types-ts4.0/customMediaPlayer/icons.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { GlyphProps } from '@atlaskit/icon/types';
+export declare function SkipTenBackwardIcon(props: GlyphProps): JSX.Element;
+export declare function SkipTenForwardIcon(props: GlyphProps): JSX.Element;

package/dist/types-ts4.0/customMediaPlayer/index.d.ts

@@ -0,0 +1,76 @@
+import React from 'react';
+import { Component } from 'react';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+import { NumericalCardDimensions } from '@atlaskit/media-common';
+import { CustomMediaPlayerType } from './types';
+import { WithPlaybackProps, WithMediaPlayerState } from './analytics';
+import { WrappedComponentProps } from 'react-intl-next';
+import { WithShowControlMethodProp } from '../types';
+import { TimeSaverConfig } from './timeSaver';
+export interface CustomMediaPlayerProps extends WithPlaybackProps, WithShowControlMethodProp {
+    readonly type: CustomMediaPlayerType;
+    readonly src: string;
+    readonly fileId?: string;
+    readonly onHDToggleClick?: () => void;
+    readonly isShortcutEnabled?: boolean;
+    readonly lastWatchTimeConfig?: TimeSaverConfig;
+    readonly onCanPlay?: () => void;
+    readonly onError?: () => void;
+    readonly onDownloadClick?: () => void;
+    readonly onFirstPlay?: () => void;
+    readonly onFullscreenChange?: (fullscreen: boolean) => void;
+    readonly originalDimensions?: NumericalCardDimensions;
+    readonly featureFlags?: MediaFeatureFlags;
+    readonly poster?: string;
+}
+export interface CustomMediaPlayerState extends WithMediaPlayerState {
+}
+export declare type Action = () => void;
+export declare class CustomMediaPlayerBase extends Component<CustomMediaPlayerProps & WrappedComponentProps & WithAnalyticsEventsProps, CustomMediaPlayerState> {
+    videoWrapperRef: React.RefObject<HTMLDivElement>;
+    private actions?;
+    private videoState;
+    private wasPlayedOnce;
+    private lastCurrentTime;
+    private readonly timeSaver;
+    private clickToTogglePlayTimoutId;
+    state: CustomMediaPlayerState;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private onFullScreenChange;
+    private onTimeChanged;
+    private onVolumeChanged;
+    private onCurrentTimeChange;
+    private renderCurrentTime;
+    private renderHDButton;
+    private onPlaybackSpeedChange;
+    private renderSpeedControls;
+    private renderVolume;
+    private toggleFullscreen;
+    private onFullScreenButtonClick;
+    private onResize;
+    private renderFullScreenButton;
+    private renderDownloadButton;
+    private renderShortcuts;
+    private renderPlayPauseButton;
+    private renderSkipBackwardButton;
+    private renderSkipForwardButton;
+    private renderSpinner;
+    private setActions;
+    pause: () => void;
+    private play;
+    private getMediaButtonClickHandler;
+    private getKeyboardShortcutHandler;
+    private createAndFireUIEvent;
+    private onViewed;
+    private resetPendingPlayPauseToggleTimer;
+    private doubleClickToFullscreen;
+    private togglePlayByBlanketClick;
+    private startPlayByBlanketClick;
+    private pausePlayByBlanketClick;
+    private startPlayByButtonClick;
+    private pausePlayByButtonClick;
+    render(): JSX.Element;
+}
+export declare const CustomMediaPlayer: React.ComponentType<CustomMediaPlayerProps & WithAnalyticsEventsProps>;

package/dist/types-ts4.0/customMediaPlayer/playPauseBlanket.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const PlayPauseBlanket: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;

package/dist/types-ts4.0/customMediaPlayer/playbackSpeedControls.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { Component } from 'react';
+import { NumericalCardDimensions } from '@atlaskit/media-common';
+import { WrappedComponentProps } from 'react-intl-next';
+export interface PlaybackSpeedControlsProps {
+    playbackSpeed: number;
+    onPlaybackSpeedChange: (playbackSpeed: number) => void;
+    originalDimensions?: NumericalCardDimensions;
+    onClick?: () => void;
+}
+export interface PlaybackSpeedControlsState {
+    popupHeight: number;
+}
+export declare class PlaybackSpeedControls extends Component<PlaybackSpeedControlsProps & WrappedComponentProps, PlaybackSpeedControlsState> {
+    state: PlaybackSpeedControlsState;
+    private onPlaybackSpeedChange;
+    private speedOptions;
+    private popupCustomStyles;
+    private onResize;
+    render(): JSX.Element;
+}
+declare const _default: React.FC<PlaybackSpeedControlsProps>;
+export default _default;

package/dist/types-ts4.0/customMediaPlayer/simultaneousPlayManager.d.ts

@@ -0,0 +1,9 @@
+export interface Pausable {
+    pause: () => any;
+}
+declare const _default: {
+    pauseOthers: (player: Pausable) => void;
+    subscribe: (player: Pausable) => void;
+    unsubscribe: (player: Pausable) => void;
+};
+export default _default;