remotion 4.0.199 → 4.0.201

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/spring-bench.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/spring-bench.test.js

@@ -0,0 +1,30 @@
+import { expect, test } from 'vitest';
+import { spring } from '../spring';
+test('Springs should calculate fast and cache the natural duration', async () => {
+    const date = performance.now();
+    for (let i = 0; i < 100000; i++) {
+        spring({
+            frame: 8000,
+            fps: 60,
+            delay: 12000,
+            durationInFrames: Math.round(Math.random() * 100) + 1,
+        });
+        spring({
+            frame: 8000,
+            fps: 60,
+            durationInFrames: Math.round(Math.random() * 100) + 1,
+        });
+        spring({
+            frame: 8000,
+            fps: 60,
+            reverse: true,
+            durationInFrames: Math.round(Math.random() * 100) + 1,
+        });
+    }
+    const time = await new Promise((resolve) => {
+        setTimeout(() => {
+            resolve(performance.now() - date);
+        });
+    });
+    expect(time).toBeLessThan(process.platform === 'darwin' ? 1500 : 600);
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/spring.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/spring.test.js

@@ -0,0 +1,164 @@
+import { describe, expect, test } from 'vitest';
+import { isApproximatelyTheSame } from '../is-approximately-the-same.js';
+import { spring } from '../spring/index.js';
+import { measureSpring } from '../spring/measure-spring.js';
+test('Basic spring to equal 0', () => {
+    expect(spring({
+        fps: 30,
+        frame: 0,
+    })).toEqual(0);
+});
+test('Basic spring to equal 1', () => {
+    expect(spring({
+        fps: 30,
+        frame: 0,
+        from: 1,
+        to: 0,
+    })).toEqual(1);
+});
+test('Should be approxmiately the same', () => {
+    expect(isApproximatelyTheSame(spring({
+        fps: 30,
+        frame: 1,
+    }), 0.04941510804510185)).toBe(true);
+});
+test('Should be close to 1', () => {
+    expect(spring({
+        fps: 30,
+        frame: 100,
+    })).toBeCloseTo(1);
+});
+test('Should be able to set duration for spring', () => {
+    expect(spring({
+        fps: 30,
+        frame: 5,
+        durationInFrames: 5,
+    })).toBeCloseTo(1);
+});
+// Reverse tests
+test('Should be able to set duration for spring when in reverse', () => {
+    expect(spring({
+        fps: 30,
+        frame: 5,
+        durationInFrames: 5,
+        reverse: true,
+    })).toBeCloseTo(0);
+    expect(spring({
+        fps: 30,
+        frame: 0,
+        durationInFrames: 5,
+        reverse: true,
+    })).toBeCloseTo(1);
+});
+test('Should be able to set duration for spring when in reverse', () => {
+    expect(spring({
+        fps: 30,
+        frame: 0,
+        durationInFrames: 5,
+        reverse: true,
+    })).toBeCloseTo(1);
+});
+// This is the reverse of one of the first tests
+test('Should be approxmiately the same when in reverse', () => {
+    expect(spring({
+        fps: 30,
+        // duration - 1
+        frame: measureSpring({ fps: 30 }) - 1,
+        reverse: true,
+    })).toBeCloseTo(0.04941510804510185);
+});
+test('Should be close to 0 when in reverse', () => {
+    expect(spring({
+        fps: 30,
+        frame: 100,
+        reverse: true,
+    })).toBeCloseTo(0);
+});
+describe('Should be able to delay a spring', () => {
+    test('Should clamp all frames before the delay to zero', () => {
+        expect(spring({
+            fps: 30,
+            frame: 0,
+            delay: 25,
+        })).toEqual(0);
+        expect(spring({
+            fps: 30,
+            frame: 15,
+            delay: 25,
+        })).toEqual(0);
+        expect(spring({
+            fps: 30,
+            frame: 25,
+            delay: 25,
+        })).toEqual(0);
+    });
+    test('Should start calculations from the delay + 1', () => {
+        expect(spring({
+            fps: 30,
+            frame: 26,
+            delay: 25,
+        })).toBeGreaterThan(0);
+    });
+    test('Should be close to 1', () => {
+        expect(spring({
+            fps: 30,
+            frame: 25 + 30,
+            delay: 25,
+        })).toBeCloseTo(1);
+    });
+});
+test('Should apply delay in the right order', () => {
+    expect(spring({
+        fps: 30,
+        frame: 61,
+        delay: 60,
+        durationInFrames: 10,
+    })).toBe(spring({
+        fps: 30,
+        frame: 1,
+        delay: 0,
+        durationInFrames: 10,
+    }));
+});
+test('weird case', () => {
+    const val = spring({
+        fps: 30,
+        frame: 12 * 30,
+        config: {
+            damping: 200,
+        },
+        delay: 12 * 30,
+        durationInFrames: 60,
+        reverse: true,
+    });
+    expect(val).toBeCloseTo(1);
+    const val2 = spring({
+        fps: 30,
+        frame: 12 * 30 + 60,
+        config: {
+            damping: 200,
+        },
+        delay: 12 * 30,
+        durationInFrames: 60,
+        reverse: true,
+    });
+    expect(val2).toBeCloseTo(0);
+});
+test('spring should not end too early', () => {
+    expect(spring({
+        fps: 30,
+        frame: 9,
+        config: {
+            damping: 200,
+        },
+        durationInFrames: 10,
+    })).toBeLessThan(1);
+    expect(spring({
+        fps: 30,
+        frame: 10,
+        config: {
+            damping: 200,
+        },
+        durationInFrames: 10,
+    })).toBeCloseTo(1);
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/static-file-errors.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/static-file-errors.test.js

@@ -0,0 +1,16 @@
+import { expect, test } from 'vitest';
+import { staticFile } from '../static-file.js';
+test('duplicate staticFile() should throw a warning', () => {
+    // @ts-expect-error
+    global.window = {
+        remotion_staticBase: '/static-abcdef',
+    };
+    expect(() => staticFile(staticFile('file.mp3'))).toThrow('The value "/static-abcdef/file.mp3" is already prefixed with the static base /static-abcdef. You don\'t need to call staticFile() on it.');
+});
+test('"https//" in staticFile() should throw an error', () => {
+    expect(() => staticFile(staticFile('https://'))).toThrow('staticFile() does not support remote URLs - got "https://". Instead, pass the URL without wrapping it in staticFile(). See: https://remotion.dev/docs/staticfile-remote-urls');
+});
+test('Single use of staticFile should not thrown an error', () => {
+    const staticBase = window.remotion_staticBase;
+    expect(staticFile('file.mp3')).toBe(staticBase + '/file.mp3');
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/static-file-safe-uri.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/static-file-safe-uri.test.js

@@ -0,0 +1,26 @@
+import { expect, test } from 'vitest';
+import { staticFile } from '../static-file.js';
+test('staticFile() should convert # into %23', () => {
+    const unsafeName = 'test/example#music';
+    expect(staticFile(unsafeName)).toBe('/test/example%23music');
+});
+test('staticFile() passing already encoded path should give warning', () => {
+    const unsafeName = '/test%2Fexample%23music';
+    expect(staticFile(unsafeName)).toBe('/test%252Fexample%2523music');
+});
+test('staticFile() should not encode slashes', () => {
+    const nameWithSlashes = '/test/example/word';
+    expect(staticFile(nameWithSlashes)).toBe(nameWithSlashes);
+});
+test('staticFile() should encode all problematic characters except slashes', () => {
+    const nameWithSlashes = '/test/#example/$word';
+    expect(staticFile(nameWithSlashes)).toBe('/test/%23example/%24word');
+});
+test('if no leading slash exists, one should be added', () => {
+    const nameWithSlashes = 'test/example';
+    expect(staticFile(nameWithSlashes)).toBe('/test/example');
+});
+test('problematic character at the beginning should be encoded correctly', () => {
+    const problematicStart = '#test/example';
+    expect(staticFile(problematicStart)).toBe('/%23test/example');
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/truthy.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/truthy.test.js

@@ -0,0 +1,22 @@
+import { expect, test } from 'vitest';
+import { truthy } from '../truthy.js';
+test.each([
+    ['true', true],
+    ['false', true],
+    ['True', true],
+    ['False', true],
+    ['', false],
+    ['abc', true],
+    [true, true],
+    [false, false],
+    [null, false],
+    [undefined, false],
+    [0, false],
+    [1, true],
+    [0.5, true],
+    [12, true],
+    [-1, true],
+    [-4, true],
+])('test with %s', (input, expected) => {
+    expect(truthy(input)).toEqual(expected);
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/use-media-in-timeline.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/use-media-in-timeline.test.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { afterAll, beforeAll, expect, test, vitest } from 'vitest';
+import { CompositionManager } from '../CompositionManagerContext.js';
+import { RenderAssetManagerProvider } from '../RenderAssetManager.js';
+import { ResolveCompositionConfig } from '../ResolveCompositionConfig.js';
+import { SequenceManager } from '../SequenceManager.js';
+import { useMediaInTimeline } from '../use-media-in-timeline.js';
+import * as useVideoConfigModule from '../use-video-config.js';
+import { renderHook } from './render-hook.js';
+import { mockCompositionContext } from './wrap-sequence-context.js';
+beforeAll(() => {
+    vitest
+        .spyOn(useVideoConfigModule, 'useVideoConfig')
+        .mockImplementation(() => ({
+        width: 10,
+        height: 10,
+        fps: 30,
+        durationInFrames: 100,
+        id: 'hithere',
+        defaultProps: {},
+        props: {},
+        defaultCodec: null,
+    }));
+});
+afterAll(() => {
+    vitest.spyOn(useVideoConfigModule, 'useVideoConfig').mockClear();
+});
+test('useMediaInTimeline registers and unregisters new sequence', () => {
+    const registerSequence = vitest.fn();
+    const unregisterSequence = vitest.fn();
+    const wrapper = ({ children }) => {
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const sequenceManagerContext = useMemo(() => {
+            return {
+                registerSequence,
+                unregisterSequence,
+                sequences: [],
+            };
+        }, []);
+        return (_jsx(CompositionManager.Provider, { value: mockCompositionContext, children: _jsx(SequenceManager.Provider, { value: sequenceManagerContext, children: _jsx(RenderAssetManagerProvider, { children: _jsx(ResolveCompositionConfig, { children: children }) }) }) }));
+    };
+    const audioRef = {
+        current: { volume: 0.5 },
+    };
+    const { unmount } = renderHook(() => useMediaInTimeline({
+        volume: 1,
+        src: 'test',
+        mediaVolume: 1,
+        mediaType: 'audio',
+        mediaRef: audioRef,
+        playbackRate: 1,
+        displayName: null,
+        id: 'test',
+        stack: null,
+        showInTimeline: true,
+    }), {
+        wrapper,
+    });
+    expect(registerSequence).toHaveBeenCalled();
+    unmount();
+    expect(unregisterSequence).toHaveBeenCalled();
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/use-media-tag-volume.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/use-media-tag-volume.test.js

@@ -0,0 +1,44 @@
+import React from 'react';
+import { afterEach, beforeEach, describe, expect, test, vitest } from 'vitest';
+import { useMediaTagVolume } from '../use-media-tag-volume.js';
+import { renderHook } from './render-hook.js';
+describe('Should update state when volume changes', () => {
+    const setState = vitest.fn();
+    const useStateSpy = vitest.spyOn(React, 'useState');
+    beforeEach(() => {
+        // @ts-expect-error
+        useStateSpy.mockImplementation((init) => [init, setState]);
+    });
+    afterEach(() => {
+        useStateSpy.mockRestore();
+    });
+    test.skip('has the volume been set', () => {
+        const addEventListener = vitest.fn();
+        const removeEventListener = vitest.fn();
+        let audioRef = {
+            current: { volume: 0.5, addEventListener, removeEventListener },
+        };
+        const { rerender } = renderHook(({ mediaRef }) => useMediaTagVolume(mediaRef), {
+            initialProps: { mediaRef: audioRef },
+        });
+        expect(setState).toHaveBeenCalledWith(0.5);
+        audioRef = {
+            current: { ...audioRef.current, volume: 0.75 },
+        };
+        rerender({ mediaRef: audioRef });
+        expect(setState).toHaveBeenCalledWith(0.75);
+        expect(addEventListener).toHaveBeenCalledWith('volumechange', expect.anything());
+        expect(removeEventListener).toHaveBeenCalledWith('volumechange', expect.anything());
+    });
+});
+test('Should listen for volume changes', () => {
+    const addEventListener = vitest.fn();
+    const removeEventListener = vitest.fn();
+    const audioRef = {
+        current: { volume: 0.5, addEventListener, removeEventListener },
+    };
+    renderHook(({ mediaRef }) => useMediaTagVolume(mediaRef), {
+        initialProps: { mediaRef: audioRef },
+    });
+    expect(addEventListener).toHaveBeenCalledTimes(1);
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/use-sync-volume-with-media-tag.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/use-sync-volume-with-media-tag.test.js

@@ -0,0 +1,53 @@
+import { expect, test, vitest } from 'vitest';
+import { useSyncVolumeWithMediaTag } from '../use-sync-volume-with-media-tag.js';
+import { renderHook } from './render-hook.js';
+test('has the volume been adapted', () => {
+    var _a, _b;
+    const addEventListener = vitest.fn();
+    const removeEventListener = vitest.fn();
+    const audioRef = {
+        current: { volume: 0.5, addEventListener, removeEventListener },
+    };
+    const volume = 0.6;
+    const volumePropFrame = 1;
+    const actualVolume = 0.4;
+    const initialProps = {
+        volumePropFrame,
+        actualVolume,
+        volume,
+        mediaRef: audioRef,
+        mediaVolume: 1,
+    };
+    const { rerender } = renderHook((hookProps) => useSyncVolumeWithMediaTag(hookProps), {
+        initialProps,
+    });
+    expect((_a = audioRef.current) === null || _a === void 0 ? void 0 : _a.volume).toEqual(initialProps.volume);
+    const newVolume = 0.5;
+    rerender({
+        ...initialProps,
+        volume: newVolume,
+    });
+    expect((_b = audioRef.current) === null || _b === void 0 ? void 0 : _b.volume).toEqual(newVolume);
+});
+test('volume should not be adapted', () => {
+    var _a;
+    const addEventListener = vitest.fn();
+    const removeEventListener = vitest.fn();
+    const audioRef = {
+        current: { volume: 0.4, addEventListener, removeEventListener },
+    };
+    const volume = 0.4;
+    const volumePropFrame = 1;
+    const actualVolume = 0.4;
+    const initialProps = {
+        volumePropFrame,
+        actualVolume,
+        volume,
+        mediaRef: audioRef,
+        mediaVolume: 1,
+    };
+    renderHook((hookProps) => useSyncVolumeWithMediaTag(hookProps), {
+        initialProps,
+    });
+    expect((_a = audioRef.current) === null || _a === void 0 ? void 0 : _a.volume).toEqual(initialProps.volume);
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/validate-start-from-props.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/validate-start-from-props.test.js

@@ -0,0 +1,37 @@
+import { describe, test } from 'vitest';
+import { validateStartFromProps } from '../validate-start-from-props.js';
+import { expectToThrow } from './expect-to-throw.js';
+describe('ValidateStartFrom props should throw', () => {
+    describe('Throw with invalid startFrom prop', () => {
+        test('It should throw if startFrom prop is negative', () => {
+            expectToThrow(() => validateStartFromProps(-40, 1), /startFrom must be greater than equal to 0 instead got -40./);
+        });
+        test('It should throw if startFrom is not a number', () => {
+            expectToThrow(
+            // @ts-expect-error
+            () => validateStartFromProps('10', 20), /type of startFrom prop must be a number, instead got type string./);
+        });
+        test('It should throw if startFrom is NaN', () => {
+            expectToThrow(() => validateStartFromProps(NaN, 20), /startFrom prop can not be NaN or Infinity./);
+        });
+        test('It should throw if startFrom is Infinity', () => {
+            expectToThrow(() => validateStartFromProps(Infinity, 20), /startFrom prop can not be NaN or Infinity./);
+        });
+    });
+    describe('Throw with invalid endAt prop', () => {
+        test('It should throw if endAt prop is negative', () => {
+            expectToThrow(() => validateStartFromProps(0, -40), /endAt must be a positive number, instead got -40./);
+        });
+        test('It should throw if endAt is less than startFrom', () => {
+            expectToThrow(() => validateStartFromProps(10, 1), /endAt prop must be greater than startFrom prop./);
+        });
+        test('It should throw if endAt is not a number', () => {
+            expectToThrow(
+            // @ts-expect-error
+            () => validateStartFromProps(10, '20'), /type of endAt prop must be a number, instead got type string./);
+        });
+        test('It should throw if endAt is NaN', () => {
+            expectToThrow(() => validateStartFromProps(10, NaN), /endAt prop can not be NaN./);
+        });
+    });
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/video.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/video.test.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @vitest-environment jsdom
+ */
+import { render } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+import { CanUseRemotionHooksProvider } from '../CanUseRemotionHooks.js';
+import { Video } from '../video/index.js';
+import { expectToThrow } from './expect-to-throw.js';
+import { WrapSequenceContext } from './wrap-sequence-context.js';
+describe('Render correctly with props', () => {
+    test('It should render Video without startFrom / endAt props', () => {
+        expect(() => render(_jsx(WrapSequenceContext, { children: _jsx(Video, { src: "test" }) }))).not.toThrow();
+    });
+    test('It should render Video with startFrom props', () => {
+        expect(() => render(_jsx(WrapSequenceContext, { children: _jsx(Video, { src: "test", startFrom: 10 }) }))).not.toThrow();
+    });
+    test('It should render Video with endAt props', () => {
+        expect(() => render(_jsx(WrapSequenceContext, { children: _jsx(Video, { src: "test", endAt: 10 }) }))).not.toThrow();
+    });
+    test('It should render Video with startFrom and endAt props', () => {
+        expect(() => render(_jsx(WrapSequenceContext, { children: _jsx(Video, { src: "test", startFrom: 10, endAt: 15 }) }))).not.toThrow();
+    });
+    test('It should throw if videoConfig/Wrapper is missing', () => {
+        expectToThrow(() => render(_jsx(CanUseRemotionHooksProvider, { children: _jsx(Video, { startFrom: 10, endAt: 15 }) })), /No video config found/);
+    });
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/volume-prop.test.d.ts

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/volume-prop.test.js

@@ -0,0 +1,93 @@
+import { describe, expect, test } from 'vitest';
+import { evaluateVolume } from '../volume-prop.js';
+import { expectToThrow } from './expect-to-throw.js';
+describe('EvaluateVolume does not throw', () => {
+    test('Volume is undefined', () => {
+        const toEvaluate = {
+            frame: 10,
+            volume: undefined,
+            mediaVolume: 1,
+            allowAmplificationDuringRender: false,
+        };
+        expect(evaluateVolume(toEvaluate)).toEqual(1);
+    });
+    test('Volume is smaller than one', () => {
+        const smallVolume = 0.5;
+        const toEvaluate = {
+            frame: 10,
+            volume: smallVolume,
+            mediaVolume: 1,
+            allowAmplificationDuringRender: false,
+        };
+        expect(evaluateVolume(toEvaluate)).toEqual(smallVolume);
+    });
+    test('Volume is bigger than one', () => {
+        const toEvaluate = {
+            frame: 10,
+            volume: 10,
+            mediaVolume: 1,
+            allowAmplificationDuringRender: true,
+        };
+        expect(evaluateVolume(toEvaluate)).toBe(10);
+    });
+    test('evaluated volume from frame that is smaller than one', () => {
+        const toEvaluate = {
+            frame: 1,
+            volume: (frame) => frame * 0.5,
+            mediaVolume: 1,
+            allowAmplificationDuringRender: false,
+        };
+        expect(evaluateVolume(toEvaluate)).toBe(0.5);
+    });
+    test('evaluated volume from frame that is bigger than one', () => {
+        const toEvaluate = {
+            frame: 10,
+            volume: (frame) => frame,
+            mediaVolume: 1,
+            allowAmplificationDuringRender: false,
+        };
+        expect(evaluateVolume(toEvaluate)).toBe(1);
+    });
+});
+describe('evaluateVolume throws exception', () => {
+    test('It should throw if volume prop is neither number nor undefined', () => {
+        const toEvaluate = { frame: 10, volume: 'NaN' };
+        expectToThrow(() => {
+            // @ts-expect-error
+            evaluateVolume(toEvaluate);
+        }, /volume is not a function/);
+    });
+    test('It should throw if volume is invalid type', () => {
+        const invalidVolume = 'anystring';
+        const toEvaluate = { frame: 1, volume: () => invalidVolume, mediaVolume: 1 };
+        // changing the test because string multiply by a number in javascript is `NaN`
+        expectToThrow(() => {
+            // @ts-expect-error
+            evaluateVolume(toEvaluate);
+        }, /You passed in a function to the volume prop but it returned NaN for frame 1./);
+    });
+    test('It should throw if volume is NaN', () => {
+        const invalidVolume = NaN;
+        const toEvaluate = {
+            frame: 1,
+            volume: () => invalidVolume,
+            mediaVolume: 1,
+            allowAmplificationDuringRender: false,
+        };
+        expectToThrow(() => {
+            evaluateVolume(toEvaluate);
+        }, /You passed in a function to the volume prop but it returned NaN for frame 1/);
+    });
+    test('It should throw if volume returns non finite number', () => {
+        const invalidVolume = Infinity;
+        const toEvaluate = {
+            frame: 1,
+            volume: () => invalidVolume,
+            mediaVolume: 1,
+            allowAmplificationDuringRender: false,
+        };
+        expectToThrow(() => {
+            evaluateVolume(toEvaluate);
+        }, /You passed in a function to the volume prop but it returned a non-finite number for frame 1/);
+    });
+});

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/wrap-sequence-context.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { CompositionManagerContext } from '../CompositionManagerContext.js';
+export declare const mockCompositionContext: CompositionManagerContext;
+export declare const WrapSequenceContext: React.FC<{
+    children: React.ReactNode;
+}>;

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/wrap-sequence-context.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CanUseRemotionHooksProvider } from '../CanUseRemotionHooks.js';
+import { CompositionManager } from '../CompositionManagerContext.js';
+import { ResolveCompositionConfig } from '../ResolveCompositionConfig.js';
+const Comp = () => null;
+export const mockCompositionContext = {
+    assets: [],
+    compositions: [
+        {
+            id: 'my-comp',
+            durationInFrames: 1000000,
+            // @ts-expect-error
+            component: Comp,
+            defaultProps: {},
+            folderName: null,
+            fps: 30,
+            height: 1080,
+            width: 1080,
+            parentFolderName: null,
+            nonce: 0,
+            calculateMetadata: null,
+        },
+    ],
+    folders: [],
+    registerComposition: () => undefined,
+    registerFolder: () => undefined,
+    unregisterComposition: () => undefined,
+    unregisterFolder: () => undefined,
+    canvasContent: { type: 'composition', compositionId: 'my-comp' },
+};
+export const WrapSequenceContext = ({ children }) => {
+    return (_jsx(CanUseRemotionHooksProvider, { children: _jsx(CompositionManager.Provider, { value: mockCompositionContext, children: _jsx(ResolveCompositionConfig, { children: children }) }) }));
+};