@remotion/player 4.0.181 → 4.0.182

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-buffer-state-emitter.d.ts

@@ -0,0 +1,2 @@
+import type { PlayerEmitter, ThumbnailEmitter } from './event-emitter.js';
+export declare const useBufferStateEmitter: (emitter: PlayerEmitter | ThumbnailEmitter) => void;

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

@@ -0,0 +1,22 @@
+import { useContext, useEffect } from 'react';
+import { Internals } from 'remotion';
+export const useBufferStateEmitter = (emitter) => {
+    const bufferManager = useContext(Internals.BufferingContextReact);
+    if (!bufferManager) {
+        throw new Error('BufferingContextReact not found');
+    }
+    useEffect(() => {
+        const clear1 = bufferManager.listenForBuffering(() => {
+            bufferManager.buffering.current = true;
+            emitter.dispatchWaiting({});
+        });
+        const clear2 = bufferManager.listenForResume(() => {
+            bufferManager.buffering.current = false;
+            emitter.dispatchResume({});
+        });
+        return () => {
+            clear1.remove();
+            clear2.remove();
+        };
+    }, [bufferManager, emitter]);
+};

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>, hideControlsWhenPointerDoesntMove: boolean | number) => boolean;

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

@@ -0,0 +1,43 @@
+import { useEffect, useState } from 'react';
+export const useHoverState = (ref, hideControlsWhenPointerDoesntMove) => {
+    const [hovered, setHovered] = useState(false);
+    useEffect(() => {
+        const { current } = ref;
+        if (!current) {
+            return;
+        }
+        let hoverTimeout;
+        const addHoverTimeout = () => {
+            if (hideControlsWhenPointerDoesntMove) {
+                clearTimeout(hoverTimeout);
+                hoverTimeout = setTimeout(() => {
+                    setHovered(false);
+                }, hideControlsWhenPointerDoesntMove === true
+                    ? 3000
+                    : hideControlsWhenPointerDoesntMove);
+            }
+        };
+        const onHover = () => {
+            setHovered(true);
+            addHoverTimeout();
+        };
+        const onLeave = () => {
+            setHovered(false);
+            clearTimeout(hoverTimeout);
+        };
+        const onMove = () => {
+            setHovered(true);
+            addHoverTimeout();
+        };
+        current.addEventListener('mouseenter', onHover);
+        current.addEventListener('mouseleave', onLeave);
+        current.addEventListener('mousemove', onMove);
+        return () => {
+            current.removeEventListener('mouseenter', onHover);
+            current.removeEventListener('mouseleave', onLeave);
+            current.removeEventListener('mousemove', onMove);
+            clearTimeout(hoverTimeout);
+        };
+    }, [hideControlsWhenPointerDoesntMove, ref]);
+    return hovered;
+};

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

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

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

@@ -0,0 +1,157 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import { useContext, 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, frameRef, }) => {
+    const config = Internals.useUnsafeVideoConfig();
+    const frame = Internals.Timeline.useTimelinePosition();
+    const { playing, pause, emitter } = usePlayer();
+    const setFrame = Internals.Timeline.useTimelineSetFrame();
+    const buffering = useRef(null);
+    // 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 lastTimeUpdateEvent = useRef(null);
+    const context = useContext(Internals.BufferingContextReact);
+    if (!context) {
+        throw new Error('Missing the buffering context. Most likely you have a Remotion version mismatch.');
+    }
+    useEffect(() => {
+        const onBufferClear = context.listenForBuffering(() => {
+            buffering.current = performance.now();
+        });
+        const onResumeClear = context.listenForResume(() => {
+            buffering.current = null;
+        });
+        return () => {
+            onBufferClear.remove();
+            onResumeClear.remove();
+        };
+    }, [context]);
+    useEffect(() => {
+        if (!config) {
+            return;
+        }
+        if (!playing) {
+            return;
+        }
+        let hasBeenStopped = false;
+        let reqAnimFrameCall = null;
+        let 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 currentFrame = frameRef.current;
+            const { nextFrame, framesToAdvance, hasEnded } = calculateNextFrame({
+                time,
+                currentFrame,
+                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 (buffering.current) {
+                const stopListening = context.listenForResume(() => {
+                    stopListening.remove();
+                    if (hasBeenStopped) {
+                        return;
+                    }
+                    startedTime = performance.now();
+                    framesAdvanced = 0;
+                    callback();
+                });
+                return;
+            }
+            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,
+        frameRef,
+        buffering,
+        context,
+    ]);
+    useEffect(() => {
+        const interval = setInterval(() => {
+            if (lastTimeUpdateEvent.current === frameRef.current) {
+                return;
+            }
+            emitter.dispatchTimeUpdate({ frame: frameRef.current });
+            lastTimeUpdateEvent.current = frameRef.current;
+        }, 250);
+        return () => clearInterval(interval);
+    }, [emitter, frameRef]);
+    useEffect(() => {
+        emitter.dispatchFrameUpdate({ frame });
+    }, [emitter, frame]);
+};

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

@@ -0,0 +1,24 @@
+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;
+    isBuffering: () => boolean;
+    /**
+     * @deprecated Remotion internal API
+     */
+    remotionInternal_currentFrameRef: React.MutableRefObject<number>;
+};
+export declare const usePlayer: () => UsePlayerMethods;
+export {};

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

@@ -0,0 +1,157 @@
+import { useCallback, useContext, useMemo, useRef, useState } from 'react';
+import { Internals } from 'remotion';
+import { PlayerEventEmitterContext } from './emitter-context.js';
+export const usePlayer = () => {
+    var _a;
+    const [playing, setPlaying, imperativePlaying] = Internals.Timeline.usePlayingState();
+    const [hasPlayed, setHasPlayed] = useState(false);
+    const frame = Internals.Timeline.useTimelinePosition();
+    const playStart = useRef(frame);
+    const setFrame = Internals.Timeline.useTimelineSetFrame();
+    const setTimelinePosition = Internals.Timeline.useTimelineSetFrame();
+    const audioContext = useContext(Internals.SharedAudioContext);
+    const { audioAndVideoTags } = useContext(Internals.Timeline.TimelineContext);
+    const frameRef = useRef(frame);
+    frameRef.current = frame;
+    const video = Internals.useVideo();
+    const config = Internals.useUnsafeVideoConfig();
+    const emitter = useContext(PlayerEventEmitterContext);
+    const lastFrame = ((_a = config === null || config === void 0 ? void 0 : config.durationInFrames) !== null && _a !== void 0 ? _a : 1) - 1;
+    const isLastFrame = frame === lastFrame;
+    const isFirstFrame = frame === 0;
+    if (!emitter) {
+        throw new TypeError('Expected Player event emitter context');
+    }
+    const bufferingContext = useContext(Internals.BufferingContextReact);
+    if (!bufferingContext) {
+        throw new Error('Missing the buffering context. Most likely you have a Remotion version mismatch.');
+    }
+    const { buffering } = bufferingContext;
+    const seek = useCallback((newFrame) => {
+        if (video === null || video === void 0 ? void 0 : video.id) {
+            setTimelinePosition((c) => ({ ...c, [video.id]: newFrame }));
+        }
+        frameRef.current = newFrame;
+        emitter.dispatchSeek(newFrame);
+    }, [emitter, setTimelinePosition, video === null || video === void 0 ? void 0 : video.id]);
+    const play = useCallback((e) => {
+        if (imperativePlaying.current) {
+            return;
+        }
+        setHasPlayed(true);
+        if (isLastFrame) {
+            seek(0);
+        }
+        /**
+         * Play silent audio tags to warm them up for autoplay
+         */
+        if (audioContext && audioContext.numberOfAudioTags > 0 && e) {
+            audioContext.playAllAudios();
+        }
+        /**
+         * Play audios and videos directly here so they can benefit from
+         * being triggered by a click
+         */
+        audioAndVideoTags.current.forEach((a) => a.play());
+        imperativePlaying.current = true;
+        setPlaying(true);
+        playStart.current = frameRef.current;
+        emitter.dispatchPlay();
+    }, [
+        imperativePlaying,
+        isLastFrame,
+        audioContext,
+        setPlaying,
+        emitter,
+        seek,
+        audioAndVideoTags,
+    ]);
+    const pause = useCallback(() => {
+        if (imperativePlaying.current) {
+            imperativePlaying.current = false;
+            setPlaying(false);
+            emitter.dispatchPause();
+        }
+    }, [emitter, imperativePlaying, setPlaying]);
+    const pauseAndReturnToPlayStart = useCallback(() => {
+        if (imperativePlaying.current) {
+            imperativePlaying.current = false;
+            frameRef.current = playStart.current;
+            if (config) {
+                setTimelinePosition((c) => ({
+                    ...c,
+                    [config.id]: playStart.current,
+                }));
+                setPlaying(false);
+                emitter.dispatchPause();
+            }
+        }
+    }, [config, emitter, imperativePlaying, setPlaying, setTimelinePosition]);
+    const videoId = video === null || video === void 0 ? void 0 : video.id;
+    const frameBack = useCallback((frames) => {
+        if (!videoId) {
+            return null;
+        }
+        if (imperativePlaying.current) {
+            return;
+        }
+        setFrame((c) => {
+            var _a, _b;
+            const prev = (_b = (_a = c[videoId]) !== null && _a !== void 0 ? _a : window.remotion_initialFrame) !== null && _b !== void 0 ? _b : 0;
+            return {
+                ...c,
+                [videoId]: Math.max(0, prev - frames),
+            };
+        });
+    }, [imperativePlaying, setFrame, videoId]);
+    const frameForward = useCallback((frames) => {
+        if (!videoId) {
+            return null;
+        }
+        if (imperativePlaying.current) {
+            return;
+        }
+        setFrame((c) => {
+            var _a, _b;
+            const prev = (_b = (_a = c[videoId]) !== null && _a !== void 0 ? _a : window.remotion_initialFrame) !== null && _b !== void 0 ? _b : 0;
+            return {
+                ...c,
+                [videoId]: Math.min(lastFrame, prev + frames),
+            };
+        });
+    }, [videoId, imperativePlaying, lastFrame, setFrame]);
+    const returnValue = useMemo(() => {
+        return {
+            frameBack,
+            frameForward,
+            isLastFrame,
+            emitter,
+            playing,
+            play,
+            pause,
+            seek,
+            isFirstFrame,
+            getCurrentFrame: () => frameRef.current,
+            isPlaying: () => imperativePlaying.current,
+            isBuffering: () => buffering.current,
+            pauseAndReturnToPlayStart,
+            hasPlayed,
+            remotionInternal_currentFrameRef: frameRef,
+        };
+    }, [
+        frameBack,
+        frameForward,
+        isLastFrame,
+        emitter,
+        playing,
+        play,
+        pause,
+        seek,
+        isFirstFrame,
+        pauseAndReturnToPlayStart,
+        hasPlayed,
+        imperativePlaying,
+        buffering,
+    ]);
+    return returnValue;
+};

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

@@ -0,0 +1,6 @@
+import type { ThumbnailEmitter } from './event-emitter.js';
+type UseThumbnailMethods = {
+    emitter: ThumbnailEmitter;
+};
+export declare const useThumbnail: () => UseThumbnailMethods;
+export {};

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

@@ -0,0 +1,14 @@
+import { useContext, useMemo } from 'react';
+import { ThumbnailEmitterContext } from './emitter-context.js';
+export const useThumbnail = () => {
+    const emitter = useContext(ThumbnailEmitterContext);
+    if (!emitter) {
+        throw new TypeError('Expected Player event emitter context');
+    }
+    const returnValue = useMemo(() => {
+        return {
+            emitter,
+        };
+    }, [emitter]);
+    return returnValue;
+};

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

@@ -0,0 +1,11 @@
+type Info = {
+    maxTimeLabelWidth: number | null;
+    displayVerticalVolumeSlider: boolean;
+};
+export declare const X_SPACER = 10;
+export declare const X_PADDING = 12;
+export declare const useVideoControlsResize: ({ allowFullscreen: allowFullScreen, playerWidth, }: {
+    allowFullscreen: boolean;
+    playerWidth: number;
+}) => Info;
+export {};