Skip to content

🎥 Make videos programmatically with React

8.1 KB
Raw Blame
import {expect, test} from 'bun:test';
import {parseDragData} from '../drag-data';
import {setStudioDragData} from '../drag-transport';
import {parseElementDragData, staticFileRef} from '../element-drag-data';
import {
	createElementPayload,
	parseStudioElementPayload,
	type CreateElementPayloadInput,
} from '../element-payload';

const validInput = {
	dependencies: [
		{name: '@remotion/google-fonts', version: null},
		{name: 'lodash', version: '4.17.21'},
		{name: '@remotion/google-fonts', version: null},
	],
	dimensions: {width: 800, height: 200},
	displayName: 'Lower Third',
	durationInFrames: 90,
	initialProps: {
		captions: [{text: 'Hello', startMs: 0, endMs: 1000}],
		style: {color: 'red'},
	},
	slug: 'lower-third',
	sourceCode: 'export const LowerThird = () => null;',
	installationMode: 'component-owned-sequence',
} satisfies CreateElementPayloadInput;

const createInvalidPayload = (input: unknown) =>
	// @ts-expect-error Exercise runtime validation of invalid JavaScript inputs.
	createElementPayload(input);

test('creates one canonical Element payload for HTTP and drag transports', () => {
	const payload = createElementPayload(validInput);
	expect(payload).toEqual({
		type: 'remotion-element',
		version: 1,
		durationInFrames: 90,
		element: {
			assets: [],
			dependencies: [
				{name: '@remotion/google-fonts', version: null},
				{name: 'lodash', version: '4.17.21'},
			],
			dimensions: {width: 800, height: 200},
			displayName: 'Lower Third',
			durationInFrames: 90,
			initialProps: {
				captions: [{text: 'Hello', startMs: 0, endMs: 1000}],
				style: {color: 'red'},
			},
			installationMode: 'component-owned-sequence',
			slug: 'lower-third',
			sourceCode: 'export const LowerThird = () => null;',
		},
	});
	expect(parseStudioElementPayload(payload)).toEqual(payload);

	const data = new Map<string, string>();

	const dataTransfer: Pick<DataTransfer, 'effectAllowed' | 'setData'> = {
		effectAllowed: 'none',
		setData: (type: string, value: string) => data.set(type, value),
	};

	setStudioDragData({dataTransfer, payload});

	expect(dataTransfer.effectAllowed).toBe('copy');

	const mimeType =
		'application/vnd.remotion.drag+json;v=1;type=element;width=800;height=200;duration=90';

	expect([...data.keys()]).toEqual([mimeType, 'text/plain']);
	expect(data.get('text/plain')).toBe(data.get(mimeType));
	expect(parseDragData({mimeType, payload: data.get(mimeType)!})).toMatchObject(
		{
			type: 'element',
			data: {
				element: {
					displayName: 'Lower Third',
					installationMode: 'component-owned-sequence',
				},
			},
			preview: {width: 800, height: 200, durationInFrames: 90},
		},
	);
});

test('validates asset payloads and references for both transports', () => {
	const payload = createElementPayload({
		...validInput,
		assets: [
			{
				path: 'my-element/logo.png',
				type: 'url',
				url: 'https://example.com/logo.png',
			},
			{path: 'my-element/data.json', type: 'base64', data: 'eyJvayI6dHJ1ZX0='},
		],
		initialProps: {media: [{src: staticFileRef('my-element/logo.png')}]},
	});

	const serialized = JSON.stringify(payload);
	expect(payload.version).toBe(2);
	expect(parseStudioElementPayload(JSON.parse(serialized))).toEqual(payload);
	expect(parseElementDragData(serialized)?.element).toEqual(payload.element);
	expect(parseStudioElementPayload({...payload, version: 1})).toBe(null);

	for (const assets of [
		[{path: '../logo.png', type: 'base64', data: 'AA=='}],
		[{path: 'logo.png', type: 'base64', data: 'not base64'}],
		[{path: 'logo.png', type: 'url', url: 'file:///logo.png'}],
		[
			{path: 'nested', type: 'base64', data: 'AA=='},
			{path: 'nested/logo.png', type: 'base64', data: 'AA=='},
		],
	] as const) {
		expect(() => createInvalidPayload({...validInput, assets})).toThrow();
	}

	for (const path of ['', '../logo.png', '/logo.png']) {
		expect(() => staticFileRef(path)).toThrow();
	}

	for (const ref of [
		staticFileRef('missing.png'),
		{__remotion_element_asset: '../logo.png'},
		{__remotion_element_asset: 123},
		{__remotion_element_asset: 'my-element/logo.png', extra: true},
	]) {
		const initialProps = {media: [{src: ref}]};
		expect(() =>
			createElementPayload({
				...validInput,
				assets: payload.element.assets,
				initialProps,
			}),
		).toThrow();
		const tampered = {...payload, element: {...payload.element, initialProps}};
		expect(parseStudioElementPayload(tampered)).toBeNull();
		expect(parseElementDragData(JSON.stringify(tampered))).toBeNull();
	}
});

test('defaults new Element payloads to wrapped installation', () => {
	const {installationMode: _installationMode, ...input} = validInput;
	const payload = createElementPayload(input);
	expect(payload.element.installationMode).toBe('wrapped');
});

test('normalizes legacy payloads without initial props or assets', () => {
	const payload = createElementPayload(validInput);

	const {
		initialProps: _initialProps,
		assets: _assets,
		...legacyElement
	} = payload.element;

	expect(
		parseStudioElementPayload({...payload, element: legacyElement}),
	).toMatchObject({version: 1, element: {initialProps: null, assets: []}});
});

test('rejects invalid and reserved initial props', () => {
	for (const initialProps of [
		{invalid: undefined},
		{invalid: Number.NaN},
		{'not-an-attribute': true},
		{captions: () => undefined},
		{from: 10},
		{style: 'color: red'},
	]) {
		expect(() => createInvalidPayload({...validInput, initialProps})).toThrow(
			/initialProps|initial props/,
		);
	}

	const payload = createElementPayload(validInput);

	for (const initialProps of [
		{invalid: undefined},
		{invalid: Number.NaN},
		{'not-an-attribute': true},
		{captions: () => undefined},
		{durationInFrames: 10},
		{style: 'color: red'},
	]) {
		expect(
			parseStudioElementPayload({
				...payload,
				element: {...payload.element, initialProps},
			}),
		).toBe(null);
	}
});

test('rejects an invalid installation mode from Studio payloads', () => {
	const payload = createElementPayload(validInput);
	expect(
		parseStudioElementPayload({
			...payload,
			element: {...payload.element, installationMode: 'no'},
		}),
	).toBe(null);
});

test('rejects invalid Element authoring input with actionable errors', () => {
	const cases: Array<{input: unknown; message: string}> = [
		{
			input: {...validInput, slug: '../unsafe'},
			message: 'slug must be a safe lowercase Element slug',
		},
		{
			input: {
				...validInput,
				sourceCode:
					'export const First = () => null; export const Second = () => null;',
			},
			message:
				'sourceCode must contain exactly one exported named React component',
		},
		{
			input: {...validInput, dependencies: ['@remotion/google-fonts']},
			message: 'Invalid Element dependency: "@remotion/google-fonts"',
		},
		{
			input: {
				...validInput,
				dependencies: [{name: 'lodash', version: null}],
			},
			message:
				'Non-Remotion Element dependency "lodash" must declare an exact version.',
		},
		{
			input: {
				...validInput,
				dependencies: [{name: 'lodash', version: '^4.17.21'}],
			},
			message:
				'Non-Remotion Element dependency "lodash" must declare an exact version.',
		},
		{
			input: {
				...validInput,
				dependencies: [{name: 'lodash', version: 'latest'}],
			},
			message:
				'Non-Remotion Element dependency "lodash" must declare an exact version.',
		},
		{
			input: {
				...validInput,
				dependencies: [{name: '@remotion/effects', version: '4.0.0'}],
			},
			message:
				'Remotion Element dependency "@remotion/effects" must use version: null.',
		},
		{
			input: {
				...validInput,
				dependencies: [{name: 'react', version: '19.0.0'}],
			},
			message:
				'"react" is provided by Remotion projects and must not be declared as an Element dependency.',
		},
		{
			input: {...validInput, dimensions: {width: 0, height: 200}},
			message: 'width and height must be numbers between 0 and 100000',
		},
		{
			input: {...validInput, durationInFrames: 0},
			message: 'durationInFrames must be an integer between 1 and 100000000',
		},
		{
			input: {...validInput, installationMode: 'no'},
			message:
				'installationMode must be "wrapped" or "component-owned-sequence"',
		},
	];

	for (const {input, message} of cases) {
		expect(() => createInvalidPayload(input)).toThrow(message);
	}
});