remotion 4.0.0-lambda.1 → 4.0.0-newpathfunctions.13

package/dist/internals.js

@@ -24,49 +24,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Internals = void 0;
+const config_1 = require("./config");
 const shared_audio_tags_1 = require("./audio/shared-audio-tags");
+const CanUseRemotionHooks_1 = require("./CanUseRemotionHooks");
 const CompositionManager_1 = require("./CompositionManager");
-const AssetCompression = __importStar(require("./compress-assets"));
-const browser_1 = require("./config/browser");
-const browser_executable_1 = require("./config/browser-executable");
-const chromium_flags_1 = require("./config/chromium-flags");
-const codec_1 = require("./config/codec");
-const concurrency_1 = require("./config/concurrency");
-const crf_1 = require("./config/crf");
-const env_file_1 = require("./config/env-file");
-const ffmpeg_executable_1 = require("./config/ffmpeg-executable");
-const frame_range_1 = require("./config/frame-range");
-const image_format_1 = require("./config/image-format");
-const image_sequence_1 = require("./config/image-sequence");
-const Logging = __importStar(require("./config/log"));
-const max_timeline_tracks_1 = require("./config/max-timeline-tracks");
-const override_webpack_1 = require("./config/override-webpack");
-const overwrite_1 = require("./config/overwrite");
-const pixel_format_1 = require("./config/pixel-format");
-const preview_server_1 = require("./config/preview-server");
-const prores_profile_1 = require("./config/prores-profile");
-const quality_1 = require("./config/quality");
-const scale_1 = require("./config/scale");
-const still_frame_1 = require("./config/still-frame");
-const timeout_1 = require("./config/timeout");
-const webpack_caching_1 = require("./config/webpack-caching");
 const CSSUtils = __importStar(require("./default-css"));
 const delay_render_1 = require("./delay-render");
-const feature_flags_1 = require("./feature-flags");
 const get_environment_1 = require("./get-environment");
 const get_preview_dom_element_1 = require("./get-preview-dom-element");
-const is_audio_codec_1 = require("./is-audio-codec");
-const perf = __importStar(require("./perf"));
+const is_player_1 = require("./is-player");
 const portal_node_1 = require("./portal-node");
+const prefetch_state_1 = require("./prefetch-state");
 const register_root_1 = require("./register-root");
 const RemotionRoot_1 = require("./RemotionRoot");
 const Sequence_1 = require("./Sequence");
 const setup_env_variables_1 = require("./setup-env-variables");
-const TimelineInOutPosition = __importStar(require("./timeline-inout-position-state"));
 const TimelinePosition = __importStar(require("./timeline-position-state"));
-const timeout_2 = require("./timeout");
 const truthy_1 = require("./truthy");
-const use_current_frame_1 = require("./use-current-frame");
 const use_lazy_component_1 = require("./use-lazy-component");
 const use_unsafe_video_config_1 = require("./use-unsafe-video-config");
 const use_video_1 = require("./use-video");
@@ -74,101 +48,52 @@ const validate_composition_id_1 = require("./validation/validate-composition-id"
 const validate_dimensions_1 = require("./validation/validate-dimensions");
 const validate_duration_in_frames_1 = require("./validation/validate-duration-in-frames");
 const validate_fps_1 = require("./validation/validate-fps");
-const validate_frame_1 = require("./validation/validate-frame");
-const validate_image_format_1 = require("./validation/validate-image-format");
-const validate_opengl_renderer_1 = require("./validation/validate-opengl-renderer");
-const validate_quality_1 = require("./validation/validate-quality");
+const validate_offthreadvideo_image_format_1 = require("./validation/validate-offthreadvideo-image-format");
+const duration_state_1 = require("./video/duration-state");
 const volume_position_state_1 = require("./volume-position-state");
 const wrap_remotion_context_1 = require("./wrap-remotion-context");
-const Timeline = { ...TimelinePosition, ...TimelineInOutPosition };
+const Timeline = TimelinePosition;
 // Mark them as Internals so use don't assume this is public
 // API and are less likely to use it
 exports.Internals = {
-    perf,
     useUnsafeVideoConfig: use_unsafe_video_config_1.useUnsafeVideoConfig,
     Timeline,
     CompositionManager: CompositionManager_1.CompositionManager,
     RemotionRoot: RemotionRoot_1.RemotionRoot,
     useVideo: use_video_1.useVideo,
     getRoot: register_root_1.getRoot,
-    getBrowserExecutable: browser_executable_1.getBrowserExecutable,
-    getCustomFfmpegExecutable: ffmpeg_executable_1.getCustomFfmpegExecutable,
-    getCustomFfprobeExecutable: ffmpeg_executable_1.getCustomFfprobeExecutable,
-    getPixelFormat: pixel_format_1.getPixelFormat,
-    getConcurrency: concurrency_1.getConcurrency,
-    getRange: frame_range_1.getRange,
-    getShouldOverwrite: overwrite_1.getShouldOverwrite,
-    getOutputCodecOrUndefined: codec_1.getOutputCodecOrUndefined,
-    getWebpackOverrideFn: override_webpack_1.getWebpackOverrideFn,
-    getQuality: quality_1.getQuality,
-    getScale: scale_1.getScale,
-    getShouldOutputImageSequence: image_sequence_1.getShouldOutputImageSequence,
-    validateSelectedCrfAndCodecCombination: crf_1.validateSelectedCrfAndCodecCombination,
-    getFinalOutputCodec: codec_1.getFinalOutputCodec,
     useMediaVolumeState: volume_position_state_1.useMediaVolumeState,
     useMediaMutedState: volume_position_state_1.useMediaMutedState,
-    DEFAULT_CODEC: codec_1.DEFAULT_CODEC,
-    DEFAULT_PIXEL_FORMAT: pixel_format_1.DEFAULT_PIXEL_FORMAT,
-    FEATURE_FLAG_FIREFOX_SUPPORT: feature_flags_1.FEATURE_FLAG_FIREFOX_SUPPORT,
-    DEFAULT_WEBPACK_CACHE_ENABLED: webpack_caching_1.DEFAULT_WEBPACK_CACHE_ENABLED,
-    getBrowser: browser_1.getBrowser,
-    DEFAULT_BROWSER: browser_1.DEFAULT_BROWSER,
-    getDefaultCrfForCodec: crf_1.getDefaultCrfForCodec,
-    getActualCrf: crf_1.getActualCrf,
-    setFrameRangeFromCli: frame_range_1.setFrameRangeFromCli,
-    getUserPreferredImageFormat: image_format_1.getUserPreferredImageFormat,
-    validateSelectedPixelFormatAndImageFormatCombination: image_format_1.validateSelectedPixelFormatAndImageFormatCombination,
-    validateSelectedPixelFormatAndCodecCombination: pixel_format_1.validateSelectedPixelFormatAndCodecCombination,
-    validateFrameRange: frame_range_1.validateFrameRange,
-    validateNonNullImageFormat: validate_image_format_1.validateNonNullImageFormat,
-    getWebpackCaching: webpack_caching_1.getWebpackCaching,
     useLazyComponent: use_lazy_component_1.useLazyComponent,
     truthy: truthy_1.truthy,
-    isAudioCodec: is_audio_codec_1.isAudioCodec,
-    Logging,
     SequenceContext: Sequence_1.SequenceContext,
     useRemotionContexts: wrap_remotion_context_1.useRemotionContexts,
     RemotionContextProvider: wrap_remotion_context_1.RemotionContextProvider,
     CSSUtils,
     setupEnvVariables: setup_env_variables_1.setupEnvVariables,
     ENV_VARIABLES_ENV_NAME: setup_env_variables_1.ENV_VARIABLES_ENV_NAME,
-    getDotEnvLocation: env_file_1.getDotEnvLocation,
-    getServerPort: preview_server_1.getServerPort,
     MediaVolumeContext: volume_position_state_1.MediaVolumeContext,
     SetMediaVolumeContext: volume_position_state_1.SetMediaVolumeContext,
     validateDurationInFrames: validate_duration_in_frames_1.validateDurationInFrames,
     validateFps: validate_fps_1.validateFps,
     validateDimension: validate_dimensions_1.validateDimension,
     getRemotionEnvironment: get_environment_1.getRemotionEnvironment,
-    getProResProfile: prores_profile_1.getProResProfile,
-    setProResProfile: prores_profile_1.setProResProfile,
-    validateSelectedCodecAndProResCombination: prores_profile_1.validateSelectedCodecAndProResCombination,
-    getMaxTimelineTracks: max_timeline_tracks_1.getMaxTimelineTracks,
     SharedAudioContext: shared_audio_tags_1.SharedAudioContext,
     SharedAudioContextProvider: shared_audio_tags_1.SharedAudioContextProvider,
-    validateQuality: validate_quality_1.validateQuality,
-    validateFrame: validate_frame_1.validateFrame,
-    setStillFrame: still_frame_1.setStillFrame,
-    getStillFrame: still_frame_1.getStillFrame,
     invalidCompositionErrorMessage: validate_composition_id_1.invalidCompositionErrorMessage,
     isCompositionIdValid: validate_composition_id_1.isCompositionIdValid,
-    DEFAULT_OVERWRITE: overwrite_1.DEFAULT_OVERWRITE,
-    AssetCompression,
-    defaultOverrideFunction: override_webpack_1.defaultOverrideFunction,
-    DEFAULT_PUPPETEER_TIMEOUT: timeout_2.DEFAULT_PUPPETEER_TIMEOUT,
-    setupPuppeteerTimeout: timeout_2.setupPuppeteerTimeout,
-    setPuppeteerTimeout: timeout_1.setPuppeteerTimeout,
-    getCurrentPuppeteerTimeout: timeout_1.getCurrentPuppeteerTimeout,
-    getChromiumDisableWebSecurity: chromium_flags_1.getChromiumDisableWebSecurity,
-    getIgnoreCertificateErrors: chromium_flags_1.getIgnoreCertificateErrors,
-    validateOpenGlRenderer: validate_opengl_renderer_1.validateOpenGlRenderer,
-    getChromiumOpenGlRenderer: chromium_flags_1.getChromiumOpenGlRenderer,
-    getChromiumHeadlessMode: chromium_flags_1.getChromiumHeadlessMode,
-    DEFAULT_OPENGL_RENDERER: chromium_flags_1.DEFAULT_OPENGL_RENDERER,
     getPreviewDomElement: get_preview_dom_element_1.getPreviewDomElement,
     compositionsRef: CompositionManager_1.compositionsRef,
     DELAY_RENDER_CALLSTACK_TOKEN: delay_render_1.DELAY_RENDER_CALLSTACK_TOKEN,
-    useAbsoluteCurrentFrame: use_current_frame_1.useAbsoluteCurrentFrame,
     portalNode: portal_node_1.portalNode,
     waitForRoot: register_root_1.waitForRoot,
+    validateOffthreadVideoImageFormat: validate_offthreadvideo_image_format_1.validateOffthreadVideoImageFormat,
+    CanUseRemotionHooksProvider: CanUseRemotionHooks_1.CanUseRemotionHooksProvider,
+    CanUseRemotionHooks: CanUseRemotionHooks_1.CanUseRemotionHooks,
+    enableLegacyRemotionConfig: config_1.enableLegacyRemotionConfig,
+    PrefetchProvider: prefetch_state_1.PrefetchProvider,
+    DurationsContextProvider: duration_state_1.DurationsContextProvider,
+    IsPlayerContextProvider: is_player_1.IsPlayerContextProvider,
+    useIsPlayer: is_player_1.useIsPlayer,
+    useRemotionEnvironment: get_environment_1.useRemotionEnvironment,
 };

package/dist/is-player.d.ts

@@ -0,0 +1,3 @@
+import type { PropsWithChildren } from 'react';
+export declare const IsPlayerContextProvider: React.FC<PropsWithChildren>;
+export declare const useIsPlayer: () => boolean;

package/dist/is-player.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsPlayer = exports.IsPlayerContextProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const IsPlayerContext = (0, react_1.createContext)(false);
+const IsPlayerContextProvider = ({ children, }) => {
+    return (0, jsx_runtime_1.jsx)(IsPlayerContext.Provider, { value: true, children: children });
+};
+exports.IsPlayerContextProvider = IsPlayerContextProvider;
+const useIsPlayer = () => {
+    return (0, react_1.useContext)(IsPlayerContext);
+};
+exports.useIsPlayer = useIsPlayer;

package/dist/layers.d.ts

@@ -0,0 +1,24 @@
+import type { ComponentType, LazyExoticComponent } from 'react';
+import React from 'react';
+export declare type LooseComponentType<T> = ComponentType<T> | ((props: T) => React.ReactNode);
+export declare type InputLayer<T> = {
+    component: LooseComponentType<T>;
+    type: 'web' | 'svg' | 'video';
+};
+export declare type CompProps<T> = {
+    lazyComponent: () => Promise<{
+        default: LooseComponentType<T>;
+    }>;
+} | {
+    component: LooseComponentType<T>;
+} | {
+    layers: InputLayer<T>[];
+};
+export declare type Layer<T> = {
+    component: LazyExoticComponent<ComponentType<T>>;
+    type: 'web' | 'svg' | 'video';
+};
+export declare type SmallLayer = Pick<Layer<unknown>, 'type'>;
+export declare const convertComponentTypesToLayers: <T>(compProps: CompProps<T>) => Layer<T>[];
+export declare const convertComponentTypesToLayersWithCache: <T>(compProps: CompProps<T>, prevCompProps: CompProps<T> | null, prevReturnValue: Layer<T>[] | null) => Layer<T>[];
+export declare const useLayers: <T>(compProps: CompProps<T>) => Layer<T>[];

package/dist/layers.js

@@ -0,0 +1,149 @@
+"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.useLayers = exports.convertComponentTypesToLayersWithCache = exports.convertComponentTypesToLayers = void 0;
+const react_1 = __importStar(require("react"));
+const inputLayersToLayers = (layers) => {
+    return layers.map((layer) => {
+        if (layer.type === 'web') {
+            return {
+                component: react_1.default.lazy(() => Promise.resolve({ default: layer.component })),
+                type: 'web',
+            };
+        }
+        // No lazy for Video allowed!
+        if (layer.type === 'video') {
+            return {
+                component: layer.component,
+                type: 'video',
+            };
+        }
+        // No lazy for SVG allowed!
+        return {
+            component: layer.component,
+            type: 'svg',
+        };
+    });
+};
+const convertComponentTypesToLayers = (compProps) => {
+    if ('component' in compProps) {
+        // In SSR, suspense is not yet supported, we cannot use React.lazy
+        if (typeof document === 'undefined') {
+            return [
+                {
+                    component: compProps.component,
+                    type: 'web',
+                },
+            ];
+        }
+        return [
+            {
+                component: react_1.default.lazy(() => Promise.resolve({ default: compProps.component })),
+                type: 'web',
+            },
+        ];
+    }
+    if ('lazyComponent' in compProps) {
+        return [
+            {
+                component: react_1.default.lazy(compProps.lazyComponent),
+                type: 'web',
+            },
+        ];
+    }
+    if ('layers' in compProps) {
+        return inputLayersToLayers(compProps.layers);
+    }
+    throw new Error('Unknown component type');
+};
+exports.convertComponentTypesToLayers = convertComponentTypesToLayers;
+const convertComponentTypesToLayersWithCache = (compProps, prevCompProps, prevReturnValue) => {
+    if ('component' in compProps) {
+        if (prevCompProps &&
+            'component' in prevCompProps &&
+            compProps.component === prevCompProps.component &&
+            prevReturnValue) {
+            return prevReturnValue;
+        }
+        return [
+            {
+                type: 'web',
+                component: react_1.default.lazy(() => Promise.resolve({ default: compProps.component })),
+            },
+        ];
+    }
+    if ('lazyComponent' in compProps) {
+        if (prevCompProps &&
+            'lazyComponent' in prevCompProps &&
+            compProps.lazyComponent === prevCompProps.lazyComponent &&
+            prevReturnValue) {
+            return prevReturnValue;
+        }
+        return [
+            {
+                type: 'web',
+                component: react_1.default.lazy(compProps.lazyComponent),
+            },
+        ];
+    }
+    if ('layers' in compProps) {
+        const isTheSame = () => {
+            if (!prevCompProps) {
+                return false;
+            }
+            if (!('layers' in prevCompProps)) {
+                return false;
+            }
+            if (compProps.layers.length !== prevCompProps.layers.length) {
+                return false;
+            }
+            for (let i = 0; i < compProps.layers.length; i++) {
+                if (compProps.layers[i].component !== prevCompProps.layers[i].component) {
+                    return false;
+                }
+                if (compProps.layers[i].type !== prevCompProps.layers[i].type) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        if (isTheSame()) {
+            return prevReturnValue;
+        }
+        return inputLayersToLayers(compProps.layers);
+    }
+    throw new Error('Unknown component type');
+};
+exports.convertComponentTypesToLayersWithCache = convertComponentTypesToLayersWithCache;
+const useLayers = (compProps) => {
+    var _a, _b;
+    const prevCompProps = (0, react_1.useRef)();
+    const prevLayers = (0, react_1.useRef)();
+    const layers = (0, exports.convertComponentTypesToLayersWithCache)(compProps, (_a = prevCompProps.current) !== null && _a !== void 0 ? _a : null, (_b = prevLayers.current) !== null && _b !== void 0 ? _b : null);
+    prevCompProps.current = compProps;
+    prevLayers.current = layers;
+    return layers;
+};
+exports.useLayers = useLayers;

package/dist/loop/index.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
+import type { LayoutAndStyle } from '../Sequence';
 export declare type LoopProps = {
     durationInFrames: number;
     times?: number;
-    layout?: 'absolute-fill' | 'none';
     name?: string;
     children: React.ReactNode;
-};
+} & LayoutAndStyle;
 export declare const Loop: React.FC<LoopProps>;

package/dist/loop/index.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Loop = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
-const __1 = require("..");
+const Sequence_1 = require("../Sequence");
+const use_video_config_1 = require("../use-video-config");
 const validate_duration_in_frames_1 = require("../validation/validate-duration-in-frames");
-const Loop = ({ durationInFrames, times = Infinity, children, layout, name, }) => {
-    const { durationInFrames: compDuration } = (0, __1.useVideoConfig)();
+const Loop = ({ durationInFrames, times = Infinity, children, name, ...props }) => {
+    const { durationInFrames: compDuration } = (0, use_video_config_1.useVideoConfig)();
     (0, validate_duration_in_frames_1.validateDurationInFrames)(durationInFrames, 'of the <Loop /> component');
     if (typeof times !== 'number') {
         throw new TypeError(`You passed to "times" an argument of type ${typeof times}, but it must be a number.`);
@@ -18,10 +19,11 @@ const Loop = ({ durationInFrames, times = Infinity, children, layout, name, }) =
     }
     const maxTimes = Math.ceil(compDuration / durationInFrames);
     const actualTimes = Math.min(maxTimes, times);
+    const style = props.layout === 'none' ? undefined : props.style;
     return ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: new Array(actualTimes).fill(true).map((_, i) => {
-            return ((0, jsx_runtime_1.jsx)(__1.Sequence
+            return ((0, jsx_runtime_1.jsx)(Sequence_1.Sequence
             // eslint-disable-next-line react/no-array-index-key
-            , { durationInFrames: durationInFrames, from: i * durationInFrames, layout: layout, name: name, showLoopTimesInTimeline: actualTimes, showInTimeline: i === 0, children: children }, `loop-${i}`));
+            , { durationInFrames: durationInFrames, from: i * durationInFrames, name: name, showLoopTimesInTimeline: actualTimes, showInTimeline: i === 0, layout: props.layout, style: style, children: children }, `loop-${i}`));
         }) }));
 };
 exports.Loop = Loop;

package/dist/multiple-versions-warning.js

@@ -1,13 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkMultipleRemotionVersions = void 0;
+const truthy_1 = require("./truthy");
+const version_1 = require("./version");
 const checkMultipleRemotionVersions = () => {
-    if (typeof window === 'undefined') {
+    if (typeof globalThis === 'undefined') {
         return;
     }
-    if (window.remotion_imported) {
-        console.error('🚨 Multiple versions of Remotion detected. Multiple versions will cause conflicting React contexts and things may break in an unexpected way. Please check your dependency tree and make sure only one version of Remotion is on the page.');
+    const alreadyImported = globalThis.remotion_imported ||
+        (typeof window !== 'undefined' && window.remotion_imported);
+    if (alreadyImported) {
+        if (typeof window === 'undefined' && alreadyImported === version_1.VERSION) {
+            // Next.JS will reload the package and cause a server-side warning.
+            // It's okay if this happens during SSR in developement
+            return;
+        }
+        throw new TypeError(`🚨 Multiple versions of Remotion detected: ${[
+            version_1.VERSION,
+            typeof alreadyImported === 'string'
+                ? alreadyImported
+                : 'an older version',
+        ]
+            .filter(truthy_1.truthy)
+            .join(' and ')}. This will cause things to break in an unexpected way.\nCheck that all your Remotion packages are on the same version. If your dependencies depend on Remotion, make them peer dependencies. You can also run \`npx remotion versions\` from your terminal to see which versions are mismatching.`);
+    }
+    globalThis.remotion_imported = version_1.VERSION;
+    if (typeof window !== 'undefined') {
+        window.remotion_imported = version_1.VERSION;
     }
-    window.remotion_imported = true;
 };
 exports.checkMultipleRemotionVersions = checkMultipleRemotionVersions;

package/dist/play-and-handle-not-allowed-error.d.ts

@@ -1,2 +1,2 @@
-import { RefObject } from 'react';
+import type { RefObject } from 'react';
 export declare const playAndHandleNotAllowedError: (mediaRef: RefObject<HTMLVideoElement | HTMLAudioElement>, mediaType: 'audio' | 'video') => void;

package/dist/play-and-handle-not-allowed-error.js

@@ -28,6 +28,10 @@ const playAndHandleNotAllowedError = (mediaRef, mediaType) => {
             if (err.message.includes('request was interrupted by a new load request')) {
                 return;
             }
+            // Audio tag got unmounted
+            if (err.message.includes('because the media was removed from the document')) {
+                return;
+            }
             console.log(`Could not play ${mediaType} due to following error: `, err);
             if (!current.muted) {
                 console.log(`The video will be muted and we'll retry playing it.`, err);

package/dist/prefetch-state.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+declare type Value = Record<string, string>;
+export declare const PreloadContext: React.Context<Value>;
+export declare const setPreloads: (updater: (p: Value) => Value) => void;
+export declare const PrefetchProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export {};

package/dist/prefetch-state.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrefetchProvider = exports.setPreloads = exports.PreloadContext = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+exports.PreloadContext = (0, react_1.createContext)({});
+let preloads = {};
+let updaters = [];
+const setPreloads = (updater) => {
+    preloads = updater(preloads);
+    updaters.forEach((u) => u());
+};
+exports.setPreloads = setPreloads;
+const PrefetchProvider = ({ children }) => {
+    const [_preloads, _setPreloads] = (0, react_1.useState)(() => preloads);
+    (0, react_1.useEffect)(() => {
+        const updaterFunction = () => {
+            _setPreloads(preloads);
+        };
+        updaters.push(updaterFunction);
+        return () => {
+            updaters = updaters.filter((u) => u !== updaterFunction);
+        };
+    }, []);
+    return ((0, jsx_runtime_1.jsx)(exports.PreloadContext.Provider, { value: _preloads, children: children }));
+};
+exports.PrefetchProvider = PrefetchProvider;

package/dist/prefetch.d.ts

@@ -0,0 +1,9 @@
+export declare const usePreload: (src: string) => string;
+declare type FetchAndPreload = {
+    free: () => void;
+    waitUntilDone: () => Promise<string>;
+};
+export declare const prefetch: (src: string, options?: {
+    method?: 'blob-url' | 'base64';
+}) => FetchAndPreload;
+export {};

package/dist/prefetch.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prefetch = exports.usePreload = void 0;
+const react_1 = require("react");
+const get_environment_1 = require("./get-environment");
+const prefetch_state_1 = require("./prefetch-state");
+const usePreload = (src) => {
+    var _a;
+    const preloads = (0, react_1.useContext)(prefetch_state_1.PreloadContext);
+    return (_a = preloads[src]) !== null && _a !== void 0 ? _a : src;
+};
+exports.usePreload = usePreload;
+const blobToBase64 = function (blob) {
+    const reader = new FileReader();
+    return new Promise((resolve, reject) => {
+        reader.onload = function () {
+            const dataUrl = reader.result;
+            resolve(dataUrl);
+        };
+        reader.onerror = (err) => {
+            return reject(err);
+        };
+        reader.readAsDataURL(blob);
+    });
+};
+const prefetch = (src, options) => {
+    var _a;
+    const method = (_a = options === null || options === void 0 ? void 0 : options.method) !== null && _a !== void 0 ? _a : 'blob-url';
+    if ((0, get_environment_1.getRemotionEnvironment)() === 'rendering') {
+        return {
+            free: () => undefined,
+            waitUntilDone: () => Promise.resolve(src),
+        };
+    }
+    let canceled = false;
+    let objectUrl = null;
+    let resolve = () => undefined;
+    let reject = () => undefined;
+    const waitUntilDone = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    const controller = new AbortController();
+    let canBeAborted = true;
+    fetch(src, {
+        signal: controller.signal,
+    })
+        .then((res) => {
+        canBeAborted = false;
+        if (canceled) {
+            return null;
+        }
+        if (!res.ok) {
+            throw new Error(`HTTP error, status = ${res.status}`);
+        }
+        return res.blob();
+    })
+        .then((buf) => {
+        if (!buf) {
+            return;
+        }
+        if (method === 'base64') {
+            return blobToBase64(buf);
+        }
+        return URL.createObjectURL(buf);
+    })
+        .then((url) => {
+        if (canceled) {
+            return;
+        }
+        objectUrl = url;
+        (0, prefetch_state_1.setPreloads)((p) => ({
+            ...p,
+            [src]: objectUrl,
+        }));
+        resolve(objectUrl);
+    })
+        .catch((err) => {
+        reject(err);
+    });
+    return {
+        free: () => {
+            if (objectUrl) {
+                if (method === 'blob-url') {
+                    URL.revokeObjectURL(objectUrl);
+                }
+                (0, prefetch_state_1.setPreloads)((p) => {
+                    const copy = { ...p };
+                    delete copy[src];
+                    return copy;
+                });
+            }
+            else {
+                canceled = true;
+                if (canBeAborted) {
+                    try {
+                        controller.abort();
+                    }
+                    catch (e) { }
+                }
+            }
+        },
+        waitUntilDone: () => {
+            return waitUntilDone;
+        },
+    };
+};
+exports.prefetch = prefetch;

package/dist/random.d.ts

@@ -1,6 +1,7 @@
+export declare type RandomSeed = number | string | null;
 /**
  * A deterministic pseudo-random number generator.
  * Pass in the same seed and get the same pseudorandom number.
  * See: https://remotion.dev/docs/random
  */
-export declare const random: (seed: number | string | null, dummy?: unknown) => number;
+export declare const random: (seed: RandomSeed, dummy?: unknown) => number;