Skip to content

🎥 Make videos programmatically with React

21.7 KB
Raw Blame
import {expect, spyOn, test} from 'bun:test';
import {
	existsSync,
	mkdtempSync,
	readFileSync,
	rmSync,
	writeFileSync,
} from 'node:fs';
import {tmpdir} from 'node:os';
import path from 'node:path';
import {renameFolder, updateCompositionMetadata} from '@remotion/codemods';
import type {
	CompositionEditResponse,
	SymbolicatedStackFrame,
	UndoRedoNavigation,
} from '@remotion/studio-shared';
import {
	createFileWatcherRegistry,
	setFileWatcherRegistry,
} from '../file-watcher';
import type {ApiHandler} from '../preview-server/api-types';
import {setLiveEventsListener} from '../preview-server/live-events';
import {addCompositionHandler} from '../preview-server/routes/add-composition';
import {addFolderHandler} from '../preview-server/routes/add-folder';
import {applyVisualControlHandler} from '../preview-server/routes/apply-visual-control-change';
import {deleteCompositionHandler} from '../preview-server/routes/delete-composition';
import {duplicateCompositionHandler} from '../preview-server/routes/duplicate-composition';
import {moveCompositionHandler} from '../preview-server/routes/move-composition';
import {redoHandler} from '../preview-server/routes/redo';
import {renameCompositionHandler} from '../preview-server/routes/rename-composition';
import {undoHandler} from '../preview-server/routes/undo';
import {getRedoStack, getUndoStack} from '../preview-server/undo-stack';

const rootContents = `import React from 'react';
import {Composition} from 'remotion';

const Component = () => null;

export const RemotionRoot: React.FC = () => {
	return (
		<>
			<Composition
				id="DeleteMe"
				component={Component}
				durationInFrames={120}
				fps={30}
				width={1280}
				height={720}
			/>
			<Composition
				id="KeepMe"
				component={Component}
				durationInFrames={120}
				fps={30}
				width={1280}
				height={720}
			/>
		</>
	);
};
`;

const folderRootContents = `import React from 'react';
import {Composition, Folder} from 'remotion';

const Component = () => null;

export const RemotionRoot: React.FC = () => {
	return (
		<>
			<Folder name="Parent">
				<Folder name="Shared">
					<Composition
						id="NestedA"
						component={Component}
						durationInFrames={120}
						fps={30}
						width={1280}
						height={720}
					/>
				</Folder>
			</Folder>
			<Folder name="Other">
				<Folder name="Shared">
					<Composition
						id="NestedB"
						component={Component}
						durationInFrames={120}
						fps={30}
						width={1280}
						height={720}
					/>
				</Folder>
			</Folder>
		</>
	);
};
`;

const clearUndoRedoStacks = () => {
	(getUndoStack() as unknown as unknown[]).length = 0;
	(getRedoStack() as unknown as unknown[]).length = 0;
};

test('folder edits do not run Prettier after applying source edits', () => {
	const remotionRoot = mkdtempSync(path.join(tmpdir(), 'remotion-codemod-'));
	const filePath = path.join(remotionRoot, 'Root.tsx');
	const input = `import {Folder} from 'remotion';

const untouched  =  { value : "keep" };
export const Root = () => <Folder name="Before" />;
`;

	try {
		writeFileSync(filePath, input);
		const output = renameFolder({
			project: {rootDir: remotionRoot, files: {[filePath]: input}},
			compositionFile: filePath,
			folder: {name: 'Before', parentName: null},
			newName: 'After',
		});

		expect(output.changes[0].nextContents).toBe(
			input.replace('"Before"', '"After"'),
		);
	} finally {
		rmSync(remotionRoot, {recursive: true, force: true});
	}
});

test('metadata edits do not run Prettier after applying source edits', () => {
	const remotionRoot = mkdtempSync(path.join(tmpdir(), 'remotion-codemod-'));
	const filePath = path.join(remotionRoot, 'Root.tsx');
	const input = `import {Composition} from 'remotion';
const untouched  =  { value : "keep" };
export const Root=()=> <Composition id='Comp' width = { WIDTH }/>;
`;

	try {
		writeFileSync(filePath, input);
		const output = updateCompositionMetadata({
			project: {rootDir: remotionRoot, files: {[filePath]: input}},
			compositionFile: filePath,
			compositionId: 'Comp',
			metadata: {
				durationInFrames: 90,
				height: 1080,
				width: 1920,
			},
		});

		expect(output.changes[0].nextContents)
			.toBe(`import {Composition} from 'remotion';
const untouched  =  { value : "keep" };
export const Root=()=> <Composition id='Comp' width = {1920} durationInFrames={90} height={1080}/>;
`);
	} finally {
		rmSync(remotionRoot, {recursive: true, force: true});
	}
});

test('visual-control handler preserves source formatting', async () => {
	const remotionRoot = mkdtempSync(path.join(tmpdir(), 'remotion-codemod-'));
	const cleanupFileWatcher = setFileWatcherRegistry(
		createFileWatcherRegistry(),
	);
	const cleanupLiveEvents = setLiveEventsListener({
		sendEventToClient: () => undefined,
		sendEventToClientId: () => true,
		router: () => Promise.resolve(),
		closeConnections: () => Promise.resolve(),
		addNewClientListener: () => () => undefined,
	});
	const filePath = path.join(remotionRoot, 'Root.tsx');
	const input = `const untouched  =  { value : "keep" };
export const Root=()=> visualControl('opacity', OPACITY);
`;

	try {
		clearUndoRedoStacks();
		writeFileSync(filePath, input);
		const response = await applyVisualControlHandler(
			getHandlerOptions({
				input: {
					fileName: 'Root.tsx',
					changes: [
						{
							id: 'opacity',
							newValueSerialized: '0.5',
							newValueIsUndefined: false,
							enumPaths: [],
						},
					],
				},
				entryPoint: filePath,
				remotionRoot,
			}),
		);

		expect(response.success).toBe(true);
		expect(readFileSync(filePath, 'utf-8')).toBe(
			input.replace('OPACITY', '0.5'),
		);
		expect(getUndoStack()).toHaveLength(1);
	} finally {
		clearUndoRedoStacks();
		cleanupLiveEvents();
		cleanupFileWatcher();
		rmSync(remotionRoot, {recursive: true, force: true});
	}
});

const getHandlerOptions = <T>({
	input,
	entryPoint,
	remotionRoot,
	logLevel = 'error',
}: {
	input: T;
	entryPoint: string;
	remotionRoot: string;
	logLevel?: 'error' | 'info';
}) => ({
	input,
	entryPoint,
	remotionRoot,
	request: {} as never,
	response: {} as never,
	logLevel,
	methods: {
		removeJob: () => undefined,
		cancelJob: () => undefined,
		addJob: () => undefined,
	},
	publicDir: remotionRoot,
	binariesDirectory: null,
	configFile: null,
	getDefaultCodingAgent: () => null,
	getDefaultEditor: () => null,
});

type CompositionEditRequest = {
	symbolicatedStack: SymbolicatedStackFrame | null;
	undoRedoNavigation: UndoRedoNavigation | null;
};

const expectCompositionEditUndoRedo = async <
	Request extends CompositionEditRequest,
>({
	handler,
	request,
	assertApplied,
	expectedUndoMessage,
	expectedLogMessage,
}: {
	handler: ApiHandler<Request, CompositionEditResponse>;
	request: Request;
	assertApplied: (contents: string) => void;
	expectedUndoMessage: string;
	expectedLogMessage: string | null;
}) => {
	const remotionRoot = mkdtempSync(path.join(tmpdir(), 'remotion-codemod-'));
	const cleanupFileWatcher = setFileWatcherRegistry(
		createFileWatcherRegistry(),
	);
	const cleanupLiveEvents = setLiveEventsListener({
		sendEventToClient: () => undefined,
		sendEventToClientId: () => true,
		router: () => Promise.resolve(),
		closeConnections: () => Promise.resolve(),
		addNewClientListener: () => () => undefined,
	});
	const consoleSpy = expectedLogMessage
		? spyOn(console, 'log').mockImplementation(() => undefined)
		: null;

	try {
		clearUndoRedoStacks();
		const entryPoint = path.join(remotionRoot, 'Root.tsx');
		writeFileSync(entryPoint, rootContents);

		const applyResponse = await handler(
			getHandlerOptions({
				input: {
					...request,
					symbolicatedStack: {
						originalFunctionName: null,
						originalFileName: 'Root.tsx',
						originalLineNumber: 9,
						originalColumnNumber: 4,
						originalScriptCode: null,
					},
				},
				entryPoint,
				remotionRoot,
				logLevel: expectedLogMessage ? 'info' : 'error',
			}),
		);

		expect(applyResponse.success).toBe(true);
		assertApplied(readFileSync(entryPoint, 'utf-8'));
		expect(getUndoStack().length).toBe(1);
		expect(getUndoStack()[0].description.undoMessage).toBe(expectedUndoMessage);
		expect(getRedoStack().length).toBe(0);
		if (expectedLogMessage) {
			const logOutput = consoleSpy?.mock.calls.flat().join(' ');
			expect(logOutput).toContain('Root.tsx:9');
			expect(logOutput).toContain(expectedLogMessage);
			expect(logOutput).not.toMatch(/\[\d+ms\]/);
		}

		const undoResponse = await undoHandler(
			getHandlerOptions({input: {}, entryPoint, remotionRoot}),
		);
		expect(undoResponse.success).toBe(true);
		expect(readFileSync(entryPoint, 'utf-8')).toBe(rootContents);
		expect(getUndoStack().length).toBe(0);
		expect(getRedoStack().length).toBe(1);

		const redoResponse = await redoHandler(
			getHandlerOptions({input: {}, entryPoint, remotionRoot}),
		);
		expect(redoResponse.success).toBe(true);
		assertApplied(readFileSync(entryPoint, 'utf-8'));
		expect(getUndoStack().length).toBe(1);
		expect(getRedoStack().length).toBe(0);
	} finally {
		clearUndoRedoStacks();
		cleanupLiveEvents();
		cleanupFileWatcher();
		consoleSpy?.mockRestore();
		rmSync(remotionRoot, {recursive: true, force: true});
	}
};

test('deleteCompositionHandler pushes composition deletions to undo and redo stacks', async () => {
	await expectCompositionEditUndoRedo({
		handler: deleteCompositionHandler,
		request: {
			idToDelete: 'DeleteMe',
			undoRedoNavigation: null,
			symbolicatedStack: null,
		},
		assertApplied: (contents) => {
			expect(contents).not.toContain('id="DeleteMe"');
			expect(contents).toContain('id="KeepMe"');
		},
		expectedUndoMessage: '↩️  Deletion of composition "DeleteMe"',
		expectedLogMessage: null,
	});
});

test('renameCompositionHandler logs composition renames and pushes them to the undo and redo stacks', async () => {
	await expectCompositionEditUndoRedo({
		handler: renameCompositionHandler,
		request: {
			idToRename: 'DeleteMe',
			newId: 'Renamed',
			undoRedoNavigation: null,
			symbolicatedStack: null,
		},
		assertApplied: (contents) => {
			expect(contents).not.toContain('id="DeleteMe"');
			expect(contents).toContain('id="Renamed"');
			expect(contents).toContain('id="KeepMe"');
		},
		expectedUndoMessage: '↩️  Rename of composition "DeleteMe" to "Renamed"',
		expectedLogMessage: 'Renamed composition "DeleteMe" to "Renamed"',
	});
});

test('duplicateCompositionHandler pushes composition and still duplications to undo and redo stacks', async () => {
	for (const tag of ['Composition', 'Still'] as const) {
		await expectCompositionEditUndoRedo({
			handler: duplicateCompositionHandler,
			request: {
				idToDuplicate: 'DeleteMe',
				newId: 'Duplicated',
				newDurationInFrames: 120,
				newFps: 30,
				newHeight: null,
				newWidth: null,
				tag,
				undoRedoNavigation: null,
				symbolicatedStack: null,
			},
			assertApplied: (contents) => {
				expect(contents).toContain('id="DeleteMe"');
				expect(contents).toContain('id="Duplicated"');
				expect(contents).toContain('id="KeepMe"');
				if (tag === 'Still') {
					const still = contents.match(/<Still[\s\S]*?\/>/)?.[0];
					expect(still).toContain('id="Duplicated"');
					expect(still).not.toContain('fps=');
					expect(still).not.toContain('durationInFrames=');
				}
			},
			expectedUndoMessage:
				'↩️  Duplication of composition "DeleteMe" to "Duplicated"',
			expectedLogMessage: null,
		});
	}
});

test('addFolderHandler pushes folder creations to undo and redo stacks', async () => {
	await expectCompositionEditUndoRedo({
		handler: addFolderHandler,
		request: {
			folderName: 'FreshFolder',
			parentName: null,
			undoRedoNavigation: null,
			symbolicatedStack: null,
		},
		assertApplied: (contents) => {
			expect(contents).toContain('<Folder name="FreshFolder" />');
			expect(contents).toContain('id="KeepMe"');
		},
		expectedUndoMessage: '↩️  Creation of folder "FreshFolder"',
		expectedLogMessage: null,
	});
});

test('moveCompositionHandler pushes composition moves to undo and redo stacks', async () => {
	const remotionRoot = mkdtempSync(path.join(tmpdir(), 'remotion-codemod-'));
	const cleanupFileWatcher = setFileWatcherRegistry(
		createFileWatcherRegistry(),
	);
	const cleanupLiveEvents = setLiveEventsListener({
		sendEventToClient: () => undefined,
		sendEventToClientId: () => true,
		router: () => Promise.resolve(),
		closeConnections: () => Promise.resolve(),
		addNewClientListener: () => () => undefined,
	});

	try {
		clearUndoRedoStacks();
		const entryPoint = path.join(remotionRoot, 'Root.tsx');
		writeFileSync(entryPoint, folderRootContents);

		const applyResponse = await moveCompositionHandler(
			getHandlerOptions({
				input: {
					compositionId: 'NestedA',
					destination: {
						type: 'folder',
						folderName: 'Shared',
						parentName: 'Other',
					},
					undoRedoNavigation: null,
					symbolicatedStack: {
						originalFunctionName: null,
						originalFileName: 'Root.tsx',
						originalLineNumber: 9,
						originalColumnNumber: 4,
						originalScriptCode: null,
					},
				},
				entryPoint,
				remotionRoot,
			}),
		);

		expect(applyResponse.success).toBe(true);
		if (!applyResponse.success) {
			throw new Error(applyResponse.reason);
		}

		expect(applyResponse.nodePathMutation).not.toBeNull();
		const contents = readFileSync(entryPoint, 'utf-8');
		expect(contents.indexOf('id="NestedB"')).toBeLessThan(
			contents.indexOf('id="NestedA"'),
		);
		expect(getUndoStack()[0].description.undoMessage).toBe(
			'↩️  Move of composition "NestedA"',
		);

		const undoResponse = await undoHandler(
			getHandlerOptions({input: {}, entryPoint, remotionRoot}),
		);
		expect(undoResponse.success).toBe(true);
		expect(readFileSync(entryPoint, 'utf-8')).toBe(folderRootContents);
	} finally {
		clearUndoRedoStacks();
		cleanupLiveEvents();
		cleanupFileWatcher();
		rmSync(remotionRoot, {recursive: true, force: true});
	}
});

test('moveCompositionHandler pushes composition moves to root to undo and redo stacks', async () => {
	const remotionRoot = mkdtempSync(path.join(tmpdir(), 'remotion-codemod-'));
	const cleanupFileWatcher = setFileWatcherRegistry(
		createFileWatcherRegistry(),
	);
	const cleanupLiveEvents = setLiveEventsListener({
		sendEventToClient: () => undefined,
		sendEventToClientId: () => true,
		router: () => Promise.resolve(),
		closeConnections: () => Promise.resolve(),
		addNewClientListener: () => () => undefined,
	});

	try {
		clearUndoRedoStacks();
		const entryPoint = path.join(remotionRoot, 'Root.tsx');
		writeFileSync(entryPoint, folderRootContents);

		const applyResponse = await moveCompositionHandler(
			getHandlerOptions({
				input: {
					compositionId: 'NestedA',
					destination: {type: 'root'},
					undoRedoNavigation: null,
					symbolicatedStack: {
						originalFunctionName: null,
						originalFileName: 'Root.tsx',
						originalLineNumber: 9,
						originalColumnNumber: 4,
						originalScriptCode: null,
					},
				},
				entryPoint,
				remotionRoot,
			}),
		);

		expect(applyResponse.success).toBe(true);
		if (!applyResponse.success) {
			throw new Error(applyResponse.reason);
		}

		expect(applyResponse.nodePathMutation).not.toBeNull();
		const contents = readFileSync(entryPoint, 'utf-8');
		expect(contents.indexOf('id="NestedB"')).toBeLessThan(
			contents.indexOf('id="NestedA"'),
		);
		expect(getUndoStack()[0].description.undoMessage).toBe(
			'↩️  Move of composition "NestedA"',
		);

		const undoResponse = await undoHandler(
			getHandlerOptions({input: {}, entryPoint, remotionRoot}),
		);
		expect(undoResponse.success).toBe(true);
		expect(readFileSync(entryPoint, 'utf-8')).toBe(folderRootContents);
	} finally {
		clearUndoRedoStacks();
		cleanupLiveEvents();
		cleanupFileWatcher();
		rmSync(remotionRoot, {recursive: true, force: true});
	}
});

test('addCompositionHandler creates new composition files with undo and redo', async () => {
	const remotionRoot = mkdtempSync(path.join(tmpdir(), 'remotion-codemod-'));
	const cleanupFileWatcher = setFileWatcherRegistry(
		createFileWatcherRegistry(),
	);
	const cleanupLiveEvents = setLiveEventsListener({
		sendEventToClient: () => undefined,
		sendEventToClientId: () => true,
		router: () => Promise.resolve(),
		closeConnections: () => Promise.resolve(),
		addNewClientListener: () => () => undefined,
	});

	try {
		clearUndoRedoStacks();
		const entryPoint = path.join(remotionRoot, 'Root.tsx');
		const componentFile = path.join(remotionRoot, 'FreshVideo.tsx');
		writeFileSync(entryPoint, rootContents);

		const applyResponse = await addCompositionHandler(
			getHandlerOptions({
				input: {
					options: {
						asset: null,
						canvasCapture: null,
						newId: 'FreshVideo',
						componentName: 'FreshVideo',
						componentImportPath: './FreshVideo',
						folderName: null,
						parentName: null,
						newDurationInFrames: 150,
						newFps: 30,
						newHeight: 1080,
						newWidth: 1920,
					},
					undoRedoNavigation: null,
					symbolicatedStack: {
						originalFunctionName: null,
						originalFileName: 'Root.tsx',
						originalLineNumber: 9,
						originalColumnNumber: 4,
						originalScriptCode: null,
					},
				},
				entryPoint,
				remotionRoot,
			}),
		);

		expect(applyResponse.success).toBe(true);
		expect(readFileSync(entryPoint, 'utf-8')).toBe(
			"import {FreshVideo} from './FreshVideo';\n" +
				rootContents.replace(
					'\t\t</>',
					[
						'\t\t\t<Composition',
						'\t\t\t\tid="FreshVideo"',
						'\t\t\t\tcomponent={FreshVideo}',
						'\t\t\t\tdurationInFrames={150}',
						'\t\t\t\tfps={30}',
						'\t\t\t\twidth={1920}',
						'\t\t\t\theight={1080}',
						'\t\t\t/>',
						'\t\t</>',
					].join('\n'),
				),
		);
		expect(readFileSync(entryPoint, 'utf-8')).toContain(
			"import {FreshVideo} from './FreshVideo'",
		);
		expect(readFileSync(componentFile, 'utf-8')).toContain(
			'export const FreshVideo',
		);

		const undoResponse = await undoHandler(
			getHandlerOptions({input: {}, entryPoint, remotionRoot}),
		);
		expect(undoResponse.success).toBe(true);
		expect(readFileSync(entryPoint, 'utf-8')).toBe(rootContents);
		expect(existsSync(componentFile)).toBe(false);

		const redoResponse = await redoHandler(
			getHandlerOptions({input: {}, entryPoint, remotionRoot}),
		);
		expect(redoResponse.success).toBe(true);
		expect(readFileSync(entryPoint, 'utf-8')).toContain('id="FreshVideo"');
		expect(readFileSync(componentFile, 'utf-8')).toContain(
			'export const FreshVideo',
		);
	} finally {
		clearUndoRedoStacks();
		cleanupLiveEvents();
		cleanupFileWatcher();
		rmSync(remotionRoot, {recursive: true, force: true});
	}
});

test('addCompositionHandler creates an interactive Canvas Capture composition', async () => {
	const remotionRoot = mkdtempSync(path.join(tmpdir(), 'remotion-codemod-'));
	const cleanupFileWatcher = setFileWatcherRegistry(
		createFileWatcherRegistry(),
	);
	const cleanupLiveEvents = setLiveEventsListener({
		sendEventToClient: () => undefined,
		sendEventToClientId: () => true,
		router: () => Promise.resolve(),
		closeConnections: () => Promise.resolve(),
		addNewClientListener: () => () => undefined,
	});

	try {
		clearUndoRedoStacks();
		const entryPoint = path.join(remotionRoot, 'Root.tsx');
		const componentFile = path.join(remotionRoot, 'FreshCapture.tsx');
		writeFileSync(entryPoint, rootContents);

		const applyResponse = await addCompositionHandler(
			getHandlerOptions({
				input: {
					options: {
						asset: null,
						canvasCapture: {
							videoFileName: 'capture.mp4',
							videoHeight: 1080,
							videoWidth: 1920,
							keyframeFps: 30,
							data: {
								captureMetadata: {density: 2},
								mouseMovements: [
									{
										timeInSeconds: 0,
										canvasX: 10,
										canvasY: 20,
										cursor:
											'url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%2F%3E") 6 7, alias',
									},
									{
										timeInSeconds: 1,
										canvasX: 30,
										canvasY: 40,
										cursor: 'pointer',
									},
								],
								pointerClicks: [
									{timeInSeconds: 0.5, type: 'pointer-down'},
									{timeInSeconds: 0.75, type: 'pointer-up'},
								],
							},
						},
						newId: 'FreshCapture',
						componentName: 'FreshCapture',
						componentImportPath: './FreshCapture',
						folderName: null,
						parentName: null,
						newDurationInFrames: 90,
						newFps: 30,
						newHeight: 720,
						newWidth: 1280,
					},
					undoRedoNavigation: null,
					symbolicatedStack: {
						originalFunctionName: null,
						originalFileName: 'Root.tsx',
						originalLineNumber: 9,
						originalColumnNumber: 4,
						originalScriptCode: null,
					},
				},
				entryPoint,
				remotionRoot,
			}),
		);

		expect(applyResponse.success).toBe(true);
		expect(readFileSync(entryPoint, 'utf-8')).toContain(
			"import {FreshCapture} from './FreshCapture'",
		);
		const rootContentsAfterImport = readFileSync(entryPoint, 'utf-8');
		expect(rootContentsAfterImport).toContain('id="FreshCapture"');
		expect(rootContentsAfterImport).toContain('component={FreshCapture}');
		const componentContents = readFileSync(componentFile, 'utf-8');
		expect(componentContents).toContain(
			"import {MacOSCursor} from '@remotion/mac-cursors'",
		);
		expect(componentContents).toContain('customCursor={');
		expect(componentContents).toContain(
			'url("data:image/svg+xml,%3Csvg%20width%3D%2224%22%2F%3E") 6 7, alias',
		);
		expect(componentContents).toMatch(
			/<Video\s+src=\{staticFile\('capture\.mp4'\)\}\s+durationInFrames=\{90\}/,
		);
		expect(componentContents).toContain('width: 1920');
		expect(componentContents).toContain('height: 1080');
		expect(rootContentsAfterImport).toContain('width={1280}');
		expect(rootContentsAfterImport).toContain('height={720}');

		const undoResponse = await undoHandler(
			getHandlerOptions({input: {}, entryPoint, remotionRoot}),
		);
		expect(undoResponse.success).toBe(true);
		expect(readFileSync(entryPoint, 'utf-8')).toBe(rootContents);
		expect(existsSync(componentFile)).toBe(false);
	} finally {
		clearUndoRedoStacks();
		cleanupLiveEvents();
		cleanupFileWatcher();
		rmSync(remotionRoot, {recursive: true, force: true});
	}
});