Skip to content

🎥 Make videos programmatically with React

61.3 KB
Raw Blame
import {expect, test} from 'bun:test';
import fs from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import {NoReactInternals} from 'remotion/no-react';
import {
	insertJsxElementIntoComposition,
	resolveCompositionComponent,
} from '../helpers/resolve-composition-component';
import {insertCompositionElementHandler} from '../preview-server/routes/insert-composition-element';
import {lineContainingToNodePath} from './test-utils';

const remotionRoot = path.join(__dirname, '..', '..', '..', 'example');

test('resolves a statically imported composition component', async () => {
	const location = await resolveCompositionComponent({
		remotionRoot,
		compositionFile: 'src/E2eTestRoot.tsx',
		compositionId: 'schema-test',
	});

	expect(location.source).toBe(path.join('src', 'SchemaTest', 'index.tsx'));
	expect(location.line).toBe(146);
	expect(location.canAddSequence).toBe(true);
});

test('resolves a lazy imported composition component', async () => {
	const location = await resolveCompositionComponent({
		remotionRoot,
		compositionFile: 'src/Root.tsx',
		compositionId: 'looped',
	});

	expect(location.source).toBe(path.join('src', 'LoopedVideo', 'index.tsx'));
	expect(location.line).toBe(4);
	expect(location.canAddSequence).toBe(true);
});

test('resolves recursively through re-exported composition components', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './components';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.mkdir(path.join(tempDir, 'components', 'inner'), {
			recursive: true,
		});
		await fs.writeFile(
			path.join(tempDir, 'components', 'index.tsx'),
			["export {MyComp} from './inner';", ''].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'components', 'inner', 'index.tsx'),
			["export {MyComp} from './MyComp';", ''].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'components', 'inner', 'MyComp.tsx'),
			[
				'export const MyComp: React.FC = () => {',
				'\treturn <div>hello</div>;',
				'};',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe(
			path.join('components', 'inner', 'MyComp.tsx'),
		);
		expect(location.line).toBe(1);
		expect(location.canAddSequence).toBe(true);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('resolves composition components that are imported and then exported', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {ImportedOne, ImportedTwo, LocalComp} from './Barrel';",
				'export const RemotionRoot = () => {',
				'\treturn <>',
				'\t\t<Composition id="imported-one" component={ImportedOne} />',
				'\t\t<Composition id="imported-two" component={ImportedTwo} />',
				'\t\t<Composition id="local" component={LocalComp} />',
				'\t</>;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'Barrel.tsx'),
			[
				"import {ImportedOne} from './ImportedOne';",
				"import {ImportedTwo as ImportedTwoLocal} from './ImportedTwo';",
				'',
				'export function LocalComp() {',
				'\treturn <div>local</div>;',
				'}',
				'',
				'export {ImportedOne, ImportedTwoLocal as ImportedTwo};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'ImportedOne.tsx'),
			[
				'',
				'export function ImportedOne() {',
				'\treturn <div>one</div>;',
				'}',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'ImportedTwo.tsx'),
			[
				'',
				'',
				'export function ImportedTwo() {',
				'\treturn <div>two</div>;',
				'}',
				'',
			].join('\n'),
		);

		const locations = await Promise.all(
			['imported-one', 'imported-two', 'local'].map((compositionId) =>
				resolveCompositionComponent({
					remotionRoot: tempDir,
					compositionFile: 'Root.tsx',
					compositionId,
				}),
			),
		);

		expect(
			locations.map(({source, line, canAddSequence}) => ({
				source,
				line,
				canAddSequence,
			})),
		).toEqual([
			{source: 'ImportedOne.tsx', line: 2, canAddSequence: true},
			{source: 'ImportedTwo.tsx', line: 3, canAddSequence: true},
			{source: 'Barrel.tsx', line: 4, canAddSequence: true},
		]);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('resolves through fallback re-export branch after cycle', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './components';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.mkdir(path.join(tempDir, 'components', 'valid'), {
			recursive: true,
		});
		await fs.writeFile(
			path.join(tempDir, 'components', 'index.tsx'),
			[
				"export {MyComp} from './cycle-a';",
				"export {MyComp} from './valid';",
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'components', 'cycle-a.tsx'),
			["export {MyComp} from './cycle-b';", ''].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'components', 'cycle-b.tsx'),
			["export {MyComp} from './cycle-a';", ''].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'components', 'valid', 'index.tsx'),
			["export {MyComp} from './MyComp';", ''].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'components', 'valid', 'MyComp.tsx'),
			[
				'export const MyComp: React.FC = () => {',
				'\treturn <div>hello</div>;',
				'};',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe(
			path.join('components', 'valid', 'MyComp.tsx'),
		);
		expect(location.line).toBe(1);
		expect(location.canAddSequence).toBe(true);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('resolves a same-file composition component', async () => {
	const location = await resolveCompositionComponent({
		remotionRoot,
		compositionFile: 'src/NewVideo.tsx',
		compositionId: 'NewVideo',
	});

	expect(location.source).toBe(path.join('src', 'NewVideo.tsx'));
	expect(location.line).toBe(21);
	expect(location.canAddSequence).toBe(true);
});

test('bails out if component has no JSX return', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				'export const MyComp: React.FC = () => {',
				'\tthrow new Error("hello");',
				'};',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe('MyComp.tsx');
		expect(location.canAddSequence).toBe(false);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('supports adding a sequence to fragment return', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				'export const MyComp: React.FC = () => {',
				'\treturn <>hello</>;',
				'};',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe('MyComp.tsx');
		expect(location.canAddSequence).toBe(true);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('supports adding a sequence to JSX element return', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				'export const MyComp: React.FC = () => {',
				'\treturn <div>hello</div>;',
				'};',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe('MyComp.tsx');
		expect(location.canAddSequence).toBe(true);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('canAddSequence=true for default-exported function component', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import MyComp from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				'const MyComp: React.FC = () => {',
				'\treturn <section>hello</section>;',
				'};',
				'',
				'export default MyComp;',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe('MyComp.tsx');
		expect(location.canAddSequence).toBe(true);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('canAddSequence=true for self-closing root JSX return', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				'export const MyComp: React.FC = () => {',
				'\treturn <div />;',
				'};',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe('MyComp.tsx');
		expect(location.canAddSequence).toBe(true);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a Solid next to a self-closing root without wrapping it', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		const componentInput = [
			"import {Video} from '@remotion/media';",
			"import {staticFile} from 'remotion';",
			'',
			'export const MyComp: React.FC = () => {',
			'\treturn <Video src={staticFile("background.mov")} />;',
			'};',
			'',
		].join('\n');
		await fs.writeFile(path.join(tempDir, 'MyComp.tsx'), componentInput);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'solid',
				width: 1920,
				height: 1080,
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain(
			"import {staticFile, Solid} from 'remotion';",
		);
		expect(result.output).not.toContain('<Sequence');
		expect(result.output).toContain(
			'<Video src={staticFile("background.mov")} />',
		);
		expect(result.output).toContain('<Solid');
		expect(result.output).toMatch(/style=\{\{\s*position: 'absolute'\s*\}\}/);
		expect(result.nodePathRemappings).toEqual([
			{
				oldNodePath: lineContainingToNodePath(componentInput, '<Video'),
				newNodePath: lineContainingToNodePath(result.output, '<Video'),
			},
			{
				oldNodePath: null,
				newNodePath: lineContainingToNodePath(result.output, '<Solid'),
			},
		]);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts an asset as a sibling of a connected composition', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {Sequence} from 'remotion';",
				"import {Skills2Announcement} from './Skills2Announcement';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn (',
				'\t\t<Sequence name="Skills2Announcement">',
				'\t\t\t<Skills2Announcement />',
				'\t\t</Sequence>',
				'\t);',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'video',
				src: 'clip.mp4',
				srcType: 'static',
				dimensions: {width: 1920, height: 1080},
				durationInFrames: 90,
				position: null,
			},
			from: 42,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		const connectedCompositionEnd = result.output.indexOf('</Sequence>');
		const videoStart = result.output.indexOf('<Video');
		expect(result.output).toContain('<>');
		expect(connectedCompositionEnd).toBeGreaterThan(-1);
		expect(videoStart).toBeGreaterThan(connectedCompositionEnd);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts beside a parenthesized self-closing root without wrapping it', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {Video} from '@remotion/media';",
				"import {staticFile} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn (',
				'\t\t<Video src={staticFile("background.mov")} />',
				'\t);',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'image',
				src: 'foreground.png',
				srcType: 'static',
				dimensions: {width: 1920, height: 1080},
				durationInFrames: null,
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		const videoStart = result.output.indexOf('<Video');
		const imageStart = result.output.indexOf('<CanvasImage');
		expect(result.output).toContain('<>');
		expect(result.output).not.toContain('<Sequence');
		expect(videoStart).toBeGreaterThan(-1);
		expect(imageStart).toBeGreaterThan(videoStart);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('canAddSequence=false for ThreeCanvas root element', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {ThreeCanvas} from '@remotion/three';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <ThreeCanvas />;',
				'};',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe('MyComp.tsx');
		expect(location.canAddSequence).toBe(false);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('canAddSequence=false for RiveCanvas root element', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {RiveCanvas} from '@remotion/rive';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <RiveCanvas></RiveCanvas>;',
				'};',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe('MyComp.tsx');
		expect(location.canAddSequence).toBe(false);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('canAddSequence=false for SkiaCanvas root element', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {SkiaCanvas} from '@remotion/skia';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <SkiaCanvas></SkiaCanvas>;',
				'};',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe('MyComp.tsx');
		expect(location.canAddSequence).toBe(false);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('canAddSequence=false for plain canvas root element', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				'export const MyComp: React.FC = () => {',
				'\treturn <canvas></canvas>;',
				'};',
				'',
			].join('\n'),
		);

		const location = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(location.source).toBe('MyComp.tsx');
		expect(location.canAddSequence).toBe(false);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a Solid into the resolved composition component', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'solid',
				width: 1280,
				height: 720,
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.source).toBe('MyComp.tsx');
		expect(result.output).toContain(
			"import {AbsoluteFill, Solid} from 'remotion';",
		);
		expect(result.output).toContain('<Solid');
		expect(result.output).toContain('width={1280}');
		expect(result.output).toContain('height={720}');
		expect(result.output).toContain('color="gray"');
		expect(result.output).toContain("position: 'absolute'");
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a Solid with a translate style', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'solid',
				width: 1280,
				height: 720,
				position: {
					x: 120,
					y: 80.5,
				},
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain("position: 'absolute'");
		expect(result.output).toContain("translate: '120px 80.5px'");
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('rounds the translate style to one decimal place', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'solid',
				width: 1280,
				height: 720,
				position: {
					x: -366.7533828676237,
					y: 50.1836012801557,
				},
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain("position: 'absolute'");
		expect(result.output).toContain("translate: '-366.8px 50.2px'");
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts an aliased Solid import if Solid is already defined', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const Solid = () => null;',
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'solid',
				width: 1920,
				height: 1080,
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain(
			"import {AbsoluteFill, Solid as Solid2} from 'remotion';",
		);
		expect(result.output).toContain('<Solid2');
		expect(result.output).toContain('width={1920}');
		expect(result.output).toContain('height={1080}');
		expect(result.output).toContain("position: 'absolute'");
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a Solid into an empty component returning null', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			['export const MyComp: React.FC = () => null;', ''].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'solid',
				width: 640,
				height: 360,
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain("import { Solid } from 'remotion';");
		expect(result.output).toContain('export const MyComp: React.FC = () => (');
		expect(result.output).toContain('\t<>');
		expect(result.output).toContain('\t\t<Solid');
		expect(result.output).toContain('\t</>');
		expect(result.output).toContain('width={640}');
		expect(result.output).toContain('height={360}');
		expect(result.output).toContain("position: 'absolute'");

		await fs.writeFile(path.join(tempDir, 'MyComp.tsx'), result.output);

		const afterFirstInsert = await resolveCompositionComponent({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
		});
		expect(afterFirstInsert.canAddSequence).toBe(true);

		const secondInsert = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'solid',
				width: 320,
				height: 180,
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});
		expect(secondInsert.output.match(/<Solid/g)?.length).toBe(2);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('converts and inserts SVG markup as an Interactive.Svg', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'svg',
				markup:
					'<svg width="100" height="50" viewBox="0 0 100 50" style="opacity: 0.8"><path fill-rule="evenodd" stroke-width="2" d="M0 0h10v10z" /></svg>',
				position: {x: 120.25, y: 80},
			},
			from: 42,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain(
			"import {AbsoluteFill, Interactive} from 'remotion';",
		);
		expect(result.output).toContain('<Interactive.Svg');
		expect(result.output).toContain('from={42}');
		expect(result.output).not.toContain('<Sequence');
		expect(result.output).toContain('</Interactive.Svg>');
		expect(result.output).toContain('width={100}');
		expect(result.output).toContain('height={50}');
		expect(result.output).toContain('viewBox="0 0 100 50"');
		expect(result.output).toContain('fillRule="evenodd"');
		expect(result.output).toContain('strokeWidth={2}');
		expect(result.output).toContain('opacity: 0.8');
		expect(result.output).toContain("position: 'absolute'");
		expect(result.output).toContain("translate: '120.3px 80px'");
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a CanvasImage asset at a timeline frame', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'image',
				src: 'image.png',
				srcType: 'static',
				dimensions: {
					width: 800,
					height: 600,
				},
				durationInFrames: null,
				position: null,
			},
			from: 42,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain(
			"import {AbsoluteFill, CanvasImage, staticFile} from 'remotion';",
		);
		expect(result.output).not.toContain('<Sequence');
		expect(result.output).toContain('from={42}');
		expect(result.output).toContain('<CanvasImage');
		expect(result.output).toContain("src={staticFile('image.png')}");
		expect(result.output).toContain("position: 'absolute'");
		expect(result.output).not.toContain('width={800}');
		expect(result.output).not.toContain('height={600}');
		expect(result.output).not.toContain('width: 800');
		expect(result.output).not.toContain('height: 600');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a CanvasImage asset with a translate style', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'image',
				src: 'image.png',
				srcType: 'static',
				dimensions: {
					width: 800,
					height: 600,
				},
				durationInFrames: null,
				position: {
					x: 100,
					y: 150,
				},
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain(
			"import {AbsoluteFill, CanvasImage, staticFile} from 'remotion';",
		);
		expect(result.output).toContain('<CanvasImage');
		expect(result.output).toContain("src={staticFile('image.png')}");
		expect(result.output).toContain("translate: '100px 150px'");
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts an AnimatedImage asset into the resolved composition component', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'animated-image',
				src: 'animated-png.png',
				srcType: 'static',
				dimensions: {
					width: 320,
					height: 180,
				},
				durationInFrames: 37.52,
				position: null,
			},
			from: 42,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain(
			"import {AbsoluteFill, AnimatedImage, staticFile} from 'remotion';",
		);
		expect(result.output).toContain('<AnimatedImage');
		expect(result.output).toContain("src={staticFile('animated-png.png')}");
		expect(result.output).toContain('durationInFrames={37.52}');
		expect(result.output).toContain('from={42}');
		expect(result.output).not.toContain('<Sequence');
		expect(result.output).toContain('width: 320');
		expect(result.output).toContain('height: 180');
		expect(result.output).not.toContain('width={320}');
		expect(result.output).not.toContain('height={180}');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a Video asset with its duration and CSS dimensions', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'video',
				src: 'clip.mp4',
				srcType: 'static',
				dimensions: {
					width: 1920,
					height: 1080,
				},
				durationInFrames: 37.52,
				position: null,
			},
			from: 42,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain("import {Video} from '@remotion/media';");
		expect(result.output).toContain(
			"import {AbsoluteFill, staticFile} from 'remotion';",
		);
		expect(result.output).toContain('durationInFrames={37.52}');
		expect(result.output).toContain('from={42}');
		expect(result.output).toContain('<Video');
		expect(result.output).toContain("src={staticFile('clip.mp4')}");
		expect(result.output).toContain("position: 'absolute'");
		expect(result.output).toContain('width: 1920');
		expect(result.output).toContain('height: 1080');
		expect(result.output).not.toContain('<Sequence');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('aliases an inserted Video asset when Video is already defined', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const Video = () => null;',
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'video',
				src: 'clip.mp4',
				srcType: 'static',
				dimensions: null,
				durationInFrames: null,
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain(
			"import {Video as Video2} from '@remotion/media';",
		);
		expect(result.output).toMatch(
			/<Video2\s+src=\{staticFile\('clip\.mp4'\)\}/,
		);
		expect(result.output).toContain('export const Video = () => null;');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a Gif asset into the resolved composition component', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'gif',
				src: 'animation.gif',
				srcType: 'static',
				dimensions: {
					width: 320,
					height: 180,
				},
				durationInFrames: 37.52,
				position: null,
			},
			from: 42,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain("import {Gif} from '@remotion/gif';");
		expect(result.output).toContain(
			"import {AbsoluteFill, staticFile} from 'remotion';",
		);
		expect(result.output).toContain('<Gif');
		expect(result.output).toContain("src={staticFile('animation.gif')}");
		expect(result.output).toContain('durationInFrames={37.52}');
		expect(result.output).toContain('from={42}');
		expect(result.output).not.toContain('<Sequence');
		expect(result.output).toContain('width: 320');
		expect(result.output).toContain('height: 180');
		expect(result.output).not.toContain('width={320}');
		expect(result.output).not.toContain('height={180}');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts an Audio asset into the resolved composition component', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'audio',
				src: 'audio.mp3',
				srcType: 'static',
				dimensions: null,
				durationInFrames: 37.52,
				position: null,
			},
			from: 42,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain("import {Audio} from '@remotion/media';");
		expect(result.output).toContain(
			"import {AbsoluteFill, staticFile} from 'remotion';",
		);
		expect(result.output).toContain('<Audio');
		expect(result.output).toContain("src={staticFile('audio.mp3')}");
		expect(result.output).toContain('durationInFrames={37.52}');
		expect(result.output).toContain('from={42}');
		expect(result.output).not.toContain('<Sequence');
		expect(result.output).not.toContain("position: 'absolute'");
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a remote audio asset with a literal URL', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'audio',
				src: 'https://example.com/whip.wav',
				srcType: 'remote',
				dimensions: null,
				durationInFrames: null,
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain("import {Audio} from '@remotion/media';");
		expect(result.output).toContain("import {AbsoluteFill} from 'remotion';");
		expect(result.output).toContain('<Audio');
		expect(result.output).toContain('src="https://example.com/whip.wav"');
		expect(result.output).not.toContain('staticFile');
		expect(result.output).not.toContain('@remotion/sfx');
		expect(result.output).not.toContain("position: 'absolute'");
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('aliases an inserted Audio asset when Audio is already defined', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const Audio = () => null;',
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'asset',
				assetType: 'audio',
				src: 'audio.mp3',
				srcType: 'static',
				dimensions: null,
				durationInFrames: null,
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain(
			"import {Audio as Audio2} from '@remotion/media';",
		);
		expect(result.output).toMatch(
			/<Audio2\s+src=\{staticFile\('audio\.mp3'\)\}/,
		);
		expect(result.output).toContain('export const Audio = () => null;');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a component into the resolved composition component', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'component',
				componentName: 'Circle',
				importName: 'Circle',
				importPath: '@remotion/shapes',
				props: [
					{name: 'fill', value: '#0b84ff'},
					{name: 'dataShapeIndex', value: 1},
					{name: 'debug', value: false},
				],
				position: null,
			},
			from: 42,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain("import {Circle} from '@remotion/shapes';");
		expect(result.output).toContain('<Circle');
		expect(result.output).toContain('fill="#0b84ff"');
		expect(result.output).toContain('dataShapeIndex={1}');
		expect(result.output).toContain('debug={false}');
		expect(result.output).toContain('from={42}');
		expect(result.output).toContain("position: 'absolute'");
		expect(result.output).not.toContain('<Sequence');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('adds value imports without reusing or colliding with type-only component imports', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);

		for (const typeOnlyImport of [
			"import type {LowerThird} from './lower-third.element';",
			"import {type LowerThird} from './lower-third.element';",
		]) {
			await fs.writeFile(
				path.join(tempDir, 'MyComp.tsx'),
				[
					typeOnlyImport,
					"import {AbsoluteFill} from 'remotion';",
					'',
					'export const MyComp: React.FC = () => {',
					'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
					'};',
					'',
				].join('\n'),
			);

			const aliasedResult = await insertJsxElementIntoComposition({
				remotionRoot: tempDir,
				compositionFile: 'Root.tsx',
				compositionId: 'test',
				element: {
					type: 'component',
					componentName: 'LowerThird',
					importName: 'LowerThird',
					importPath: './lower-third.element',
					props: [],
					position: null,
				},
				from: null,
				prettierConfigOverride: {singleQuote: true, useTabs: true},
				sourceFileOverrides: null,
			});
			expect(aliasedResult.output).toContain('LowerThird as LowerThird2');
			expect(aliasedResult.output).toContain('<LowerThird2');
			expect(aliasedResult.output).toMatch(/\btype\s+(?:\{\s*)?LowerThird\b/);
		}

		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import type {LowerThird as LowerThirdProps} from './lower-third.element';",
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);
		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'component',
				componentName: 'LowerThird',
				importName: 'LowerThird',
				importPath: './lower-third.element',
				props: [],
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});
		expect(result.output).toContain(
			"import {LowerThird} from './lower-third.element';",
		);
		expect(result.output).toContain('<LowerThird');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('wraps a component in a dimensionless Sequence', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {MyComp} from './MyComp';",
				'export const RemotionRoot = () => {',
				'\treturn <Composition id="test" component={MyComp} />;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'MyComp.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const MyComp: React.FC = () => {',
				'\treturn <AbsoluteFill>hello</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'test',
			element: {
				type: 'component',
				componentName: 'LowerThird',
				importName: 'LowerThird',
				importPath: './lower-third.element',
				props: [],
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
			wrapInSequence: {
				dimensions: null,
				from: 42,
				name: 'Lower Third',
				position: {x: 120, y: 80.5},
			},
		});

		expect(result.output).toContain(
			"import {AbsoluteFill, Sequence} from 'remotion';",
		);
		expect(result.output).toContain(
			"import {LowerThird} from './lower-third.element';",
		);
		expect(result.output).toContain('<Sequence');
		expect(result.output).toContain('from={42}');
		expect(result.output).toContain('name="Lower Third"');
		expect(result.output).toContain("translate: '120px 80.5px'");
		expect(result.output).toContain('<LowerThird />');
		expect(result.output).not.toContain('width={');
		expect(result.output).not.toContain('height={');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a composition as a duration-aware Sequence', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {Source} from './Source';",
				"import {Target} from './Target';",
				'export const RemotionRoot = () => {',
				'\treturn (',
				'\t\t<>',
				'\t\t\t<Composition id="source" component={Source} />',
				'\t\t\t<Composition id="target" component={Target} />',
				'\t\t</>',
				'\t);',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'Source.tsx'),
			[
				'export const Source: React.FC = () => {',
				'\treturn <div>source</div>;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'Target.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const Target: React.FC = () => {',
				'\treturn <AbsoluteFill>target</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'target',
			element: {
				type: 'composition',
				compositionId: 'source',
				compositionFile: 'Root.tsx',
				durationInFrames: 100,
				width: 1080,
				height: 540,
				serializedResolvedPropsWithCustomSchema: JSON.stringify({
					hi: 'there',
					nested: {value: 1},
					'dash-prop': 'ok',
					img: `${NoReactInternals.FILE_TOKEN}image.png`,
					date: `${NoReactInternals.DATE_TOKEN}2025-01-01T00:00:00.000Z`,
				}),
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain("import {Source} from './Source';");
		expect(result.output).toContain('Sequence');
		expect(result.output).toContain('<Sequence');
		expect(result.output).toContain('width={1080}');
		expect(result.output).toContain('height={540}');
		expect(result.output).toContain('durationInFrames={100}');
		expect(result.output).toContain('name="source"');
		expect(result.output).toContain('<Source');
		expect(result.output).toContain('hi="there"');
		expect(result.output).toContain('nested={{');
		expect(result.output).toContain('value: 1');
		expect(result.output).toContain("'dash-prop': 'ok'");
		expect(result.output).toContain("img={staticFile('image.png')}");
		expect(result.output).toContain(
			"date={new Date('2025-01-01T00:00:00.000Z')}",
		);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('rejects inserting a composition whose component is not exported', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {SourceComposition} from './Source';",
				"import {Target} from './Target';",
				'export const RemotionRoot = () => {',
				'\treturn (',
				'\t\t<>',
				'\t\t\t<SourceComposition />',
				'\t\t\t<Composition id="target" component={Target} />',
				'\t\t</>',
				'\t);',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'Source.tsx'),
			[
				"import {Composition} from 'remotion';",
				'const Source: React.FC = () => {',
				'\treturn <div>source</div>;',
				'};',
				'export const SourceComposition = () => {',
				'\treturn <Composition id="source" component={Source} />;',
				'};',
				'',
			].join('\n'),
		);
		const targetContents = [
			"import {AbsoluteFill} from 'remotion';",
			'',
			'export const Target: React.FC = () => {',
			'\treturn <AbsoluteFill>target</AbsoluteFill>;',
			'};',
			'',
		].join('\n');
		const targetFile = path.join(tempDir, 'Target.tsx');
		await fs.writeFile(targetFile, targetContents);

		const response = await insertCompositionElementHandler({
			input: {
				compositionFile: 'Root.tsx',
				compositionId: 'target',
				element: {
					type: 'composition',
					compositionId: 'source',
					compositionFile: 'Source.tsx',
					durationInFrames: 100,
					width: 1080,
					height: 540,
					serializedResolvedPropsWithCustomSchema: JSON.stringify({}),
					position: null,
				},
				from: null,
			},
			entryPoint: path.join(tempDir, 'Root.tsx'),
			remotionRoot: tempDir,
			request: {} as never,
			response: {} as never,
			logLevel: 'error',
			methods: {
				removeJob: () => undefined,
				cancelJob: () => undefined,
				addJob: () => undefined,
			},
			publicDir: tempDir,
			binariesDirectory: null,
			configFile: null,
			getDefaultCodingAgent: () => null,
			getDefaultEditor: () => null,
		});

		expect(response.success).toBe(false);
		if (!response.success) {
			expect(response.reason).toBe(
				'Cannot add composition "source" because its component "Source" is not exported from Source.tsx. Export the component and try again.',
			);
		}

		expect(await fs.readFile(targetFile, 'utf-8')).toBe(targetContents);
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('inserts a default-exported composition next to an existing namespace import', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import Source from './Source';",
				"import {Target} from './Target';",
				'export const RemotionRoot = () => {',
				'\treturn (',
				'\t\t<>',
				'\t\t\t<Composition id="source" component={Source} />',
				'\t\t\t<Composition id="target" component={Target} />',
				'\t\t</>',
				'\t);',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'Source.tsx'),
			[
				'const Source: React.FC = () => {',
				'\treturn <div>source</div>;',
				'};',
				'',
				'export default Source;',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'Target.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				"import * as SourceModule from './Source';",
				'',
				'export const Target: React.FC = () => {',
				'\treturn <AbsoluteFill>target</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		const result = await insertJsxElementIntoComposition({
			remotionRoot: tempDir,
			compositionFile: 'Root.tsx',
			compositionId: 'target',
			element: {
				type: 'composition',
				compositionId: 'source',
				compositionFile: 'Root.tsx',
				durationInFrames: 100,
				width: 1080,
				height: 540,
				serializedResolvedPropsWithCustomSchema: JSON.stringify({}),
				position: null,
			},
			from: null,
			prettierConfigOverride: {singleQuote: true, useTabs: true},
			sourceFileOverrides: null,
		});

		expect(result.output).toContain(
			"import * as SourceModule from './Source';",
		);
		expect(result.output).toContain("import Source from './Source';");
		expect(result.output).not.toContain(
			"import Source, * as SourceModule from './Source';",
		);
		expect(result.output).toContain('<Source');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('rejects array payloads for resolved composition props', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		await fs.writeFile(
			path.join(tempDir, 'Root.tsx'),
			[
				"import {Composition} from 'remotion';",
				"import {Source} from './Source';",
				"import {Target} from './Target';",
				'export const RemotionRoot = () => {',
				'\treturn (',
				'\t\t<>',
				'\t\t\t<Composition id="source" component={Source} />',
				'\t\t\t<Composition id="target" component={Target} />',
				'\t\t</>',
				'\t);',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'Source.tsx'),
			[
				'export const Source: React.FC = () => {',
				'\treturn <div>source</div>;',
				'};',
				'',
			].join('\n'),
		);
		await fs.writeFile(
			path.join(tempDir, 'Target.tsx'),
			[
				"import {AbsoluteFill} from 'remotion';",
				'',
				'export const Target: React.FC = () => {',
				'\treturn <AbsoluteFill>target</AbsoluteFill>;',
				'};',
				'',
			].join('\n'),
		);

		await expect(
			insertJsxElementIntoComposition({
				remotionRoot: tempDir,
				compositionFile: 'Root.tsx',
				compositionId: 'target',
				element: {
					type: 'composition',
					compositionId: 'source',
					compositionFile: 'Root.tsx',
					durationInFrames: 100,
					width: 1080,
					height: 540,
					serializedResolvedPropsWithCustomSchema: JSON.stringify([
						'not',
						'an object',
					]),
					position: null,
				},
				from: null,
				prettierConfigOverride: {singleQuote: true, useTabs: true},
				sourceFileOverrides: null,
			}),
		).rejects.toThrow('Resolved composition props must be an object');
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});

test('rejects composition insertion requests that traverse out of the project root', async () => {
	const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'remotion-resolve-'));
	try {
		const response = await insertCompositionElementHandler({
			input: {
				compositionFile: 'Root.tsx',
				compositionId: 'target',
				element: {
					type: 'composition',
					compositionId: 'source',
					compositionFile: '../Root.tsx',
					durationInFrames: 100,
					width: 1080,
					height: 540,
					serializedResolvedPropsWithCustomSchema: JSON.stringify({}),
					position: null,
				},
				from: null,
			},
			entryPoint: path.join(tempDir, 'Root.tsx'),
			remotionRoot: tempDir,
			request: {} as never,
			response: {} as never,
			logLevel: 'error',
			methods: {
				removeJob: () => undefined,
				cancelJob: () => undefined,
				addJob: () => undefined,
			},
			publicDir: tempDir,
			binariesDirectory: null,
			configFile: null,
			getDefaultCodingAgent: () => null,
			getDefaultEditor: () => null,
		});

		expect(response.success).toBe(false);
		if (!response.success) {
			expect(response.reason).toBe('Unsupported composition file');
		}
	} finally {
		await fs.rm(tempDir, {recursive: true, force: true});
	}
});