remotion 4.0.0-webhook.27 → 4.1.0-alpha1

package/dist/cjs/video/VideoForRendering.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoForRendering = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const absolute_src_js_1 = require("../absolute-src.js");
+const AssetManager_js_1 = require("../AssetManager.js");
+const use_audio_frame_js_1 = require("../audio/use-audio-frame.js");
+const delay_render_js_1 = require("../delay-render.js");
+const get_environment_js_1 = require("../get-environment.js");
+const is_approximately_the_same_js_1 = require("../is-approximately-the-same.js");
+const random_js_1 = require("../random.js");
+const SequenceContext_js_1 = require("../SequenceContext.js");
+const timeline_position_state_js_1 = require("../timeline-position-state.js");
+const use_current_frame_js_1 = require("../use-current-frame.js");
+const use_unsafe_video_config_js_1 = require("../use-unsafe-video-config.js");
+const volume_prop_js_1 = require("../volume-prop.js");
+const warn_about_non_seekable_media_js_1 = require("../warn-about-non-seekable-media.js");
+const get_current_time_js_1 = require("./get-current-time.js");
+const VideoForRenderingForwardFunction = ({ onError, volume: volumeProp, allowAmplificationDuringRender, playbackRate, onDuration, ...props }, ref) => {
+    const absoluteFrame = (0, timeline_position_state_js_1.useTimelinePosition)();
+    const frame = (0, use_current_frame_js_1.useCurrentFrame)();
+    const volumePropsFrame = (0, use_audio_frame_js_1.useFrameForVolumeProp)();
+    const videoConfig = (0, use_unsafe_video_config_js_1.useUnsafeVideoConfig)();
+    const videoRef = (0, react_1.useRef)(null);
+    const sequenceContext = (0, react_1.useContext)(SequenceContext_js_1.SequenceContext);
+    const mediaStartsAt = (0, use_audio_frame_js_1.useMediaStartsAt)();
+    const environment = (0, get_environment_js_1.useRemotionEnvironment)();
+    const { registerAsset, unregisterAsset } = (0, react_1.useContext)(AssetManager_js_1.AssetManager);
+    // Generate a string that's as unique as possible for this asset
+    // but at the same time the same on all threads
+    const id = (0, react_1.useMemo)(() => {
+        var _a;
+        return `video-${(0, random_js_1.random)((_a = props.src) !== null && _a !== void 0 ? _a : '')}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.cumulatedFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom}-${sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.durationInFrames}`;
+    }, [
+        props.src,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.cumulatedFrom,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom,
+        sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.durationInFrames,
+    ]);
+    if (!videoConfig) {
+        throw new Error('No video config found');
+    }
+    const volume = (0, volume_prop_js_1.evaluateVolume)({
+        volume: volumeProp,
+        frame: volumePropsFrame,
+        mediaVolume: 1,
+        allowAmplificationDuringRender: allowAmplificationDuringRender !== null && allowAmplificationDuringRender !== void 0 ? allowAmplificationDuringRender : false,
+    });
+    (0, react_1.useEffect)(() => {
+        if (!props.src) {
+            throw new Error('No src passed');
+        }
+        if (props.muted) {
+            return;
+        }
+        if (volume <= 0) {
+            return;
+        }
+        if (!window.remotion_audioEnabled) {
+            return;
+        }
+        registerAsset({
+            type: 'video',
+            src: (0, absolute_src_js_1.getAbsoluteSrc)(props.src),
+            id,
+            frame: absoluteFrame,
+            volume,
+            mediaFrame: frame,
+            playbackRate: playbackRate !== null && playbackRate !== void 0 ? playbackRate : 1,
+            allowAmplificationDuringRender: allowAmplificationDuringRender !== null && allowAmplificationDuringRender !== void 0 ? allowAmplificationDuringRender : false,
+        });
+        return () => unregisterAsset(id);
+    }, [
+        props.muted,
+        props.src,
+        registerAsset,
+        id,
+        unregisterAsset,
+        volume,
+        frame,
+        absoluteFrame,
+        playbackRate,
+        allowAmplificationDuringRender,
+    ]);
+    (0, react_1.useImperativeHandle)(ref, () => {
+        return videoRef.current;
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (!window.remotion_videoEnabled) {
+            return;
+        }
+        const { current } = videoRef;
+        if (!current) {
+            return;
+        }
+        const currentTime = (() => {
+            return (0, get_current_time_js_1.getMediaTime)({
+                fps: videoConfig.fps,
+                frame,
+                src: props.src,
+                playbackRate: playbackRate || 1,
+                startFrom: -mediaStartsAt,
+                mediaType: 'video',
+            });
+        })();
+        const handle = (0, delay_render_js_1.delayRender)(`Rendering <Video /> with src="${props.src}"`);
+        if (process.env.NODE_ENV === 'test') {
+            (0, delay_render_js_1.continueRender)(handle);
+            return;
+        }
+        if ((0, is_approximately_the_same_js_1.isApproximatelyTheSame)(current.currentTime, currentTime)) {
+            if (current.readyState >= 2) {
+                (0, delay_render_js_1.continueRender)(handle);
+                return;
+            }
+            const loadedDataHandler = () => {
+                (0, delay_render_js_1.continueRender)(handle);
+            };
+            current.addEventListener('loadeddata', loadedDataHandler, { once: true });
+            return () => {
+                current.removeEventListener('loadeddata', loadedDataHandler);
+            };
+        }
+        current.currentTime = currentTime;
+        const seekedHandler = () => {
+            (0, warn_about_non_seekable_media_js_1.warnAboutNonSeekableMedia)(current, 'exception');
+            if (window.navigator.platform.startsWith('Mac')) {
+                // Improve me: This is ensures frame perfectness but slows down render.
+                // Please see this issue for context: https://github.com/remotion-dev/remotion/issues/200
+                // Only affects macOS since it uses VideoToolbox decoding.
+                setTimeout(() => {
+                    (0, delay_render_js_1.continueRender)(handle);
+                }, 100);
+            }
+            else {
+                (0, delay_render_js_1.continueRender)(handle);
+            }
+        };
+        current.addEventListener('seeked', seekedHandler, { once: true });
+        const endedHandler = () => {
+            (0, delay_render_js_1.continueRender)(handle);
+        };
+        current.addEventListener('ended', endedHandler, { once: true });
+        const errorHandler = () => {
+            var _a;
+            if (current === null || current === void 0 ? void 0 : current.error) {
+                console.error('Error occurred in video', current === null || current === void 0 ? void 0 : current.error);
+                // If user is handling the error, we don't cause an unhandled exception
+                if (onError) {
+                    return;
+                }
+                throw new Error(`The browser threw an error while playing the video ${props.src}: Code ${current.error.code} - ${(_a = current === null || current === void 0 ? void 0 : current.error) === null || _a === void 0 ? void 0 : _a.message}. See https://remotion.dev/docs/media-playback-error for help. Pass an onError() prop to handle the error.`);
+            }
+            else {
+                throw new Error('The browser threw an error');
+            }
+        };
+        current.addEventListener('error', errorHandler, { once: true });
+        // If video skips to another frame or unmounts, we clear the created handle
+        return () => {
+            current.removeEventListener('ended', endedHandler);
+            current.removeEventListener('error', errorHandler);
+            current.removeEventListener('seeked', seekedHandler);
+            (0, delay_render_js_1.continueRender)(handle);
+        };
+    }, [
+        volumePropsFrame,
+        props.src,
+        playbackRate,
+        videoConfig.fps,
+        frame,
+        mediaStartsAt,
+        onError,
+    ]);
+    const { src } = props;
+    // If video source switches, make new handle
+    if (environment === 'rendering') {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        (0, react_1.useLayoutEffect)(() => {
+            if (process.env.NODE_ENV === 'test') {
+                return;
+            }
+            const newHandle = (0, delay_render_js_1.delayRender)('Loading <Video> duration with src=' + src);
+            const { current } = videoRef;
+            const didLoad = () => {
+                if (current === null || current === void 0 ? void 0 : current.duration) {
+                    onDuration(src, current.duration);
+                }
+                (0, delay_render_js_1.continueRender)(newHandle);
+            };
+            if (current === null || current === void 0 ? void 0 : current.duration) {
+                onDuration(src, current.duration);
+                (0, delay_render_js_1.continueRender)(newHandle);
+            }
+            else {
+                current === null || current === void 0 ? void 0 : current.addEventListener('loadedmetadata', didLoad, { once: true });
+            }
+            // If tag gets unmounted, clear pending handles because video metadata is not going to load
+            return () => {
+                current === null || current === void 0 ? void 0 : current.removeEventListener('loadedmetadata', didLoad);
+                (0, delay_render_js_1.continueRender)(newHandle);
+            };
+        }, [src, onDuration]);
+    }
+    return (0, jsx_runtime_1.jsx)("video", { ref: videoRef, ...props, onError: onError });
+};
+exports.VideoForRendering = (0, react_1.forwardRef)(VideoForRenderingForwardFunction);

package/dist/cjs/video/duration-state.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+type DurationState = Record<string, number>;
+type DurationAction = {
+    type: 'got-duration';
+    src: string;
+    durationInSeconds: number;
+};
+export declare const durationReducer: (state: DurationState, action: DurationAction) => DurationState;
+type TDurationsContext = {
+    durations: DurationState;
+    setDurations: React.Dispatch<DurationAction>;
+};
+export declare const DurationsContext: React.Context<TDurationsContext>;
+export declare const DurationsContextProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

package/dist/cjs/video/duration-state.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurationsContextProvider = exports.DurationsContext = exports.durationReducer = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const absolute_src_js_1 = require("../absolute-src.js");
+const durationReducer = (state, action) => {
+    switch (action.type) {
+        case 'got-duration':
+            return {
+                ...state,
+                [(0, absolute_src_js_1.getAbsoluteSrc)(action.src)]: action.durationInSeconds,
+            };
+        default:
+            return state;
+    }
+};
+exports.durationReducer = durationReducer;
+exports.DurationsContext = (0, react_1.createContext)({
+    durations: {},
+    setDurations: () => {
+        throw new Error('context missing');
+    },
+});
+const DurationsContextProvider = ({ children }) => {
+    const [durations, setDurations] = (0, react_1.useReducer)(exports.durationReducer, {});
+    const value = (0, react_1.useMemo)(() => {
+        return {
+            durations,
+            setDurations,
+        };
+    }, [durations]);
+    return ((0, jsx_runtime_1.jsx)(exports.DurationsContext.Provider, { value: value, children: children }));
+};
+exports.DurationsContextProvider = DurationsContextProvider;

package/dist/{video → cjs/video}/get-current-time.js

@@ -2,9 +2,9 @@
 // Calculate the `.currentTime` of a video or audio element
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMediaTime = exports.getExpectedMediaFrameUncorrected = void 0;
-const interpolate_1 = require("../interpolate");
+const interpolate_js_1 = require("../interpolate.js");
 const getExpectedMediaFrameUncorrected = ({ frame, playbackRate, startFrom, }) => {
-    return (0, interpolate_1.interpolate)(frame, [-1, startFrom, startFrom + 1], [-1, startFrom, startFrom + playbackRate]);
+    return (0, interpolate_js_1.interpolate)(frame, [-1, startFrom, startFrom + 1], [-1, startFrom, startFrom + playbackRate]);
 };
 exports.getExpectedMediaFrameUncorrected = getExpectedMediaFrameUncorrected;
 const getMediaTime = ({ fps, frame, src, playbackRate, startFrom, mediaType, }) => {
@@ -13,19 +13,20 @@ const getMediaTime = ({ fps, frame, src, playbackRate, startFrom, mediaType, })
         playbackRate,
         startFrom,
     });
-    if (src.endsWith('webm')) {
-        // For WebM videos, we need to add a little bit of shift to get the right frame.
-        const msPerFrame = 1000 / fps;
-        const msShift = msPerFrame / 2;
-        return (expectedFrame * msPerFrame + msShift) / 1000;
-    }
-    if (mediaType === 'video') {
+    const isChrome = typeof window !== 'undefined' &&
+        window.navigator.userAgent.match(/Chrome\/([0-9]+)/);
+    if (isChrome &&
+        Number(isChrome[1]) < 112 &&
+        mediaType === 'video' &&
+        src.endsWith('.mp4')) {
         // In Chrome, for MP4s, if 30fps, the first frame is still displayed at 0.033333
         // even though after that it increases by 0.033333333 each.
         // So frame = 0 in Remotion is like frame = 1 for the browser
         return (expectedFrame + 1) / fps;
     }
-    // For audio, we don't do any shift correction
-    return expectedFrame / fps;
+    // For WebM videos, we need to add a little bit of shift to get the right frame.
+    const msPerFrame = 1000 / fps;
+    const msShift = msPerFrame / 2;
+    return (expectedFrame * msPerFrame + msShift) / 1000;
 };
 exports.getMediaTime = getMediaTime;

package/dist/cjs/video/index.d.ts

@@ -0,0 +1,3 @@
+export { OffthreadVideo } from './OffthreadVideo.js';
+export { OffthreadVideoProps as RemotionOffthreadVideoProps, RemotionMainVideoProps, RemotionVideoProps, } from './props.js';
+export { Video } from './Video.js';

package/dist/{video → cjs/video}/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Video = exports.OffthreadVideo = void 0;
-var OffthreadVideo_1 = require("./OffthreadVideo");
-Object.defineProperty(exports, "OffthreadVideo", { enumerable: true, get: function () { return OffthreadVideo_1.OffthreadVideo; } });
-var Video_1 = require("./Video");
-Object.defineProperty(exports, "Video", { enumerable: true, get: function () { return Video_1.Video; } });
+var OffthreadVideo_js_1 = require("./OffthreadVideo.js");
+Object.defineProperty(exports, "OffthreadVideo", { enumerable: true, get: function () { return OffthreadVideo_js_1.OffthreadVideo; } });
+var Video_js_1 = require("./Video.js");
+Object.defineProperty(exports, "Video", { enumerable: true, get: function () { return Video_js_1.Video; } });

package/dist/cjs/video/props.d.ts

@@ -0,0 +1,32 @@
+import type React from 'react';
+import type { VolumeProp } from '../volume-prop.js';
+export type RemotionMainVideoProps = {
+    startFrom?: number;
+    endAt?: number;
+};
+export type RemotionVideoProps = Omit<React.DetailedHTMLProps<React.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, 'autoPlay' | 'controls' | 'onEnded' | 'nonce'> & {
+    volume?: VolumeProp;
+    playbackRate?: number;
+    acceptableTimeShiftInSeconds?: number;
+    allowAmplificationDuringRender?: boolean;
+};
+type DeprecatedOffthreadVideoProps = {
+    /**
+     * @deprecated Use the `transparent` prop instead
+     */
+    imageFormat?: never;
+};
+export type OffthreadVideoProps = {
+    src: string;
+    className?: string;
+    id?: string;
+    style?: React.CSSProperties;
+    volume?: VolumeProp;
+    playbackRate?: number;
+    muted?: boolean;
+    onError?: React.ReactEventHandler<HTMLVideoElement | HTMLImageElement>;
+    acceptableTimeShiftInSeconds?: number;
+    allowAmplificationDuringRender?: boolean;
+    transparent?: boolean;
+} & DeprecatedOffthreadVideoProps;
+export {};

package/dist/cjs/video/props.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/video/video-fragment.d.ts

@@ -0,0 +1,12 @@
+export declare const useAppendVideoFragment: ({ actualSrc: initialActualSrc, actualFrom: initialActualFrom, duration: initialDuration, fps, }: {
+    actualSrc: string;
+    actualFrom: number;
+    duration: number;
+    fps: number;
+}) => string;
+export declare const appendVideoFragment: ({ actualSrc, actualFrom, duration, fps, }: {
+    actualSrc: string;
+    actualFrom: number;
+    duration: number;
+    fps: number;
+}) => string;

package/dist/cjs/video/video-fragment.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendVideoFragment = exports.useAppendVideoFragment = void 0;
+const react_1 = require("react");
+const toSeconds = (time, fps) => {
+    return Math.round((time / fps) * 100) / 100;
+};
+const isSubsetOfDuration = (prevStartFrom, newStartFrom, prevDuration, newDuration) => {
+    return (prevStartFrom <= newStartFrom &&
+        prevStartFrom + prevDuration >= newStartFrom + newDuration);
+};
+const useAppendVideoFragment = ({ actualSrc: initialActualSrc, actualFrom: initialActualFrom, duration: initialDuration, fps, }) => {
+    const actualFromRef = (0, react_1.useRef)(initialActualFrom);
+    const actualDuration = (0, react_1.useRef)(initialDuration);
+    const actualSrc = (0, react_1.useRef)(initialActualSrc);
+    if (!isSubsetOfDuration || initialActualSrc !== actualSrc.current) {
+        actualFromRef.current = initialActualFrom;
+        actualDuration.current = initialDuration;
+        actualSrc.current = initialActualSrc;
+    }
+    const appended = (0, exports.appendVideoFragment)({
+        actualSrc: actualSrc.current,
+        actualFrom: actualFromRef.current,
+        duration: actualDuration.current,
+        fps,
+    });
+    return appended;
+};
+exports.useAppendVideoFragment = useAppendVideoFragment;
+// https://github.com/remotion-dev/remotion/issues/1655
+const isIOSSafariCase = (actualSrc) => {
+    return typeof window === 'undefined'
+        ? false
+        : /iP(ad|od|hone)/i.test(window.navigator.userAgent) &&
+            Boolean(navigator.userAgent.match(/Version\/[\d.]+.*Safari/)) &&
+            actualSrc.startsWith('blob:');
+};
+const appendVideoFragment = ({ actualSrc, actualFrom, duration, fps, }) => {
+    var _a;
+    if (isIOSSafariCase(actualSrc)) {
+        return actualSrc;
+    }
+    if (actualSrc.startsWith('data:')) {
+        return actualSrc;
+    }
+    const existingHash = Boolean(new URL(actualSrc, (_a = (typeof window === 'undefined' ? null : window.location.href)) !== null && _a !== void 0 ? _a : 'http://localhost:3000').hash);
+    if (existingHash) {
+        return actualSrc;
+    }
+    if (!Number.isFinite(actualFrom)) {
+        return actualSrc;
+    }
+    actualSrc += `#t=${toSeconds(-actualFrom, fps)}`;
+    if (!Number.isFinite(duration)) {
+        return actualSrc;
+    }
+    actualSrc += `,${toSeconds(duration, fps)}`;
+    return actualSrc;
+};
+exports.appendVideoFragment = appendVideoFragment;

package/dist/{video-config.d.ts → cjs/video-config.d.ts}

@@ -1,8 +1,8 @@
-export declare type VideoConfig = {
+export type VideoConfig = {
     width: number;
     height: number;
     fps: number;
     durationInFrames: number;
     id: string;
-    defaultProps: unknown;
+    defaultProps: Record<string, unknown> | undefined;
 };

package/dist/{volume-position-state.d.ts → cjs/volume-position-state.d.ts}

@@ -1,17 +1,17 @@
 /// <reference types="react" />
-export declare type MediaVolumeContextValue = {
+export type MediaVolumeContextValue = {
     mediaMuted: boolean;
     mediaVolume: number;
 };
-export declare type SetMediaVolumeContextValue = {
+export type SetMediaVolumeContextValue = {
     setMediaMuted: (u: React.SetStateAction<boolean>) => void;
     setMediaVolume: (u: number) => void;
 };
 export declare const MediaVolumeContext: import("react").Context<MediaVolumeContextValue>;
 export declare const SetMediaVolumeContext: import("react").Context<SetMediaVolumeContextValue>;
-declare type MediaVolumeReturnType = readonly [number, (u: number) => void];
+type MediaVolumeReturnType = readonly [number, (u: number) => void];
 export declare const useMediaVolumeState: () => MediaVolumeReturnType;
-declare type MediaMutedReturnType = readonly [
+type MediaMutedReturnType = readonly [
     boolean,
     (u: React.SetStateAction<boolean>) => void
 ];

package/dist/{volume-prop.d.ts → cjs/volume-prop.d.ts}

@@ -1,6 +1,7 @@
-export declare type VolumeProp = number | ((frame: number) => number);
-export declare const evaluateVolume: ({ frame, volume, mediaVolume, }: {
+export type VolumeProp = number | ((frame: number) => number);
+export declare const evaluateVolume: ({ frame, volume, mediaVolume, allowAmplificationDuringRender, }: {
     frame: number;
     volume: VolumeProp | undefined;
     mediaVolume: number;
+    allowAmplificationDuringRender: boolean;
 }) => number;

package/dist/{volume-prop.js → cjs/volume-prop.js}

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateVolume = void 0;
-const evaluateVolume = ({ frame, volume, mediaVolume = 1, }) => {
+const evaluateVolume = ({ frame, volume, mediaVolume = 1, allowAmplificationDuringRender, }) => {
+    const maxVolume = allowAmplificationDuringRender ? Infinity : 1;
     if (typeof volume === 'number') {
-        return Math.min(1, volume * mediaVolume);
+        return Math.min(maxVolume, volume * mediaVolume);
     }
     if (typeof volume === 'undefined') {
         return Number(mediaVolume);
@@ -18,6 +19,6 @@ const evaluateVolume = ({ frame, volume, mediaVolume = 1, }) => {
     if (!Number.isFinite(evaluated)) {
         throw new TypeError(`You passed in a function to the volume prop but it returned a non-finite number for frame ${frame}.`);
     }
-    return Math.max(0, Math.min(1, evaluated));
+    return Math.max(0, Math.min(maxVolume, evaluated));
 };
 exports.evaluateVolume = evaluateVolume;

package/dist/{warn-about-non-seekable-media.js → cjs/warn-about-non-seekable-media.js}

@@ -18,12 +18,12 @@ const warnAboutNonSeekableMedia = (ref, type) => {
     }
     const range = { start: ref.seekable.start(0), end: ref.seekable.end(0) };
     if (range.start === 0 && range.end === 0) {
-        const msg = `The media does not support seeking. Remotion cannot properly render it. Please see https://remotion.dev/docs/non-seekable-media for assistance. Source: ${ref.src}`;
+        const msg = `The media ${ref.src} cannot be seeked. This could be one of two reasons: 1) The media resource was replaced while the video is playing but it was not loaded yet. 2) The media does not support seeking. Please see https://remotion.dev/docs/non-seekable-media for assistance.`;
         if (type === 'console-error') {
             console.error(msg);
         }
         else if (type === 'console-warning') {
-            console.warn(`The media ${ref.src} does not support seeking. The video will render fine, but may not play correctly in preview and in the <Player>. See https://remotion.dev/docs/non-seekable-media for an explanation.`);
+            console.warn(`The media ${ref.src} does not support seeking. The video will render fine, but may not play correctly in the Remotion Studio and in the <Player>. See https://remotion.dev/docs/non-seekable-media for an explanation.`);
         }
         else {
             throw new Error(msg);

package/dist/cjs/wrap-remotion-context.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+export declare function useRemotionContexts(): {
+    compositionManagerCtx: import("./CompositionManagerContext.js").CompositionManagerContext;
+    timelineContext: import("./timeline-position-state.js").TimelineContextValue;
+    setTimelineContext: import("./timeline-position-state.js").SetTimelineContextValue;
+    sequenceContext: import("./SequenceContext.js").SequenceContextType | null;
+    nonceContext: import("./nonce.js").TNonceContext;
+    canUseRemotionHooksContext: boolean;
+    nativeLayersContext: import("./NativeLayers.js").TNativeLayersContext;
+    preloadContext: {
+        [x: string]: string;
+    };
+    resolveCompositionContext: {
+        [x: string]: ({
+            type: "loading";
+        } | {
+            type: "success";
+            result: import("./video-config.js").VideoConfig;
+        } | {
+            type: "error";
+            error: Error;
+        }) | undefined;
+    } | null;
+    assetManagerContext: import("./AssetManager.js").AssetManagerContext;
+    sequenceManagerContext: import("./SequenceManager.js").SequenceManagerContext;
+};
+export interface RemotionContextProviderProps {
+    contexts: ReturnType<typeof useRemotionContexts>;
+    children: React.ReactNode;
+}
+export declare const RemotionContextProvider: (props: RemotionContextProviderProps) => JSX.Element;

package/dist/cjs/wrap-remotion-context.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemotionContextProvider = exports.useRemotionContexts = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+// This is used for when other reconcilers are being used
+// such as in React Three Fiber. All the contexts need to be passed again
+// for them to be useable
+const react_1 = __importStar(require("react"));
+const AssetManager_js_1 = require("./AssetManager.js");
+const CanUseRemotionHooks_js_1 = require("./CanUseRemotionHooks.js");
+const CompositionManagerContext_js_1 = require("./CompositionManagerContext.js");
+const NativeLayers_js_1 = require("./NativeLayers.js");
+const nonce_js_1 = require("./nonce.js");
+const prefetch_state_js_1 = require("./prefetch-state.js");
+const ResolveCompositionConfig_js_1 = require("./ResolveCompositionConfig.js");
+const SequenceContext_js_1 = require("./SequenceContext.js");
+const SequenceManager_js_1 = require("./SequenceManager.js");
+const timeline_position_state_js_1 = require("./timeline-position-state.js");
+function useRemotionContexts() {
+    const compositionManagerCtx = react_1.default.useContext(CompositionManagerContext_js_1.CompositionManager);
+    const timelineContext = react_1.default.useContext(timeline_position_state_js_1.TimelineContext);
+    const setTimelineContext = react_1.default.useContext(timeline_position_state_js_1.SetTimelineContext);
+    const sequenceContext = react_1.default.useContext(SequenceContext_js_1.SequenceContext);
+    const nonceContext = react_1.default.useContext(nonce_js_1.NonceContext);
+    const canUseRemotionHooksContext = react_1.default.useContext(CanUseRemotionHooks_js_1.CanUseRemotionHooks);
+    const nativeLayersContext = react_1.default.useContext(NativeLayers_js_1.NativeLayersContext);
+    const preloadContext = react_1.default.useContext(prefetch_state_js_1.PreloadContext);
+    const resolveCompositionContext = react_1.default.useContext(ResolveCompositionConfig_js_1.ResolveCompositionContext);
+    const assetManagerContext = react_1.default.useContext(AssetManager_js_1.AssetManager);
+    const sequenceManagerContext = react_1.default.useContext(SequenceManager_js_1.SequenceManager);
+    return (0, react_1.useMemo)(() => ({
+        compositionManagerCtx,
+        timelineContext,
+        setTimelineContext,
+        sequenceContext,
+        nonceContext,
+        canUseRemotionHooksContext,
+        nativeLayersContext,
+        preloadContext,
+        resolveCompositionContext,
+        assetManagerContext,
+        sequenceManagerContext,
+    }), [
+        compositionManagerCtx,
+        nonceContext,
+        sequenceContext,
+        setTimelineContext,
+        timelineContext,
+        canUseRemotionHooksContext,
+        nativeLayersContext,
+        preloadContext,
+        resolveCompositionContext,
+        assetManagerContext,
+        sequenceManagerContext,
+    ]);
+}
+exports.useRemotionContexts = useRemotionContexts;
+const RemotionContextProvider = (props) => {
+    const { children, contexts } = props;
+    return ((0, jsx_runtime_1.jsx)(CanUseRemotionHooks_js_1.CanUseRemotionHooks.Provider, { value: contexts.canUseRemotionHooksContext, children: (0, jsx_runtime_1.jsx)(nonce_js_1.NonceContext.Provider, { value: contexts.nonceContext, children: (0, jsx_runtime_1.jsx)(NativeLayers_js_1.NativeLayersContext.Provider, { value: contexts.nativeLayersContext, children: (0, jsx_runtime_1.jsx)(prefetch_state_js_1.PreloadContext.Provider, { value: contexts.preloadContext, children: (0, jsx_runtime_1.jsx)(CompositionManagerContext_js_1.CompositionManager.Provider, { value: contexts.compositionManagerCtx, children: (0, jsx_runtime_1.jsx)(SequenceManager_js_1.SequenceManager.Provider, { value: contexts.sequenceManagerContext, children: (0, jsx_runtime_1.jsx)(AssetManager_js_1.AssetManager.Provider, { value: contexts.assetManagerContext, children: (0, jsx_runtime_1.jsx)(ResolveCompositionConfig_js_1.ResolveCompositionContext.Provider, { value: contexts.resolveCompositionContext, children: (0, jsx_runtime_1.jsx)(timeline_position_state_js_1.TimelineContext.Provider, { value: contexts.timelineContext, children: (0, jsx_runtime_1.jsx)(timeline_position_state_js_1.SetTimelineContext.Provider, { value: contexts.setTimelineContext, children: (0, jsx_runtime_1.jsx)(SequenceContext_js_1.SequenceContext.Provider, { value: contexts.sequenceContext, children: children }) }) }) }) }) }) }) }) }) }) }));
+};
+exports.RemotionContextProvider = RemotionContextProvider;