Skip to content

🎥 Make videos programmatically with React

17.0 KB
Raw Blame
import {
	StudioProtocolInternals,
	type AddElementLibraryToStudioResult,
} from '@remotion/studio-protocol';
import {normalizeHttpUrl} from '@remotion/studio-shared';
import React, {useCallback, useContext, useEffect} from 'react';
import {getBrowserStudioOperations} from '../helpers/browser-studio-operations';
import {StudioServerConnectionCtx} from '../helpers/client-id';
import {getStudioAskAIEnabled} from '../helpers/studio-runtime-config';
import {SelectedModalContext, SetSelectedModalContext} from '../state/modals';
import {AskAiModal} from './AskAiModal';
import {AssetSelectorModal} from './AssetSelectorModal';
import {BrowserStudioExperimentingNotice} from './BrowserStudioExperimentingNotice';
import {callApi} from './call-api';
import {ConfirmationDialog, useConfirmationDialog} from './ConfirmationDialog';
import {EffectPickerModal} from './EffectPickerModal';
import {
	ElementInstallConfirmation,
	ElementLibraryAddConfirmation,
} from './ElementInstallConfirmation';
import {ElementLibraryModal} from './ElementLibraryModal';
import {FixComputedValueModal} from './FixComputedValueModal';
import {GenerateWithAgentModal} from './GenerateWithAgentModal';
import {HtmlInCanvasUnavailableModal} from './HtmlInCanvasUnavailableModal';
import {DeleteComposition} from './NewComposition/DeleteComposition';
import {DeleteFolder} from './NewComposition/DeleteFolder';
import {DuplicateComposition} from './NewComposition/DuplicateComposition';
import {NewComposition} from './NewComposition/NewComposition';
import {NewFolder} from './NewComposition/NewFolder';
import {RenameComposition} from './NewComposition/RenameComposition';
import {RenameFolder} from './NewComposition/RenameFolder';
import {RenameStaticFileModal} from './NewComposition/RenameStaticFile';
import {showNotification} from './Notifications/NotificationCenter';
import {OverrideInputPropsModal} from './OverrideInputProps';
import {PrecomposeRefactorModal} from './PrecomposeRefactorModal';
import QuickSwitcher from './QuickSwitcher/QuickSwitcher';
import {RenderStatusModal} from './RenderModal/RenderStatusModal';
import {RenderModalWithLoader} from './RenderModal/ServerRenderModal';
import {WebRenderModalWithLoader} from './RenderModal/WebRenderModal';
import {QueueJobErrorModal} from './RenderQueue/QueueJobErrorModal';
import {SettingsModal} from './SettingsModal';
import {SvgImportDialog} from './SvgImportDialog';
import {TranscriptionModalWithOptionalWhisper} from './Transcription/TranscriptionModalWithOptionalWhisper';
import {VideoMattingModalWithOptionalPackage} from './VideoMatting/VideoMattingModalWithOptionalPackage';
import {WrapperRefactorModal} from './WrapperRefactorModal';

export const Modals: React.FC<{
	readonly readOnlyStudio: boolean;
}> = ({readOnlyStudio}) => {
	const modalContextType = useContext(SelectedModalContext);
	const {setSelectedModal} = useContext(SetSelectedModalContext);
	const {previewServerState, subscribeToEvent} = useContext(
		StudioServerConnectionCtx,
	);
	const canRender = previewServerState.type === 'connected';
	const isBrowserStudio = getBrowserStudioOperations() !== null;
	const confirm = useConfirmationDialog();
	const requestElementLibraryAddition = useCallback(
		async ({
			captionStylesUrl,
			displayName,
			origin,
			url,
		}: {
			readonly captionStylesUrl: string | null;
			readonly displayName: string | null;
			readonly origin: string;
			readonly url: string;
		}) => {
			const confirmed = await confirm({
				title: 'Add Element Library',
				message: (
					<ElementLibraryAddConfirmation
						origin={origin}
						url={url}
						captionStylesUrl={captionStylesUrl}
					/>
				),
				confirmLabel: 'Add Element Library',
				cancelLabel: 'Cancel',
			});
			if (!confirmed) {
				return;
			}

			if (previewServerState.type !== 'connected') {
				showNotification(
					'Could not add Element Library: Studio disconnected',
					4000,
				);
				return;
			}

			try {
				const result = await callApi('/api/update-config', {
					clientId: previewServerState.clientId,
					updates: [
						{
							setter: 'addElementLibrary',
							type: 'set',
							value: {
								url,
								...(displayName === null ? {} : {displayName}),
								...(captionStylesUrl === null ? {} : {captionStylesUrl}),
							},
						},
					],
				});
				if (!result.success) {
					showNotification(
						`Could not add Element Library: ${result.reason}`,
						4000,
					);
					return;
				}

				const parsedUrl = new URL(url);
				const pathname = parsedUrl.pathname.replace(/\/$/, '');
				setSelectedModal({
					type: 'element-library',
					name: displayName ?? `${parsedUrl.host}${pathname}`,
					url,
				});
			} catch (error) {
				showNotification(
					`Could not add Element Library: ${(error as Error).message}`,
					4000,
				);
			}
		},
		[confirm, previewServerState, setSelectedModal],
	);

	useEffect(() => {
		if (isBrowserStudio) {
			return;
		}

		return subscribeToEvent('license-key-install-request', (event) => {
			if (event.type !== 'license-key-install-request') {
				return;
			}

			setSelectedModal({
				type: 'settings',
				initialStudioPane: null,
				initialTab: 'license',
				initialPublicLicenseKey: event.licenseKey,
			});
		});
	}, [isBrowserStudio, setSelectedModal, subscribeToEvent]);

	useEffect(() => {
		if (isBrowserStudio) {
			return;
		}

		return subscribeToEvent('element-library-add-request', (event) => {
			if (event.type !== 'element-library-add-request') {
				return;
			}

			requestElementLibraryAddition(event);
		});
	}, [isBrowserStudio, requestElementLibraryAddition, subscribeToEvent]);

	useEffect(() => {
		const onMessage = (event: MessageEvent) => {
			const elementLibrary = document.querySelector<HTMLIFrameElement>(
				'iframe[data-remotion-element-library]',
			);
			if (
				event.source !== elementLibrary?.contentWindow ||
				!StudioProtocolInternals.isAllowedStudioProtocolPageOrigin(event.origin)
			) {
				return;
			}

			const request =
				StudioProtocolInternals.parseStudioProtocolIframeAddElementLibraryRequest(
					event.data,
				);
			const responsePort = event.ports[0];
			if (request === null || responsePort === undefined) {
				return;
			}

			let normalizedUrl: string | null = null;
			try {
				const parsedUrl = new URL(request.url);
				if (parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:') {
					normalizedUrl = parsedUrl.href;
				}
			} catch {
				// The response below explains that the URL is invalid.
			}

			const captionStylesUrl =
				request.captionStylesUrl === null
					? null
					: normalizeHttpUrl(request.captionStylesUrl);
			const invalidCaptionStylesUrl =
				request.captionStylesUrl !== null && captionStylesUrl === null;

			const displayName = request.displayName?.trim() ?? null;
			const canAddLibrary =
				!isBrowserStudio &&
				!readOnlyStudio &&
				previewServerState.type === 'connected';
			const result: AddElementLibraryToStudioResult =
				normalizedUrl === null || invalidCaptionStylesUrl
					? {
							success: false,
							code: 'invalid-url',
							message: invalidCaptionStylesUrl
								? 'The caption styles URL must be an absolute HTTP or HTTPS URL.'
								: 'The Element Library URL must be an absolute HTTP or HTTPS URL.',
						}
					: displayName === ''
						? {
								success: false,
								code: 'invalid-display-name',
								message: 'The Element Library display name must not be empty.',
							}
						: !canAddLibrary
							? {
									success: false,
									code: 'no-configurable-target',
									message: 'Open a writable Remotion Studio, then try again.',
								}
							: {
									success: true,
									status: 'awaiting-confirmation',
									target: {
										projectName: window.remotion_projectName,
										studioOrigin: window.location.origin,
										studioVersion: window.remotion_version,
									},
								};

			const timeout = window.setTimeout(() => responsePort.close(), 1000);
			responsePort.onmessage = () => {
				window.clearTimeout(timeout);
				responsePort.close();
				if (result.success && normalizedUrl !== null) {
					requestElementLibraryAddition({
						captionStylesUrl,
						displayName,
						origin: event.origin,
						url: normalizedUrl,
					});
				}
			};

			responsePort.postMessage(result);
		};

		window.addEventListener('message', onMessage);
		return () => window.removeEventListener('message', onMessage);
	}, [
		isBrowserStudio,
		previewServerState.type,
		readOnlyStudio,
		requestElementLibraryAddition,
	]);

	const library =
		modalContextType?.type === 'element-library'
			? modalContextType
			: modalContextType?.type === 'element-install'
				? modalContextType.library
				: null;

	return (
		<>
			{modalContextType?.type === 'browser-studio-experimental-notice' ? (
				<BrowserStudioExperimentingNotice />
			) : null}
			{modalContextType && modalContextType.type === 'new-comp' && (
				<NewComposition
					folderName={modalContextType.folderName}
					parentName={modalContextType.parentName}
					stack={modalContextType.stack}
					canvasCapture={modalContextType.canvasCapture}
				/>
			)}
			{modalContextType && modalContextType.type === 'new-folder' && (
				<NewFolder
					parentName={modalContextType.parentName}
					stack={modalContextType.stack}
				/>
			)}
			{modalContextType && modalContextType.type === 'duplicate-comp' && (
				<DuplicateComposition
					compositionType={modalContextType.compositionType}
					compositionId={modalContextType.compositionId}
				/>
			)}
			{modalContextType && modalContextType.type === 'delete-comp' && (
				<DeleteComposition compositionId={modalContextType.compositionId} />
			)}
			{modalContextType && modalContextType.type === 'rename-comp' && (
				<RenameComposition compositionId={modalContextType.compositionId} />
			)}
			{modalContextType && modalContextType.type === 'delete-folder' && (
				<DeleteFolder
					folderName={modalContextType.folderName}
					parentName={modalContextType.parentName}
					stack={modalContextType.stack}
				/>
			)}
			{modalContextType && modalContextType.type === 'rename-folder' && (
				<RenameFolder
					folderName={modalContextType.folderName}
					parentName={modalContextType.parentName}
					stack={modalContextType.stack}
				/>
			)}
			{modalContextType && modalContextType.type === 'rename-static-file' && (
				<RenameStaticFileModal relativePath={modalContextType.relativePath} />
			)}
			{modalContextType && modalContextType.type === 'input-props-override' && (
				<OverrideInputPropsModal />
			)}
			{modalContextType && modalContextType.type === 'settings' ? (
				<SettingsModal
					key={`${modalContextType.initialTab}-${modalContextType.initialStudioPane}-${modalContextType.initialPublicLicenseKey}`}
					initialStudioPane={modalContextType.initialStudioPane}
					initialTab={modalContextType.initialTab}
					initialPublicLicenseKey={modalContextType.initialPublicLicenseKey}
				/>
			) : null}
			{modalContextType && modalContextType.type === 'web-render' && (
				<WebRenderModalWithLoader {...modalContextType} />
			)}
			{modalContextType &&
			modalContextType.type === 'server-render' &&
			(canRender || modalContextType.readOnlyStudio) ? (
				<RenderModalWithLoader
					readOnlyStudio={modalContextType.readOnlyStudio ?? false}
					initialFrame={modalContextType.initialFrame}
					initialDarkMode={modalContextType.initialDarkMode}
					compositionId={modalContextType.compositionId}
					initialVideoImageFormat={modalContextType.initialVideoImageFormat}
					initialJpegQuality={modalContextType.initialJpegQuality}
					initialScale={modalContextType.initialScale}
					initialLogLevel={modalContextType.initialLogLevel}
					initialOffthreadVideoCacheSizeInBytes={
						modalContextType.initialOffthreadVideoCacheSizeInBytes
					}
					initialOffthreadVideoThreads={
						modalContextType.initialOffthreadVideoThreads
					}
					initialMediaCacheSizeInBytes={
						modalContextType.initialMediaCacheSizeInBytes
					}
					initialConcurrency={modalContextType.initialConcurrency}
					maxConcurrency={modalContextType.maxConcurrency}
					minConcurrency={modalContextType.minConcurrency}
					initialStillImageFormat={modalContextType.initialStillImageFormat}
					initialMuted={modalContextType.initialMuted}
					initialEnforceAudioTrack={modalContextType.initialEnforceAudioTrack}
					initialProResProfile={modalContextType.initialProResProfile}
					initialx264Preset={modalContextType.initialx264Preset}
					initialGopSize={modalContextType.initialGopSize}
					initialPixelFormat={modalContextType.initialPixelFormat}
					initialAudioBitrate={modalContextType.initialAudioBitrate}
					initialVideoBitrate={modalContextType.initialVideoBitrate}
					initialEveryNthFrame={modalContextType.initialEveryNthFrame}
					initialNumberOfGifLoops={modalContextType.initialNumberOfGifLoops}
					initialDelayRenderTimeout={modalContextType.initialDelayRenderTimeout}
					initialEnvVariables={modalContextType.initialEnvVariables}
					initialDisableWebSecurity={modalContextType.initialDisableWebSecurity}
					initialGl={modalContextType.initialOpenGlRenderer}
					initialHeadless={modalContextType.initialHeadless}
					initialIgnoreCertificateErrors={
						modalContextType.initialIgnoreCertificateErrors
					}
					initialEncodingBufferSize={modalContextType.initialEncodingBufferSize}
					initialEncodingMaxRate={modalContextType.initialEncodingMaxRate}
					initialUserAgent={modalContextType.initialUserAgent}
					initialColorSpace={modalContextType.initialColorSpace}
					initialMultiProcessOnLinux={
						modalContextType.initialMultiProcessOnLinux
					}
					initialRepro={modalContextType.initialRepro}
					initialBeep={modalContextType.initialBeep}
					initialForSeamlessAacConcatenation={
						modalContextType.initialForSeamlessAacConcatenation
					}
					defaultProps={modalContextType.defaultProps}
					inFrameMark={modalContextType.inFrameMark}
					outFrameMark={modalContextType.outFrameMark}
					defaultConfigurationAudioCodec={
						modalContextType.defaultConfigurationAudioCodec
					}
					defaultConfigurationVideoCodec={
						modalContextType.defaultConfigurationVideoCodec
					}
					renderTypeOfLastRender={modalContextType.renderTypeOfLastRender}
					defaultMetadata={modalContextType.defaulMetadata}
					initialHardwareAcceleration={
						modalContextType.initialHardwareAcceleration
					}
					initialSampleRate={modalContextType.initialSampleRate}
					initialChromeMode={modalContextType.initialChromeMode}
					renderDefaults={modalContextType.renderDefaults}
				/>
			) : null}

			{modalContextType && modalContextType.type === 'render-progress' && (
				<RenderStatusModal jobId={modalContextType.jobId} />
			)}
			{modalContextType && modalContextType.type === 'queue-job-error' ? (
				<QueueJobErrorModal
					title={modalContextType.title}
					error={modalContextType.error}
				/>
			) : null}
			{modalContextType && modalContextType.type === 'transcribe' ? (
				<TranscriptionModalWithOptionalWhisper state={modalContextType} />
			) : null}
			{modalContextType && modalContextType.type === 'video-matting' ? (
				<VideoMattingModalWithOptionalPackage state={modalContextType} />
			) : null}

			{modalContextType && modalContextType.type === 'fix-computed-value' && (
				<FixComputedValueModal state={modalContextType} />
			)}
			{modalContextType && modalContextType.type === 'precompose-refactor' && (
				<PrecomposeRefactorModal state={modalContextType} />
			)}
			{modalContextType && modalContextType.type === 'generate-with-agent' ? (
				<GenerateWithAgentModal state={modalContextType} />
			) : null}
			{modalContextType &&
			(modalContextType.type === 'wrap-refactor' ||
				modalContextType.type === 'unwrap-refactor') ? (
				<WrapperRefactorModal state={modalContextType} />
			) : null}
			{modalContextType &&
			modalContextType.type === 'html-in-canvas-unavailable' ? (
				<HtmlInCanvasUnavailableModal state={modalContextType} />
			) : null}
			{modalContextType && modalContextType.type === 'quick-switcher' && (
				<QuickSwitcher
					readOnlyStudio={readOnlyStudio}
					invocationTimestamp={modalContextType.invocationTimestamp}
					initialMode={modalContextType.mode}
					assetSelection={modalContextType.assetSelection}
					compositionSelection={modalContextType.compositionSelection}
				/>
			)}
			{modalContextType && modalContextType.type === 'asset-selection' ? (
				<AssetSelectorModal
					readOnlyStudio={readOnlyStudio}
					state={modalContextType}
				/>
			) : null}
			{library === null ? null : (
				<ElementLibraryModal
					name={library.name}
					url={library.url}
					installState={
						modalContextType?.type === 'element-install'
							? modalContextType
							: null
					}
				/>
			)}
			{modalContextType?.type === 'element-install' && library === null ? (
				<ElementInstallConfirmation state={modalContextType} />
			) : null}
			{modalContextType && modalContextType.type === 'add-effect' && (
				<EffectPickerModal state={modalContextType} />
			)}
			{modalContextType && modalContextType.type === 'confirmation-dialog' && (
				<ConfirmationDialog state={modalContextType} />
			)}
			{modalContextType && modalContextType.type === 'svg-import-dialog' && (
				<SvgImportDialog state={modalContextType} />
			)}
			{getStudioAskAIEnabled() && <AskAiModal />}
		</>
	);
};