remotion 4.0.199 → 4.0.201

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/audio-for-rendering.test.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @vitest-environment jsdom
+ */
+import { render } from '@testing-library/react';
+import { beforeEach, describe, expect, test, vitest } from 'vitest';
+import { AudioForRendering } from '../audio/AudioForRendering.js';
+import { CanUseRemotionHooksProvider } from '../CanUseRemotionHooks.js';
+import { CompositionManager } from '../CompositionManagerContext.js';
+import { RenderAssetManager } from '../RenderAssetManager.js';
+import { ResolveCompositionConfig } from '../ResolveCompositionConfig.js';
+import { expectToThrow } from './expect-to-throw.js';
+import { mockCompositionContext } from './wrap-sequence-context.js';
+let mockContext;
+describe('Register and unregister asset', () => {
+    function createMockContext() {
+        const registerRenderAsset = vitest.fn();
+        const unregisterRenderAsset = vitest.fn();
+        window.remotion_audioEnabled = true;
+        const MockProvider = ({ children }) => {
+            return (_jsx(CanUseRemotionHooksProvider, { children: _jsx(CompositionManager.Provider, { value: mockCompositionContext, children: _jsx(RenderAssetManager.Provider
+                    // eslint-disable-next-line react/jsx-no-constructed-context-values
+                    , { 
+                        // eslint-disable-next-line react/jsx-no-constructed-context-values
+                        value: {
+                            registerRenderAsset,
+                            unregisterRenderAsset,
+                            renderAssets: [],
+                        }, children: _jsx(ResolveCompositionConfig, { children: children }) }) }) }));
+        };
+        return {
+            MockProvider,
+            registerRenderAsset,
+            unregisterRenderAsset,
+        };
+    }
+    beforeEach(() => {
+        mockContext = createMockContext();
+    });
+    test('register and unregister asset', () => {
+        const props = {
+            src: 'test',
+            muted: false,
+            volume: 50,
+            onDuration: vitest.fn(),
+        };
+        const { unmount } = render(_jsx(CanUseRemotionHooksProvider, { children: _jsx(mockContext.MockProvider, { children: _jsx(AudioForRendering, { ...props }) }) }));
+        expect(mockContext.registerRenderAsset).toHaveBeenCalled();
+        unmount();
+        expect(mockContext.unregisterRenderAsset).toHaveBeenCalled();
+    });
+    test('no src passed', () => {
+        const props = {
+            src: undefined,
+            muted: false,
+            volume: 50,
+            onDuration: vitest.fn(),
+        };
+        expectToThrow(() => {
+            render(_jsx(CanUseRemotionHooksProvider, { children: _jsx(mockContext.MockProvider, { children: _jsx(AudioForRendering, { ...props }) }) }));
+        }, /No src passed/);
+        expect(mockContext.registerRenderAsset).not.toHaveBeenCalled();
+        expect(mockContext.unregisterRenderAsset).not.toHaveBeenCalled();
+    });
+});

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

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

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

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @vitest-environment jsdom
+ */
+import { render } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+import { Audio } from '../audio/index.js';
+import { WrapSequenceContext } from './wrap-sequence-context.js';
+describe('Render correctly with props', () => {
+    test('It should render Audio without startFrom / endAt props', () => {
+        expect(() => render(_jsx(WrapSequenceContext, { children: _jsx(Audio, { src: "test", volume: 1 }) }))).not.toThrow();
+    });
+    test('It should render Audio with startAt  props', () => {
+        expect(() => render(_jsx(WrapSequenceContext, { children: _jsx(Audio, { src: "test", volume: 1, startFrom: 10 }) }))).not.toThrow();
+    });
+    test('It should render Audio with endAt props', () => {
+        expect(() => render(_jsx(WrapSequenceContext, { children: _jsx(Audio, { src: "test", volume: 1, endAt: 10 }) }))).not.toThrow();
+    });
+    test('It should render Audio with startFrom and endAt props', () => {
+        expect(() => render(_jsx(WrapSequenceContext, { children: _jsx(Audio, { src: "test", volume: 1, startFrom: 10, endAt: 20 }) }))).not.toThrow();
+    });
+    test('It should render Audio with loop, startFrom and endAt props', () => {
+        expect(() => render(_jsx(WrapSequenceContext, { children: _jsx(Audio, { src: "test", volume: 1, startFrom: 10, endAt: 20, loop: true }) }))).not.toThrow();
+    });
+});

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

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

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

@@ -0,0 +1,50 @@
+import { expect, test } from 'vitest';
+import { bezier } from '../bezier.js';
+const identity = (x) => {
+    return x;
+};
+const assertClose = (a, b, precision = 3) => {
+    expect(a).toBeCloseTo(b, precision);
+};
+const allEquals = (be1, be2, samples) => {
+    for (let i = 0; i <= samples; ++i) {
+        const x = i / samples;
+        assertClose(be1(x), be2(x));
+    }
+};
+function repeat(n) {
+    return function (f) {
+        for (let i = 0; i < n; ++i) {
+            f();
+        }
+    };
+}
+test('bezier - should create an object', () => {
+    expect(typeof bezier(0, 0, 1, 1) === 'function').toBe(true);
+});
+test('bezier - fail with wrong params', () => {
+    const valuesToTest = [
+        [0.5, 0.5, -5, 0.5],
+        [0.5, 0.5, 5, 0.5],
+        [-2, 0.5, 0.5, 0.5],
+        [2, 0.5, 0.5, 0.5],
+    ];
+    valuesToTest.forEach((entry) => {
+        expect(() => bezier(entry[0], entry[1], entry[2], entry[3])).toThrow();
+    });
+});
+test('bezier - linear curves', () => {
+    allEquals(bezier(0, 0, 1, 1), bezier(1, 1, 0, 0), 100);
+    allEquals(bezier(0, 0, 1, 1), identity, 100);
+});
+test('bezier - right value at extremes', () => {
+    repeat(10)(() => {
+        const a = Math.random();
+        const b = 2 * Math.random() - 0.5;
+        const c = Math.random();
+        const d = 2 * Math.random() - 0.5;
+        const easing = bezier(a, b, c, d);
+        expect(easing(0)).toBe(0);
+        expect(easing(1)).toBe(1);
+    });
+});

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

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/composition-rules.test.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @vitest-environment jsdom
+ */
+import { render } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+import { Composition } from '../Composition.js';
+import { RemotionRoot } from '../RemotionRoot.js';
+import { expectToThrow } from './expect-to-throw.js';
+const AnyComp = () => null;
+describe('Render composition-rules should throw with invalid props', () => {
+    test('It should report invalid component id', () => {
+        expectToThrow(() => render(_jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 30, height: 100, id: "invalid@id", width: 100 })), /can only contain/);
+    });
+    test('It should throw if no id is passed', () => {
+        expectToThrow(() => render(
+        // @ts-expect-error
+        _jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 30, height: 100, width: 100 })), /No id for composition passed./);
+    });
+    test('It should throw if multiple components have the same id', () => {
+        expectToThrow(() => render(_jsxs(RemotionRoot, { numberOfAudioTags: 0, children: [_jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 30, height: 100, width: 100, id: "id" }), _jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 30, height: 100, width: 100, id: "id" })] })), /Multiple composition with id id/);
+    });
+});
+describe('Render composition-rules should not with valid props', () => {
+    test('It should validate the component id', () => {
+        expect(() => render(_jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 30, height: 100, id: "valid-id", width: 100 }))).not.toThrow();
+    });
+});

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

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

package/.rollup.cache/Users/jonathanburger/remotion/packages/core/dist/esm/test/composition-validation.test.js

@@ -0,0 +1,310 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * @vitest-environment jsdom
+ */
+import { render } from '@testing-library/react';
+import { describe, expect, test } from 'vitest';
+import { Composition } from '../Composition.js';
+import { resolveVideoConfig } from '../resolve-video-config.js';
+import { expectToThrow } from './expect-to-throw.js';
+const AnyComp = () => null;
+describe('Composition-validation render should throw with invalid props', () => {
+    test('It should throw if multiple components have the same id', () => {
+        expectToThrow(() => resolveVideoConfig({
+            composition: {
+                durationInFrames: 100,
+                calculateMetadata: null,
+                fps: 30,
+                height: 100,
+                id: 'id',
+                width: undefined,
+                defaultProps: {},
+            },
+            editorProps: {},
+            signal: new AbortController().signal,
+            inputProps: {},
+        }), /The "width" prop of the "<Composition \/>" component with the id "id" must be a number, but you passed a value of type undefined/);
+    });
+    describe('Throw with invalid height props', () => {
+        test('It should throw if height is a negative number', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 100,
+                    calculateMetadata: null,
+                    fps: 30,
+                    height: -100,
+                    id: 'id',
+                    width: 100,
+                    defaultProps: {},
+                },
+                inputProps: {},
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "height" prop of the "<Composition \/>" component with the id "id" must be positive, but got -100./);
+        });
+        test('It should throw if height=0 is boundary off-point', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 100,
+                    calculateMetadata: null,
+                    fps: 30,
+                    height: 0,
+                    id: 'id',
+                    width: 100,
+                },
+                inputProps: {},
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "height" prop of the "<Composition \/>" component with the id "id" must be positive, but got 0./);
+        });
+        test('It should throw if height is not a number', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 100,
+                    calculateMetadata: null,
+                    fps: 30,
+                    // @ts-expect-error
+                    height: '100',
+                    id: 'id',
+                    width: 100,
+                    defaultProps: {},
+                },
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "height" prop of the "<Composition \/>" component with the id "id" must be a number, but you passed a value of type string/);
+        });
+        test('It should throw if height is not an integer', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 100,
+                    calculateMetadata: null,
+                    fps: 30,
+                    height: 100.01,
+                    id: 'id',
+                    width: 100,
+                    defaultProps: {},
+                },
+                inputProps: {},
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "height" prop of the "<Composition \/>" component with the id "id" must be an integer, but is 100.01./);
+        });
+    });
+    describe('Throw with invalid width props', () => {
+        test('It should throw if width is a negative number', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 100,
+                    calculateMetadata: null,
+                    fps: 30,
+                    height: 100,
+                    id: 'id',
+                    width: -100,
+                    defaultProps: {},
+                },
+                inputProps: {},
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "width" prop of the "<Composition \/>" component with the id "id" must be positive, but got -100./);
+        });
+        test('It should throw if width=0 is boundary off-point', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 100,
+                    calculateMetadata: null,
+                    fps: 30,
+                    height: 100,
+                    id: 'id',
+                    width: 0,
+                    defaultProps: {},
+                },
+                inputProps: {},
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "width" prop of the "<Composition \/>" component with the id "id" must be positive, but got 0./);
+        });
+        test('It should throw if width is not a number', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 100,
+                    calculateMetadata: null,
+                    fps: 30,
+                    height: 100,
+                    id: 'id',
+                    // @ts-expect-error
+                    width: '100',
+                    defaultProps: {},
+                },
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "width" prop of the "<Composition \/>" component with the id "id" must be a number, but you passed a value of type string/);
+        });
+    });
+    describe('Throw with invalid durationInFrames', () => {
+        test('It should throw if durationInFrames of a composition is a negative number', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: -100,
+                    calculateMetadata: null,
+                    fps: 30,
+                    height: 100,
+                    id: 'id',
+                    width: 100,
+                    defaultProps: {},
+                },
+                inputProps: {},
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "durationInFrames" prop of the "<Composition \/>" component with the id "id" must be positive, but got -100./);
+        });
+        test('It should throw if durationInFrames=0 of a composition is boundary off-point', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 0,
+                    calculateMetadata: null,
+                    fps: 30,
+                    height: 100,
+                    id: 'id',
+                    width: 100,
+                    defaultProps: {},
+                },
+                inputProps: {},
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "durationInFrames" prop of the "<Composition \/>" component with the id "id" must be positive, but got 0./);
+        });
+        test('It should throw if durationInFrames of a composition is not an integer', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 0.11,
+                    calculateMetadata: null,
+                    fps: 30,
+                    height: 100,
+                    id: 'id',
+                    width: 100,
+                    defaultProps: {},
+                },
+                inputProps: {},
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "durationInFrames" prop of the "<Composition \/>" component with the id "id" must be an integer, but got 0.11./);
+        });
+        test('It should throw if durationInFrames of a composition is not a number', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    // @ts-expect-error
+                    durationInFrames: '100',
+                    calculateMetadata: null,
+                    fps: 30,
+                    height: 100,
+                    id: 'id',
+                    width: 100,
+                    defaultProps: {},
+                },
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /The "durationInFrames" prop of the "<Composition \/>" component with the id "id" must be a number, but you passed a value of type string/);
+        });
+    });
+    describe('Throw with invalid fps', () => {
+        test('It should throw if fps is of a composition is negative', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 100,
+                    calculateMetadata: null,
+                    fps: -30,
+                    height: 100,
+                    id: 'id',
+                    width: 100,
+                    defaultProps: {},
+                },
+                inputProps: {},
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /"fps" must be positive, but got -30./);
+        });
+        test('It should throw if fps=0 of a composition is boundary off-point', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 100,
+                    calculateMetadata: null,
+                    fps: 0,
+                    height: 100,
+                    id: 'id',
+                    width: 100,
+                    defaultProps: {},
+                },
+                inputProps: {},
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /"fps" must be positive, but got 0./);
+        });
+        test('It should throw if fps of a composition is not a number', () => {
+            expectToThrow(() => resolveVideoConfig({
+                composition: {
+                    durationInFrames: 100,
+                    calculateMetadata: null,
+                    // @ts-expect-error
+                    fps: '30',
+                    height: 100,
+                    id: 'id',
+                    width: 100,
+                    defaultProps: {},
+                },
+                editorProps: {},
+                signal: new AbortController().signal,
+            }), /"fps" must be a number, but you passed a value of type string/);
+        });
+    });
+});
+describe('Composition-validation render should NOT throw with valid props', () => {
+    describe('Not throw with valid height props', () => {
+        test('It should not throw if height is a positive number', () => {
+            expect(() => render(_jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 30, height: 100, width: 100, id: "id" }))).not.toThrow();
+        });
+        test('It should not throw if height=1 is boundary on-point', () => {
+            expect(() => render(_jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 30, height: 1, width: 100, id: "id" }))).not.toThrow();
+        });
+    });
+    describe('Not throw with valid width props', () => {
+        test('It should not throw if width is a positive number', () => {
+            expect(() => render(_jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 30, height: 100, width: 100, id: "id" }))).not.toThrow();
+        });
+        test('It should not throw if width=1 is boundary on-point', () => {
+            expect(() => render(_jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 30, height: 100, width: 1, id: "id" }))).not.toThrow();
+        });
+    });
+    test('It should not throw if durationInFrames=1 of a composition is boundary on-point', () => {
+        expect(() => render(_jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 1, fps: 30, height: 100, width: 100, id: "id" }))).not.toThrow();
+    });
+    test('It should not throw if fps=1 of a composition is boundary on-point', () => {
+        expect(() => render(_jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 1, height: 100, width: 100, id: "id" }))).not.toThrow();
+    });
+    test('It should not allow an array as default props', () => {
+        expectToThrow(() => render(_jsx(Composition, { lazyComponent: () => Promise.resolve({ default: AnyComp }), durationInFrames: 100, fps: 1, height: 100, width: 100, id: "id", defaultProps: [] })), /"defaultProps" must be an object, an array was passed for composition "id"/);
+    });
+});
+test('should resolve props correctly with no calculateMetadata()', async () => {
+    const resolved = await resolveVideoConfig({
+        composition: {
+            calculateMetadata: null,
+            durationInFrames: 100,
+            fps: 30,
+            height: 1080,
+            id: 'test',
+            width: 1920,
+            defaultProps: {
+                a: 'b',
+            },
+        },
+        editorProps: {},
+        inputProps: {
+            c: 'd',
+        },
+        signal: new AbortController().signal,
+    });
+    expect(resolved.props).toEqual({
+        a: 'b',
+        c: 'd',
+    });
+});

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

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