@remotion/player 4.1.0-alpha10 → 4.1.0-alpha12

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/icons.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export const ICON_SIZE = 25;
+export const fullscreenIconSize = 16;
+export const PlayIcon = () => {
+    return (_jsx("svg", { width: ICON_SIZE, height: ICON_SIZE, viewBox: "0 0 25 25", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: _jsx("path", { d: "M8 6.375C7.40904 8.17576 7.06921 10.2486 7.01438 12.3871C6.95955 14.5255 7.19163 16.6547 7.6875 18.5625C9.95364 18.2995 12.116 17.6164 14.009 16.5655C15.902 15.5147 17.4755 14.124 18.6088 12.5C17.5158 10.8949 15.9949 9.51103 14.1585 8.45082C12.3222 7.3906 10.2174 6.68116 8 6.375Z", fill: "white", stroke: "white", strokeWidth: "6.25", strokeLinejoin: "round" }) }));
+};
+export const PauseIcon = () => {
+    return (_jsxs("svg", { viewBox: "0 0 100 100", width: ICON_SIZE, height: ICON_SIZE, children: [_jsx("rect", { x: "25", y: "20", width: "20", height: "60", fill: "#fff", ry: "5", rx: "5" }), _jsx("rect", { x: "55", y: "20", width: "20", height: "60", fill: "#fff", ry: "5", rx: "5" })] }));
+};
+export const FullscreenIcon = ({ isFullscreen, }) => {
+    const strokeWidth = 6;
+    const viewSize = 32;
+    const out = isFullscreen ? 0 : strokeWidth / 2;
+    const middleInset = isFullscreen ? strokeWidth * 1.6 : strokeWidth / 2;
+    const inset = isFullscreen ? strokeWidth * 1.6 : strokeWidth * 2;
+    return (_jsxs("svg", { viewBox: `0 0 ${viewSize} ${viewSize}`, height: fullscreenIconSize, width: fullscreenIconSize, children: [_jsx("path", { d: `
+				M ${out} ${inset}
+				L ${middleInset} ${middleInset}
+				L ${inset} ${out}
+				`, stroke: "#fff", strokeWidth: strokeWidth, fill: "none" }), _jsx("path", { d: `
+				M ${viewSize - out} ${inset}
+				L ${viewSize - middleInset} ${middleInset}
+				L ${viewSize - inset} ${out}
+				`, stroke: "#fff", strokeWidth: strokeWidth, fill: "none" }), _jsx("path", { d: `
+				M ${out} ${viewSize - inset}
+				L ${middleInset} ${viewSize - middleInset}
+				L ${inset} ${viewSize - out}
+				`, stroke: "#fff", strokeWidth: strokeWidth, fill: "none" }), _jsx("path", { d: `
+				M ${viewSize - out} ${viewSize - inset}
+				L ${viewSize - middleInset} ${viewSize - middleInset}
+				L ${viewSize - inset} ${viewSize - out}
+				`, stroke: "#fff", strokeWidth: strokeWidth, fill: "none" })] }));
+};
+export const VolumeOffIcon = () => {
+    return (_jsx("svg", { width: ICON_SIZE, height: ICON_SIZE, viewBox: "0 0 24 24", children: _jsx("path", { d: "M3.63 3.63a.996.996 0 000 1.41L7.29 8.7 7 9H4c-.55 0-1 .45-1 1v4c0 .55.45 1 1 1h3l3.29 3.29c.63.63 1.71.18 1.71-.71v-4.17l4.18 4.18c-.49.37-1.02.68-1.6.91-.36.15-.58.53-.58.92 0 .72.73 1.18 1.39.91.8-.33 1.55-.77 2.22-1.31l1.34 1.34a.996.996 0 101.41-1.41L5.05 3.63c-.39-.39-1.02-.39-1.42 0zM19 12c0 .82-.15 1.61-.41 2.34l1.53 1.53c.56-1.17.88-2.48.88-3.87 0-3.83-2.4-7.11-5.78-8.4-.59-.23-1.22.23-1.22.86v.19c0 .38.25.71.61.85C17.18 6.54 19 9.06 19 12zm-8.71-6.29l-.17.17L12 7.76V6.41c0-.89-1.08-1.33-1.71-.7zM16.5 12A4.5 4.5 0 0014 7.97v1.79l2.48 2.48c.01-.08.02-.16.02-.24z", fill: "#fff" }) }));
+};
+export const VolumeOnIcon = () => {
+    return (_jsx("svg", { width: ICON_SIZE, height: ICON_SIZE, viewBox: "0 0 24 24", children: _jsx("path", { d: "M3 10v4c0 .55.45 1 1 1h3l3.29 3.29c.63.63 1.71.18 1.71-.71V6.41c0-.89-1.08-1.34-1.71-.71L7 9H4c-.55 0-1 .45-1 1zm13.5 2A4.5 4.5 0 0014 7.97v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 4.45v.2c0 .38.25.71.6.85C17.18 6.53 19 9.06 19 12s-1.82 5.47-4.4 6.5c-.36.14-.6.47-.6.85v.2c0 .63.63 1.07 1.21.85C18.6 19.11 21 15.84 21 12s-2.4-7.11-5.79-8.4c-.58-.23-1.21.22-1.21.85z", fill: "#fff" }) }));
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/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;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/index.js

@@ -0,0 +1,20 @@
+import { calculateCanvasTransformation, calculateScale, } from './calculate-scale.js';
+import { PlayerEventEmitterContext } from './emitter-context.js';
+import { PlayerEmitter } from './event-emitter.js';
+import { useHoverState } from './use-hover-state.js';
+import { usePlayback } from './use-playback.js';
+import { usePlayer } from './use-player.js';
+import { updateAllElementsSizes, useElementSize, } from './utils/use-element-size.js';
+export { Player } from './Player.js';
+export { Thumbnail } from './Thumbnail.js';
+export const PlayerInternals = {
+    PlayerEventEmitterContext,
+    PlayerEmitter,
+    usePlayer,
+    usePlayback,
+    useElementSize,
+    calculateCanvasTransformation,
+    useHoverState,
+    updateAllElementsSizes,
+    calculateScale,
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/is-backgrounded.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const useIsBackgrounded: () => import("react").MutableRefObject<boolean>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/is-backgrounded.js

@@ -0,0 +1,20 @@
+import { useEffect, useRef } from 'react';
+const getIsBackgrounded = () => {
+    if (typeof document === 'undefined') {
+        return false;
+    }
+    return document.visibilityState === 'hidden';
+};
+export const useIsBackgrounded = () => {
+    const isBackgrounded = useRef(getIsBackgrounded());
+    useEffect(() => {
+        const onVisibilityChange = () => {
+            isBackgrounded.current = getIsBackgrounded();
+        };
+        document.addEventListener('visibilitychange', onVisibilityChange);
+        return () => {
+            document.removeEventListener('visibilitychange', onVisibilityChange);
+        };
+    }, []);
+    return isBackgrounded;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/player-css-classname.d.ts

@@ -0,0 +1 @@
+export declare const PLAYER_CSS_CLASSNAME = "__remotion-player";

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/player-css-classname.js

@@ -0,0 +1 @@
+export const PLAYER_CSS_CLASSNAME = '__remotion-player';

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/player-methods.d.ts

@@ -0,0 +1,24 @@
+import type { SyntheticEvent } from 'react';
+import type { PlayerEmitter } from './event-emitter.js';
+export type ThumbnailMethods = {
+    getContainerNode: () => HTMLDivElement | null;
+    getScale: () => number;
+};
+export type PlayerMethods = ThumbnailMethods & {
+    play: (e?: SyntheticEvent) => void;
+    pause: () => void;
+    toggle: (e?: SyntheticEvent) => void;
+    seekTo: (frame: number) => void;
+    getCurrentFrame: () => number;
+    requestFullscreen: () => void;
+    exitFullscreen: () => void;
+    isFullscreen: () => boolean;
+    setVolume: (num: number) => void;
+    getVolume: () => number;
+    isMuted: () => boolean;
+    isPlaying: () => boolean;
+    mute: () => void;
+    unmute: () => void;
+};
+export type ThumbnailRef = PlayerEmitter & ThumbnailMethods;
+export type PlayerRef = PlayerEmitter & PlayerMethods;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/player-methods.js

@@ -0,0 +1 @@
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/test/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/test/index.test.js

@@ -0,0 +1,7 @@
+import { expect, test } from 'vitest';
+import { usePlayer } from '../use-player.js';
+test('It should throw an error if not being used inside a RemotionRoot', () => {
+    expect(() => {
+        usePlayer();
+    }).toThrow();
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/test/test-utils.d.ts

@@ -0,0 +1,6 @@
+import type { queries, RenderOptions } from '@testing-library/react';
+import type { FC, ReactElement } from 'react';
+declare const HelloWorld: FC;
+declare const customRender: (ui: ReactElement, options?: Omit<RenderOptions, 'queries'>) => import("@testing-library/react").RenderResult<typeof queries, HTMLElement, HTMLElement>;
+export * from '@testing-library/react';
+export { customRender as render, HelloWorld };

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/test/test-utils.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+const HelloWorld = () => {
+    return _jsx("div", { children: "Hello World" });
+};
+const AllTheProviders = ({ children }) => {
+    // overwriting console.error console does not gets poluted with all the errors
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    window.console.error = () => { };
+    return _jsx("div", { children: children });
+};
+const customRender = (ui, options) => render(ui, { wrapper: AllTheProviders, ...options });
+export * from '@testing-library/react';
+export { customRender as render, HelloWorld };

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/test/validate-in-out-frames.test.d.ts

@@ -0,0 +1 @@
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/test/validate-in-out-frames.test.js

@@ -0,0 +1,54 @@
+import { expect, test } from 'vitest';
+import { validateInOutFrames } from '../utils/validate-in-out-frame.js';
+test('Validate in out frames', () => {
+    expect(() => validateInOutFrames({
+        durationInFrames: 200,
+        inFrame: 201,
+        outFrame: undefined,
+    })).toThrow(/inFrame must be less than \(durationInFrames - 1\)/);
+    expect(() => validateInOutFrames({
+        durationInFrames: 200,
+        inFrame: 199,
+        outFrame: 201,
+    })).toThrow(/outFrame must be less than \(durationInFrames - 1\)/);
+    expect(() => validateInOutFrames({
+        durationInFrames: 200,
+        inFrame: -10,
+        outFrame: null,
+    })).toThrow(/inFrame must be greater than 0, but is -10/);
+    expect(() => validateInOutFrames({
+        durationInFrames: 200,
+        inFrame: null,
+        outFrame: -10,
+    })).toThrow(/outFrame must be greater than 0, but is -10/);
+    expect(() => validateInOutFrames({
+        durationInFrames: 200,
+        inFrame: 1.5,
+        outFrame: null,
+    })).toThrow(/"inFrame" must be an integer, but is 1.5/);
+    expect(() => validateInOutFrames({
+        durationInFrames: 200,
+        inFrame: 20,
+        outFrame: 20,
+    })).toThrow(/outFrame must be greater than inFrame, but is 20/);
+    expect(() => validateInOutFrames({
+        durationInFrames: 200,
+        inFrame: 21,
+        outFrame: 20,
+    })).toThrow(/outFrame must be greater than inFrame, but is 20 <= 21/);
+    expect(() => validateInOutFrames({
+        durationInFrames: 200,
+        inFrame: null,
+        outFrame: 20,
+    })).not.toThrow();
+    expect(() => validateInOutFrames({
+        durationInFrames: 200,
+        inFrame: null,
+        outFrame: null,
+    })).not.toThrow();
+    expect(() => validateInOutFrames({
+        durationInFrames: 200,
+        inFrame: 10,
+        outFrame: 20,
+    })).not.toThrow();
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/test/validate-prop.test.d.ts

@@ -0,0 +1 @@
+export {};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/test/validate-prop.test.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Composition } from 'remotion';
+import { expect, test } from 'vitest';
+import { Player } from '../index.js';
+import { HelloWorld, render } from './test-utils.js';
+test('no compositionWidth should give errors', () => {
+    try {
+        render(_jsx(Player
+        // @ts-expect-error
+        , { 
+            // @ts-expect-error
+            compositionWidth: null, errorFallback: () => 'something went wrong', compositionHeight: 400, fps: 30, durationInFrames: 500, component: HelloWorld, controls: true, showVolumeControls: true }));
+    }
+    catch (e) {
+        expect(e.message).toMatch(/'compositionWidth' must be a number but got 'object' instead/);
+    }
+});
+test('no compositionHeight should give errors', () => {
+    try {
+        render(_jsx(Player, { compositionWidth: 400, errorFallback: () => 'something went wrong', 
+            // @ts-expect-error
+            compositionHeight: undefined, fps: 30, durationInFrames: 500, component: HelloWorld, controls: true, showVolumeControls: true }));
+    }
+    catch (e) {
+        expect(e.message).toMatch(/'compositionHeight' must be a number but got 'undefined' instead/);
+    }
+});
+test('No fps should give errors', () => {
+    try {
+        render(_jsx(Player, { compositionWidth: 500, compositionHeight: 400, errorFallback: () => 'something went wrong', 
+            // @ts-expect-error
+            fps: null, durationInFrames: 500, component: HelloWorld, controls: true, showVolumeControls: true }));
+    }
+    catch (e) {
+        expect(e.message).toMatch(/"fps" must be a number, but you passed a value of type object/);
+    }
+    try {
+        render(_jsx(Player, { compositionWidth: 500, compositionHeight: 400, errorFallback: () => 'something went wrong', 
+            // @ts-expect-error
+            fps: undefined, durationInFrames: 500, component: HelloWorld, controls: true, showVolumeControls: true }));
+    }
+    catch (e) {
+        expect(e.message).toMatch(/"fps" must be a number, but you passed a value of type undefined/);
+    }
+});
+test('No durationInFrames should give errors', () => {
+    try {
+        render(_jsx(Player, { compositionWidth: 500, compositionHeight: 400, errorFallback: () => 'something went wrong', fps: 30, 
+            // @ts-expect-error
+            durationInFrames: undefined, component: HelloWorld, controls: true, showVolumeControls: true }));
+    }
+    catch (e) {
+        expect(e.message).toMatch(/durationInFrames` must be a number, but is undefined/);
+    }
+});
+test('Invalid playbackRate should give error', () => {
+    try {
+        render(_jsx(Player, { compositionWidth: 500, compositionHeight: 400, fps: 30, durationInFrames: 500, component: HelloWorld, controls: true, showVolumeControls: true, playbackRate: -5, inputProps: {} }));
+    }
+    catch (e) {
+        expect(e.message).toMatch(/The lowest possible playback rate is -4. You passed: -5/);
+    }
+});
+test('playbackRate of 0 should not be possible', () => {
+    try {
+        render(_jsx(Player, { compositionWidth: 500, compositionHeight: 400, fps: 30, durationInFrames: 500, component: HelloWorld, controls: true, showVolumeControls: true, playbackRate: 0 }));
+    }
+    catch (e) {
+        expect(e.message).toMatch(/A playback rate of 0 is not supported./);
+    }
+});
+test('playbackRate of wrong type should not be possible', () => {
+    try {
+        render(_jsx(Player, { compositionWidth: 500, compositionHeight: 400, fps: 30, durationInFrames: 500, component: HelloWorld, controls: true, showVolumeControls: true, 
+            // @ts-expect-error
+            playbackRate: 'hi' }));
+    }
+    catch (e) {
+        expect(e.message).toMatch(/A playback rate of 0 is not supported./);
+    }
+});
+test('playbackRate of undefined should be okay', () => {
+    render(_jsx(Player, { compositionWidth: 500, compositionHeight: 400, fps: 30, durationInFrames: 500, component: HelloWorld, controls: true, showVolumeControls: true }));
+    expect(true).toBe(true);
+});
+test('passing in <Composition /> instance should not be possible', () => {
+    expect(() => {
+        render(_jsx(Player, { compositionWidth: 500, compositionHeight: 400, fps: 30, durationInFrames: 500, component: Composition, controls: true, showVolumeControls: true, inputProps: {
+                id: 'HelloWorld',
+                width: 500,
+                height: 400,
+                fps: 30,
+                durationInFrames: 500,
+                component: HelloWorld,
+            } }));
+    }).toThrow(/'component' must not be the 'Composition' component\. Pass your own React/);
+});
+test('passing in <Composition /> instance should not be possible', () => {
+    expect(() => {
+        render(_jsx(Player, { compositionWidth: 500, compositionHeight: 400, fps: 30, durationInFrames: 500, 
+            // @ts-expect-error
+            component: _jsx(Composition, { durationInFrames: 30, fps: 30, height: 10, width: 10, id: "hello", component: HelloWorld }), controls: true, showVolumeControls: true, inputProps: {
+                id: 'HelloWorld',
+                width: 500,
+                height: 400,
+                fps: 30,
+                durationInFrames: 500,
+                component: HelloWorld,
+            } }));
+    }).toThrow(/'component' should not be an instance of <Composition\/>\. Pass the React component dir/);
+});
+test.each([
+    ['controls'],
+    ['loop'],
+    ['autoPlay'],
+    ['showVolumeControls'],
+    ['allowFullscreen'],
+    ['clickToPlay'],
+    ['doubleClickToFullscreen'],
+])('No durationInFrames should give errors %s', (a) => {
+    const props = {};
+    props[a] = 'hey';
+    try {
+        render(_jsx(Player, { compositionWidth: 500, compositionHeight: 400, errorFallback: () => 'something went wrong', fps: 30, durationInFrames: 100, component: HelloWorld, ...props }));
+    }
+    catch (e) {
+        expect(e.message).toMatch(`'${a}' must be a boolean or undefined but got 'string' instead`);
+    }
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/use-hover-state.d.ts

@@ -0,0 +1 @@
+export declare const useHoverState: (ref: React.RefObject<HTMLDivElement>) => boolean;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/use-hover-state.js

@@ -0,0 +1,23 @@
+import { useEffect, useState } from 'react';
+export const useHoverState = (ref) => {
+    const [hovered, stetHovered] = useState(false);
+    useEffect(() => {
+        const { current } = ref;
+        if (!current) {
+            return;
+        }
+        const onHover = () => {
+            stetHovered(true);
+        };
+        const onLeave = () => {
+            stetHovered(false);
+        };
+        current.addEventListener('mouseenter', onHover);
+        current.addEventListener('mouseleave', onLeave);
+        return () => {
+            current.removeEventListener('mouseenter', onHover);
+            current.removeEventListener('mouseenter', onLeave);
+        };
+    }, [ref]);
+    return hovered;
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/use-playback.d.ts

@@ -0,0 +1,7 @@
+export declare const usePlayback: ({ loop, playbackRate, moveToBeginningWhenEnded, inFrame, outFrame, }: {
+    loop: boolean;
+    playbackRate: number;
+    moveToBeginningWhenEnded: boolean;
+    inFrame: number | null;
+    outFrame: number | null;
+}) => void;

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/use-playback.js

@@ -0,0 +1,125 @@
+import { useEffect, useRef } from 'react';
+import { Internals } from 'remotion';
+import { calculateNextFrame } from './calculate-next-frame.js';
+import { useIsBackgrounded } from './is-backgrounded.js';
+import { usePlayer } from './use-player.js';
+export const usePlayback = ({ loop, playbackRate, moveToBeginningWhenEnded, inFrame, outFrame, }) => {
+    const config = Internals.useUnsafeVideoConfig();
+    const frame = Internals.Timeline.useTimelinePosition();
+    const { playing, pause, emitter } = usePlayer();
+    const setFrame = Internals.Timeline.useTimelineSetFrame();
+    // requestAnimationFrame() does not work if the tab is not active.
+    // This means that audio will keep playing even if it has ended.
+    // In that case, we use setTimeout() instead.
+    const isBackgroundedRef = useIsBackgrounded();
+    const frameRef = useRef(frame);
+    frameRef.current = frame;
+    const lastTimeUpdateEvent = useRef(null);
+    useEffect(() => {
+        if (!config) {
+            return;
+        }
+        if (!playing) {
+            return;
+        }
+        let hasBeenStopped = false;
+        let reqAnimFrameCall = null;
+        const startedTime = performance.now();
+        let framesAdvanced = 0;
+        const cancelQueuedFrame = () => {
+            if (reqAnimFrameCall !== null) {
+                if (reqAnimFrameCall.type === 'raf') {
+                    cancelAnimationFrame(reqAnimFrameCall.id);
+                }
+                else {
+                    clearTimeout(reqAnimFrameCall.id);
+                }
+            }
+        };
+        const stop = () => {
+            hasBeenStopped = true;
+            cancelQueuedFrame();
+        };
+        const callback = () => {
+            const time = performance.now() - startedTime;
+            const actualLastFrame = outFrame !== null && outFrame !== void 0 ? outFrame : config.durationInFrames - 1;
+            const actualFirstFrame = inFrame !== null && inFrame !== void 0 ? inFrame : 0;
+            const { nextFrame, framesToAdvance, hasEnded } = calculateNextFrame({
+                time,
+                currentFrame: frameRef.current,
+                playbackSpeed: playbackRate,
+                fps: config.fps,
+                actualFirstFrame,
+                actualLastFrame,
+                framesAdvanced,
+                shouldLoop: loop,
+            });
+            framesAdvanced += framesToAdvance;
+            if (nextFrame !== frameRef.current &&
+                (!hasEnded || moveToBeginningWhenEnded)) {
+                setFrame((c) => ({ ...c, [config.id]: nextFrame }));
+            }
+            if (hasEnded) {
+                stop();
+                pause();
+                emitter.dispatchEnded();
+                return;
+            }
+            if (!hasBeenStopped) {
+                queueNextFrame();
+            }
+        };
+        const queueNextFrame = () => {
+            if (isBackgroundedRef.current) {
+                reqAnimFrameCall = {
+                    type: 'timeout',
+                    // Note: Most likely, this will not be 1000 / fps, but the browser will throttle it to ~1/sec.
+                    id: setTimeout(callback, 1000 / config.fps),
+                };
+            }
+            else {
+                reqAnimFrameCall = { type: 'raf', id: requestAnimationFrame(callback) };
+            }
+        };
+        queueNextFrame();
+        const onVisibilityChange = () => {
+            if (document.visibilityState === 'visible') {
+                return;
+            }
+            // If tab goes into the background, cancel requestAnimationFrame() and update immediately.
+            // , so the transition to setTimeout() can be fulfilled.
+            cancelQueuedFrame();
+            callback();
+        };
+        window.addEventListener('visibilitychange', onVisibilityChange);
+        return () => {
+            window.removeEventListener('visibilitychange', onVisibilityChange);
+            stop();
+        };
+    }, [
+        config,
+        loop,
+        pause,
+        playing,
+        setFrame,
+        emitter,
+        playbackRate,
+        inFrame,
+        outFrame,
+        moveToBeginningWhenEnded,
+        isBackgroundedRef,
+    ]);
+    useEffect(() => {
+        const interval = setInterval(() => {
+            if (lastTimeUpdateEvent.current === frameRef.current) {
+                return;
+            }
+            emitter.dispatchTimeUpdate({ frame: frameRef.current });
+            lastTimeUpdateEvent.current = frameRef.current;
+        }, 250);
+        return () => clearInterval(interval);
+    }, [emitter]);
+    useEffect(() => {
+        emitter.dispatchFrameUpdate({ frame });
+    }, [emitter, frame]);
+};

package/.rollup.cache/Users/jonathanburger/remotion/packages/player/dist/esm/use-player.d.ts

@@ -0,0 +1,19 @@
+import type { SyntheticEvent } from 'react';
+import type { PlayerEmitter } from './event-emitter.js';
+type UsePlayerMethods = {
+    frameBack: (frames: number) => void;
+    frameForward: (frames: number) => void;
+    isLastFrame: boolean;
+    isFirstFrame: boolean;
+    emitter: PlayerEmitter;
+    playing: boolean;
+    play: (e?: SyntheticEvent) => void;
+    pause: () => void;
+    pauseAndReturnToPlayStart: () => void;
+    seek: (newFrame: number) => void;
+    getCurrentFrame: () => number;
+    isPlaying: () => boolean;
+    hasPlayed: boolean;
+};
+export declare const usePlayer: () => UsePlayerMethods;
+export {};