@remotion/player 4.0.0-alpha.4 → 4.0.0-alpha11

package/dist/esm/event-emitter.d.ts

@@ -0,0 +1,81 @@
+declare type SeekPayload = {
+    frame: number;
+};
+declare type ErrorPayload = {
+    error: Error;
+};
+declare type TimeUpdateEventPayload = {
+    frame: number;
+};
+declare type FrameUpdateEventPayload = {
+    frame: number;
+};
+declare type RateChangeEventPayload = {
+    playbackRate: number;
+};
+declare type ScaleChangeEventPayload = {
+    scale: number;
+};
+declare type VolumeChangeEventPayload = {
+    volume: number;
+};
+declare type FullscreenChangeEventPayload = {
+    isFullscreen: boolean;
+};
+declare type MuteChangeEventPayload = {
+    isMuted: boolean;
+};
+declare type PlayerStateEventMap = {
+    seeked: SeekPayload;
+    pause: undefined;
+    play: undefined;
+    ratechange: RateChangeEventPayload;
+    scalechange: ScaleChangeEventPayload;
+    volumechange: VolumeChangeEventPayload;
+    ended: undefined;
+    error: ErrorPayload;
+    timeupdate: TimeUpdateEventPayload;
+    frameupdate: FrameUpdateEventPayload;
+    fullscreenchange: FullscreenChangeEventPayload;
+    mutechange: MuteChangeEventPayload;
+};
+declare type ThumbnailStateEventMap = {
+    error: ErrorPayload;
+};
+export declare type PlayerEventTypes = keyof PlayerStateEventMap;
+export declare type ThumbnailEventTypes = keyof ThumbnailStateEventMap;
+export declare type CallbackListener<T extends PlayerEventTypes> = (data: {
+    detail: PlayerStateEventMap[T];
+}) => void;
+declare type PlayerListeners = {
+    [EventType in PlayerEventTypes]: CallbackListener<EventType>[];
+};
+declare type ThumbnailListeners = {
+    [EventType in ThumbnailEventTypes]: CallbackListener<EventType>[];
+};
+export declare class PlayerEmitter {
+    listeners: PlayerListeners;
+    addEventListener<Q extends PlayerEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    removeEventListener<Q extends PlayerEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    private dispatchEvent;
+    dispatchSeek(frame: number): void;
+    dispatchVolumeChange(volume: number): void;
+    dispatchPause(): void;
+    dispatchPlay(): void;
+    dispatchEnded(): void;
+    dispatchRateChange(playbackRate: number): void;
+    dispatchScaleChange(scale: number): void;
+    dispatchError(error: Error): void;
+    dispatchTimeUpdate(event: TimeUpdateEventPayload): void;
+    dispatchFrameUpdate(event: FrameUpdateEventPayload): void;
+    dispatchFullscreenChange(event: FullscreenChangeEventPayload): void;
+    dispatchMuteChange(event: MuteChangeEventPayload): void;
+}
+export declare class ThumbnailEmitter {
+    listeners: ThumbnailListeners;
+    addEventListener<Q extends ThumbnailEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    removeEventListener<Q extends ThumbnailEventTypes>(name: Q, callback: CallbackListener<Q>): void;
+    private dispatchEvent;
+    dispatchError(error: Error): void;
+}
+export {};

package/dist/esm/format-time.d.ts

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

package/dist/esm/icons.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export declare const ICON_SIZE = 25;
+export declare const fullscreenIconSize = 16;
+export declare const PlayIcon: React.FC;
+export declare const PauseIcon: React.FC;
+export declare const FullscreenIcon: React.FC<{
+    isFullscreen: boolean;
+}>;
+export declare const VolumeOffIcon: React.FC;
+export declare const VolumeOnIcon: React.FC;
+export declare const SettingsIcon: React.FC<{
+    iconSize?: number;
+}>;

package/dist/esm/index.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="react" />
+import type { CallbackListener, PlayerEventTypes } from './event-emitter.js';
+import { PlayerEmitter } from './event-emitter.js';
+export { PlayerMethods, PlayerRef, ThumbnailMethods, ThumbnailRef, } from './player-methods.js';
+export { Player, PlayerProps } from './Player.js';
+export type { RenderFullscreenButton, RenderPlayPauseButton, } from './PlayerControls.js';
+export type { ErrorFallback, RenderLoading, RenderPoster } from './PlayerUI.js';
+export { Thumbnail } from './Thumbnail.js';
+export { PreviewSize, Translation } from './utils/preview-size.js';
+export { Size } from './utils/use-element-size.js';
+export type { CallbackListener, PlayerEventTypes as EventTypes };
+export declare const PlayerInternals: {
+    PlayerEventEmitterContext: import("react").Context<PlayerEmitter | undefined>;
+    PlayerEmitter: typeof PlayerEmitter;
+    usePlayer: () => {
+        frameBack: (frames: number) => void;
+        frameForward: (frames: number) => void;
+        isLastFrame: boolean;
+        isFirstFrame: boolean;
+        emitter: PlayerEmitter;
+        playing: boolean;
+        play: (e?: import("react").SyntheticEvent<Element, Event> | undefined) => void;
+        pause: () => void;
+        pauseAndReturnToPlayStart: () => void;
+        seek: (newFrame: number) => void;
+        getCurrentFrame: () => number;
+        isPlaying: () => boolean;
+        hasPlayed: boolean;
+    };
+    usePlayback: ({ loop, playbackRate, moveToBeginningWhenEnded, inFrame, outFrame, }: {
+        loop: boolean;
+        playbackRate: number;
+        moveToBeginningWhenEnded: boolean;
+        inFrame: number | null;
+        outFrame: number | null;
+    }) => void;
+    useElementSize: (ref: import("react").RefObject<HTMLElement>, options: {
+        triggerOnWindowResize: boolean;
+        shouldApplyCssTransforms: boolean;
+    }) => import("./utils/use-element-size.js").Size | null;
+    calculateCanvasTransformation: ({ previewSize, compositionWidth, compositionHeight, canvasSize, }: {
+        previewSize: number | "auto";
+        compositionWidth: number;
+        compositionHeight: number;
+        canvasSize: import("./utils/use-element-size.js").Size;
+    }) => {
+        centerX: number;
+        centerY: number;
+        xCorrection: number;
+        yCorrection: number;
+        scale: number;
+    };
+    useHoverState: (ref: import("react").RefObject<HTMLDivElement>) => boolean;
+    updateAllElementsSizes: () => void;
+    calculateScale: ({ canvasSize, compositionHeight, compositionWidth, previewSize, }: {
+        previewSize: number | "auto";
+        compositionWidth: number;
+        compositionHeight: number;
+        canvasSize: import("./utils/use-element-size.js").Size;
+    }) => number;
+};