remotion 4.0.0-webhook.27 → 4.1.0-alpha1

package/dist/cjs/loop/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loop = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const Sequence_js_1 = require("../Sequence.js");
+const use_current_frame_js_1 = require("../use-current-frame.js");
+const use_video_config_js_1 = require("../use-video-config.js");
+const validate_duration_in_frames_js_1 = require("../validation/validate-duration-in-frames.js");
+/**
+ * @description This component allows you to quickly lay out an animation so it repeats itself.
+ * @see [Documentation](https://www.remotion.dev/docs/loop)
+ */
+const Loop = ({ durationInFrames, times = Infinity, children, name, ...props }) => {
+    const currentFrame = (0, use_current_frame_js_1.useCurrentFrame)();
+    const { durationInFrames: compDuration } = (0, use_video_config_js_1.useVideoConfig)();
+    (0, validate_duration_in_frames_js_1.validateDurationInFrames)({
+        durationInFrames,
+        component: 'of the <Loop /> component',
+        allowFloats: true,
+    });
+    if (typeof times !== 'number') {
+        throw new TypeError(`You passed to "times" an argument of type ${typeof times}, but it must be a number.`);
+    }
+    if (times !== Infinity && times % 1 !== 0) {
+        throw new TypeError(`The "times" prop of a loop must be an integer, but got ${times}.`);
+    }
+    if (times < 0) {
+        throw new TypeError(`The "times" prop of a loop must be at least 0, but got ${times}`);
+    }
+    const maxTimes = Math.ceil(compDuration / durationInFrames);
+    const actualTimes = Math.min(maxTimes, times);
+    const style = props.layout === 'none' ? undefined : props.style;
+    const maxFrame = durationInFrames * (actualTimes - 1);
+    const start = Math.floor(currentFrame / durationInFrames) * durationInFrames;
+    const from = Math.min(start, maxFrame);
+    const loopDisplay = (0, react_1.useMemo)(() => {
+        return {
+            numberOfTimes: actualTimes,
+            startOffset: -from,
+            durationInFrames,
+        };
+    }, [actualTimes, durationInFrames, from]);
+    return ((0, jsx_runtime_1.jsx)(Sequence_js_1.Sequence, { durationInFrames: durationInFrames, from: from, name: name, loopDisplay: loopDisplay, layout: props.layout, style: style, children: children }));
+};
+exports.Loop = Loop;

package/dist/{multiple-versions-warning.js → cjs/multiple-versions-warning.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkMultipleRemotionVersions = void 0;
-const truthy_1 = require("./truthy");
-const version_1 = require("./version");
+const truthy_js_1 = require("./truthy.js");
+const version_js_1 = require("./version.js");
 const checkMultipleRemotionVersions = () => {
     if (typeof globalThis === 'undefined') {
         return;
@@ -10,18 +10,23 @@ const checkMultipleRemotionVersions = () => {
     const alreadyImported = globalThis.remotion_imported ||
         (typeof window !== 'undefined' && window.remotion_imported);
     if (alreadyImported) {
+        if (alreadyImported === version_js_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,
+            version_js_1.VERSION,
             typeof alreadyImported === 'string'
                 ? alreadyImported
                 : 'an older version',
         ]
-            .filter(truthy_1.truthy)
+            .filter(truthy_js_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 = true;
+    globalThis.remotion_imported = version_js_1.VERSION;
     if (typeof window !== 'undefined') {
-        window.remotion_imported = version_1.VERSION;
+        window.remotion_imported = version_js_1.VERSION;
     }
 };
 exports.checkMultipleRemotionVersions = checkMultipleRemotionVersions;

package/dist/{nonce.d.ts → cjs/nonce.d.ts}

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-export declare type TNonceContext = {
+export type TNonceContext = {
     getNonce: () => number;
     fastRefreshes: number;
 };

package/dist/{nonce.js → cjs/nonce.js}

@@ -9,7 +9,13 @@ exports.NonceContext = (0, react_1.createContext)({
 const useNonce = () => {
     const context = (0, react_1.useContext)(exports.NonceContext);
     const [nonce, setNonce] = (0, react_1.useState)(() => context.getNonce());
+    const lastContext = (0, react_1.useRef)(context);
+    // Only if context changes, but not initially
     (0, react_1.useEffect)(() => {
+        if (lastContext.current === context) {
+            return;
+        }
+        lastContext.current = context;
         setNonce(context.getNonce);
     }, [context]);
     return nonce;

package/dist/{play-and-handle-not-allowed-error.js → cjs/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/cjs/prefetch-state.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+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/cjs/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/cjs/prefetch.d.ts

@@ -0,0 +1,13 @@
+export declare const usePreload: (src: string) => string;
+type FetchAndPreload = {
+    free: () => void;
+    waitUntilDone: () => Promise<string>;
+};
+/**
+ * @description When you call the preFetch() function, an asset will be fetched and kept in memory so it is ready when you want to play it in a <Player>.
+ * @see [Documentation](https://www.remotion.dev/docs/prefetch)
+ */
+export declare const prefetch: (src: string, options?: {
+    method?: 'blob-url' | 'base64';
+}) => FetchAndPreload;
+export {};

package/dist/{prefetch.js → cjs/prefetch.js}

@@ -2,16 +2,35 @@
 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 get_environment_js_1 = require("./get-environment.js");
+const prefetch_state_js_1 = require("./prefetch-state.js");
 const usePreload = (src) => {
     var _a;
-    const { preloads } = (0, react_1.useContext)(prefetch_state_1.PreloadContext);
+    const preloads = (0, react_1.useContext)(prefetch_state_js_1.PreloadContext);
     return (_a = preloads[src]) !== null && _a !== void 0 ? _a : src;
 };
 exports.usePreload = usePreload;
-const prefetch = (src) => {
-    if ((0, get_environment_1.getRemotionEnvironment)() === 'rendering') {
+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);
+    });
+};
+/**
+ * @description When you call the preFetch() function, an asset will be fetched and kept in memory so it is ready when you want to play it in a <Player>.
+ * @see [Documentation](https://www.remotion.dev/docs/prefetch)
+ */
+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_js_1.getRemotionEnvironment)() === 'rendering') {
         return {
             free: () => undefined,
             waitUntilDone: () => Promise.resolve(src),
@@ -41,28 +60,35 @@ const prefetch = (src) => {
         return res.blob();
     })
         .then((buf) => {
-        var _a;
-        if (canceled) {
+        if (!buf) {
             return;
         }
-        if (buf) {
-            objectUrl = URL.createObjectURL(buf);
-            (_a = prefetch_state_1.preloadRef.current) === null || _a === void 0 ? void 0 : _a.setPreloads((p) => ({
-                ...p,
-                [src]: objectUrl,
-            }));
-            resolve(objectUrl);
+        if (method === 'base64') {
+            return blobToBase64(buf);
         }
+        return URL.createObjectURL(buf);
+    })
+        .then((url) => {
+        if (canceled) {
+            return;
+        }
+        objectUrl = url;
+        (0, prefetch_state_js_1.setPreloads)((p) => ({
+            ...p,
+            [src]: objectUrl,
+        }));
+        resolve(objectUrl);
     })
         .catch((err) => {
         reject(err);
     });
     return {
         free: () => {
-            var _a;
             if (objectUrl) {
-                URL.revokeObjectURL(objectUrl);
-                (_a = prefetch_state_1.preloadRef.current) === null || _a === void 0 ? void 0 : _a.setPreloads((p) => {
+                if (method === 'blob-url') {
+                    URL.revokeObjectURL(objectUrl);
+                }
+                (0, prefetch_state_js_1.setPreloads)((p) => {
                     const copy = { ...p };
                     delete copy[src];
                     return copy;

package/dist/cjs/props-if-has-props.d.ts

@@ -0,0 +1,10 @@
+import type { AnyZodObject, z } from 'zod';
+type And<A extends boolean, B extends boolean> = A extends true ? B extends true ? true : false : false;
+export type PropsIfHasProps<Schema extends AnyZodObject, Props extends Record<string, unknown> | undefined> = And<AnyZodObject extends Schema ? true : false, {} extends Props ? true : false> extends true ? {
+    defaultProps?: {};
+} : {
+    defaultProps: InferProps<Schema, Props>;
+};
+export type InferProps<Schema extends AnyZodObject, Props extends Record<string, unknown> | undefined> = AnyZodObject extends Schema ? {} extends Props ? Record<string, unknown> : Props : {} extends Props ? z.infer<Schema> : // Props and schema specified
+z.infer<Schema> & Props;
+export {};

package/dist/cjs/random.d.ts

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

package/dist/{random.js → cjs/random.js}

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.random = void 0;
+/* eslint-disable no-bitwise */
 function mulberry32(a) {
     let t = a + 0x6d2b79f5;
     t = Math.imul(t ^ (t >>> 15), t | 1);
@@ -19,9 +20,8 @@ function hashCode(str) {
     return hash;
 }
 /**
- * A deterministic pseudo-random number generator.
- * Pass in the same seed and get the same pseudorandom number.
- * See: https://remotion.dev/docs/random
+ * @description A deterministic pseudo-random number generator. Pass in the same seed and get the same pseudorandom number.
+ * @see [Documentation](https://remotion.dev/docs/random)
  */
 const random = (seed, dummy) => {
     if (dummy !== undefined) {

package/dist/{register-root.d.ts → cjs/register-root.d.ts}

@@ -1,4 +1,8 @@
 import type React from 'react';
+/**
+ * @description This function registers the root component of the Remotion project
+ * @see [Documentation](https://www.remotion.dev/docs/register-root)
+ */
 export declare const registerRoot: (comp: React.FC) => void;
 export declare const getRoot: () => React.FC<{}> | null;
 export declare const waitForRoot: (fn: (comp: React.FC) => void) => (() => void);

package/dist/{register-root.js → cjs/register-root.js}

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitForRoot = exports.getRoot = exports.registerRoot = void 0;
 let Root = null;
 let listeners = [];
+/**
+ * @description This function registers the root component of the Remotion project
+ * @see [Documentation](https://www.remotion.dev/docs/register-root)
+ */
 const registerRoot = (comp) => {
     if (!comp) {
         throw new Error(`You must pass a React component to registerRoot(), but ${JSON.stringify(comp)} was passed.`);

package/dist/cjs/resolve-video-config.d.ts

@@ -0,0 +1,8 @@
+import type { AnyZodObject } from 'zod';
+import type { TCompMetadataWithCalcFunction } from './CompositionManager.js';
+import type { VideoConfig } from './video-config.js';
+export declare const resolveVideoConfig: ({ composition, editorProps: editorPropsOrUndefined, signal, }: {
+    composition: TCompMetadataWithCalcFunction<AnyZodObject, Record<string, unknown> | undefined>;
+    editorProps: object;
+    signal: AbortSignal;
+}) => VideoConfig | Promise<VideoConfig>;

package/dist/cjs/resolve-video-config.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVideoConfig = void 0;
+const input_props_js_1 = require("./config/input-props.js");
+const get_environment_js_1 = require("./get-environment.js");
+const validate_dimensions_js_1 = require("./validation/validate-dimensions.js");
+const validate_duration_in_frames_js_1 = require("./validation/validate-duration-in-frames.js");
+const resolveVideoConfig = ({ composition, editorProps: editorPropsOrUndefined, signal, }) => {
+    var _a, _b, _c, _d, _e, _f;
+    const calculatedProm = composition.calculateMetadata
+        ? composition.calculateMetadata({
+            defaultProps: (_a = composition.defaultProps) !== null && _a !== void 0 ? _a : {},
+            props: {
+                ...((_b = composition.defaultProps) !== null && _b !== void 0 ? _b : {}),
+                ...(editorPropsOrUndefined !== null && editorPropsOrUndefined !== void 0 ? editorPropsOrUndefined : {}),
+                ...(typeof window === 'undefined' ||
+                    (0, get_environment_js_1.getRemotionEnvironment)() === 'player-development' ||
+                    (0, get_environment_js_1.getRemotionEnvironment)() === 'player-production'
+                    ? {}
+                    : (_c = (0, input_props_js_1.getInputProps)()) !== null && _c !== void 0 ? _c : {}),
+            },
+            abortSignal: signal,
+        })
+        : null;
+    if (calculatedProm !== null &&
+        typeof calculatedProm === 'object' &&
+        'then' in calculatedProm) {
+        return calculatedProm.then((c) => {
+            var _a, _b;
+            const { height, width, durationInFrames, fps } = validateCalculated({
+                calculated: c,
+                composition,
+            });
+            return {
+                width,
+                height,
+                fps,
+                durationInFrames,
+                id: composition.id,
+                defaultProps: (_b = (_a = c.props) !== null && _a !== void 0 ? _a : composition.defaultProps) !== null && _b !== void 0 ? _b : {},
+            };
+        });
+    }
+    const data = validateCalculated({
+        calculated: calculatedProm,
+        composition,
+    });
+    if (calculatedProm === null) {
+        return {
+            ...data,
+            id: composition.id,
+            defaultProps: (_d = composition === null || composition === void 0 ? void 0 : composition.defaultProps) !== null && _d !== void 0 ? _d : {},
+        };
+    }
+    return {
+        ...data,
+        id: composition.id,
+        defaultProps: (_f = (_e = calculatedProm === null || calculatedProm === void 0 ? void 0 : calculatedProm.props) !== null && _e !== void 0 ? _e : composition.defaultProps) !== null && _f !== void 0 ? _f : {},
+    };
+};
+exports.resolveVideoConfig = resolveVideoConfig;
+const validateCalculated = ({ composition, calculated, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const potentialErrorLocation = `calculated by calculateMetadata() for the composition "${composition.id}"`;
+    const width = (_b = (_a = calculated === null || calculated === void 0 ? void 0 : calculated.width) !== null && _a !== void 0 ? _a : composition.width) !== null && _b !== void 0 ? _b : null;
+    if (!width) {
+        throw new TypeError('Composition width was neither specified via the `width` prop nor the `calculateMetadata()` function.');
+    }
+    (0, validate_dimensions_js_1.validateDimension)(width, 'width', potentialErrorLocation);
+    const height = (_d = (_c = calculated === null || calculated === void 0 ? void 0 : calculated.height) !== null && _c !== void 0 ? _c : composition.height) !== null && _d !== void 0 ? _d : null;
+    if (!height) {
+        throw new TypeError('Composition height was neither specified via the `height` prop nor the `calculateMetadata()` function.');
+    }
+    (0, validate_dimensions_js_1.validateDimension)(width, 'height', potentialErrorLocation);
+    const fps = (_f = (_e = calculated === null || calculated === void 0 ? void 0 : calculated.fps) !== null && _e !== void 0 ? _e : composition.fps) !== null && _f !== void 0 ? _f : null;
+    if (!fps) {
+        throw new TypeError('Composition fps was neither specified via the `fps` prop nor the `calculateMetadata()` function.');
+    }
+    const durationInFrames = (_h = (_g = calculated === null || calculated === void 0 ? void 0 : calculated.durationInFrames) !== null && _g !== void 0 ? _g : composition.durationInFrames) !== null && _h !== void 0 ? _h : null;
+    if (!durationInFrames) {
+        throw new TypeError('Composition durationInFrames was neither specified via the `durationInFrames` prop nor the `calculateMetadata()` function.');
+    }
+    (0, validate_duration_in_frames_js_1.validateDurationInFrames)({
+        durationInFrames,
+        component: potentialErrorLocation,
+        allowFloats: false,
+    });
+    return { width, height, fps, durationInFrames };
+};

package/dist/cjs/series/flatten-children.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const flattenChildren: (children: React.ReactNode) => (string | number | React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactFragment | React.ReactPortal)[];

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

@@ -0,0 +1,17 @@
+import type { FC, PropsWithChildren } from 'react';
+import type { LayoutAndStyle, SequenceProps } from '../Sequence.js';
+type SeriesSequenceProps = PropsWithChildren<{
+    durationInFrames: number;
+    offset?: number;
+} & Pick<SequenceProps, 'layout' | 'name'> & LayoutAndStyle>;
+declare const SeriesSequence: import("react").ForwardRefExoticComponent<SeriesSequenceProps & import("react").RefAttributes<HTMLDivElement>>;
+/**
+ * @description with this component, you can easily stitch together scenes that should play sequentially after another.
+ * @see [Documentation](https://www.remotion.dev/docs/series)
+ */
+declare const Series: FC<{
+    children: React.ReactNode;
+}> & {
+    Sequence: typeof SeriesSequence;
+};
+export { Series };

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

@@ -3,17 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Series = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
-const Sequence_1 = require("../Sequence");
-const validate_duration_in_frames_1 = require("../validation/validate-duration-in-frames");
-const flatten_children_1 = require("./flatten-children");
-const SeriesSequence = ({ children }) => {
+const Sequence_js_1 = require("../Sequence.js");
+const validate_duration_in_frames_js_1 = require("../validation/validate-duration-in-frames.js");
+const flatten_children_js_1 = require("./flatten-children.js");
+const SeriesSequenceRefForwardingFunction = ({ children }, _ref) => {
+    // Discard ref
     // eslint-disable-next-line react/jsx-no-useless-fragment
     return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: children });
 };
+const SeriesSequence = (0, react_1.forwardRef)(SeriesSequenceRefForwardingFunction);
+/**
+ * @description with this component, you can easily stitch together scenes that should play sequentially after another.
+ * @see [Documentation](https://www.remotion.dev/docs/series)
+ */
 const Series = ({ children }) => {
     const childrenValue = (0, react_1.useMemo)(() => {
         let startFrame = 0;
-        return react_1.Children.map((0, flatten_children_1.flattenChildren)(children), (child, i) => {
+        const flattenedChildren = (0, flatten_children_js_1.flattenChildren)(children);
+        return react_1.Children.map(flattenedChildren, (child, i) => {
             var _a;
             const castedChild = child;
             if (typeof castedChild === 'string') {
@@ -27,12 +34,19 @@ const Series = ({ children }) => {
                 throw new TypeError(`The <Series /> component only accepts a list of <Series.Sequence /> components as it's children, but got ${castedChild} instead`);
             }
             const debugInfo = `index = ${i}, duration = ${castedChild.props.durationInFrames}`;
-            if (!castedChild || !castedChild.props.children) {
+            if (!(castedChild === null || castedChild === void 0 ? void 0 : castedChild.props.children)) {
                 throw new TypeError(`A <Series.Sequence /> component (${debugInfo}) was detected to not have any children. Delete it to fix this error.`);
             }
             const durationInFramesProp = castedChild.props.durationInFrames;
             const { durationInFrames, children: _children, ...passedProps } = castedChild.props;
-            (0, validate_duration_in_frames_1.validateDurationInFrames)(durationInFramesProp, `of a <Series.Sequence /> component`);
+            if (i !== flattenedChildren.length - 1 ||
+                durationInFramesProp !== Infinity) {
+                (0, validate_duration_in_frames_js_1.validateDurationInFrames)({
+                    durationInFrames: durationInFramesProp,
+                    component: `of a <Series.Sequence /> component`,
+                    allowFloats: true,
+                });
+            }
             const offset = (_a = castedChild.props.offset) !== null && _a !== void 0 ? _a : 0;
             if (Number.isNaN(offset)) {
                 throw new TypeError(`The "offset" property of a <Series.Sequence /> must not be NaN, but got NaN (${debugInfo}).`);
@@ -45,7 +59,7 @@ const Series = ({ children }) => {
             }
             const currentStartFrame = startFrame + offset;
             startFrame += durationInFramesProp + offset;
-            return ((0, jsx_runtime_1.jsx)(Sequence_1.Sequence, { from: currentStartFrame, durationInFrames: durationInFramesProp, ...passedProps, children: child }));
+            return ((0, jsx_runtime_1.jsx)(Sequence_js_1.Sequence, { from: currentStartFrame, durationInFrames: durationInFramesProp, ...passedProps, ref: castedChild.ref, children: child }));
         });
     }, [children]);
     /* eslint-disable react/jsx-no-useless-fragment */

package/dist/cjs/setup-env-variables.d.ts

@@ -0,0 +1 @@
+export declare const setupEnvVariables: () => void;

package/dist/{setup-env-variables.js → cjs/setup-env-variables.js}

@@ -1,22 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupEnvVariables = exports.ENV_VARIABLES_ENV_NAME = void 0;
-const get_environment_1 = require("./get-environment");
-exports.ENV_VARIABLES_ENV_NAME = 'ENV_VARIABLES';
+exports.setupEnvVariables = void 0;
+const get_environment_js_1 = require("./get-environment.js");
 const getEnvVariables = () => {
-    if ((0, get_environment_1.getRemotionEnvironment)() === 'rendering') {
+    if ((0, get_environment_js_1.getRemotionEnvironment)() === 'rendering') {
         const param = window.remotion_envVariables;
         if (!param) {
             return {};
         }
         return { ...JSON.parse(param), NODE_ENV: process.env.NODE_ENV };
     }
-    if ((0, get_environment_1.getRemotionEnvironment)() === 'preview') {
-        // Webpack will convert this to an object at compile time.
-        // Don't convert this syntax to a computed property.
+    if ((0, get_environment_js_1.getRemotionEnvironment)() === 'preview') {
+        // For the Preview, we already set the environment variables in index-html.ts.
+        // We just add NODE_ENV here.
         return {
-            ...process.env.ENV_VARIABLES,
-            NODE_ENV: process.env.NODE_ENV,
+            NODE_ENV: 'development',
         };
     }
     throw new Error('Can only call getEnvVariables() if environment is `rendering` or `preview`');

package/dist/{spring → cjs/spring}/index.d.ts

@@ -1,9 +1,10 @@
-import type { SpringConfig } from './spring-utils';
+import type { SpringConfig } from './spring-utils.js';
 /**
- * Calculates a position based on physical parameters, start and end value, and time.
- * @link https://www.remotion.dev/docs/spring
+ * @description Calculates a position based on physical parameters, start and end value, and time.
+ * @see [Documentation](https://www.remotion.dev/docs/spring)
  * @param {number} frame The current time value. Most of the time you want to pass in the return value of useCurrentFrame.
  * @param {number} fps The framerate at which the animation runs. Pass in the value obtained by `useVideoConfig()`.
+ * @param {?boolean} reverse Whether the animation plays in reverse or not. Default `false`.
  * @param {?Object} config optional object that allows you to customize the physical properties of the animation.
  * @param {number} [config.mass=1] The weight of the spring. If you reduce the mass, the animation becomes faster!
  * @param {number} [config.damping=10] How hard the animation decelerates.
@@ -13,8 +14,9 @@ import type { SpringConfig } from './spring-utils';
  * @param {?number} [config.to] The end value of the animation. Default `1`
  * @param {?number} [config.durationInFrames] Stretch the duration of an animation to  a set value.. Default `undefined`
  * @param {?number} [config.durationThreshold] How close to the end the animation is considered to be done. Default `0.005`
+ * @param {?number} [config.delay] Delay the animation for this amount of frames. Default `0`
  */
-export declare function spring({ frame, fps, config, from, to, durationInFrames, durationRestThreshold, }: {
+export declare function spring({ frame: passedFrame, fps, config, from, to, durationInFrames: passedDurationInFrames, durationRestThreshold, delay, reverse, }: {
     frame: number;
     fps: number;
     config?: Partial<SpringConfig>;
@@ -22,6 +24,8 @@ export declare function spring({ frame, fps, config, from, to, durationInFrames,
     to?: number;
     durationInFrames?: number;
     durationRestThreshold?: number;
+    delay?: number;
+    reverse?: boolean;
 }): number;
-export { measureSpring } from './measure-spring';
-export { SpringConfig } from './spring-utils';
+export { measureSpring } from './measure-spring.js';
+export { SpringConfig } from './spring-utils.js';