@remotion/player 4.0.182 → 4.0.184

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

@@ -1,54 +0,0 @@
-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

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

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

@@ -1,129 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,157 +0,0 @@
-/* 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

@@ -1,24 +0,0 @@
-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

@@ -1,157 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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 {};