Skip to content

🎥 Make videos programmatically with React

9.8 KB
Raw Blame
import type {Size} from '@remotion/player';
import React, {useCallback, useContext, useEffect} from 'react';
import {Internals} from 'remotion';
import {writeStaticFile} from '../api/write-static-file';
import type {OnRetry} from '../error-overlay/remotion-overlay/ErrorDisplay';
import {ErrorLoader} from '../error-overlay/remotion-overlay/ErrorLoader';
import {getBrowserStudioOperations} from '../helpers/browser-studio-operations';
import {StudioServerConnectionCtx} from '../helpers/client-id';
import {BACKGROUND, WHITE} from '../helpers/colors';
import {getRoute} from '../helpers/url-state';
import {useResponsiveSidebarStatus} from '../helpers/use-responsive-sidebar-status';
import {BrowseElementsIcon} from '../icons/browse-elements';
import {SearchIcon} from '../icons/search';
import {UploadIcon} from '../icons/upload';
import {FilmIcon} from '../icons/video';
import {CompositionListContext} from '../state/composition-list';
import {SetSelectedModalContext} from '../state/modals';
import {Canvas} from './Canvas';
import {canvasTabsRef} from './CanvasTabsRef';
import {FramePersistor} from './FramePersistor';
import {pickFilesToImport} from './import-assets';
import {
	InspectorQuickAction,
	inspectorActionIconStyle,
	largeInspectorActionIconContainerStyle,
	largeInspectorActionIconStyle,
} from './InspectorPanel/common';
import {VERTICAL_SCROLLBAR_CLASSNAME} from './Menu/is-menu-item';
import {showNotification} from './Notifications/NotificationCenter';
import {RefreshCompositionOverlay} from './RefreshCompositionOverlay';
import {RenderErrorContext} from './RenderErrorContext';
import {
	RunningCalculateMetadata,
	loaderLabel,
} from './RunningCalculateMetadata';
import {getCurrentFrame} from './Timeline/imperative-state';
import {ensureFrameIsInViewport} from './Timeline/timeline-scroll-logic';
import {useSelectAsset} from './use-select-asset';
import {useStaticFiles} from './use-static-files';
import {ZoomPersistor} from './ZoomPersistor';

const container: React.CSSProperties = {
	color: WHITE,
	flex: 1,
	justifyContent: 'center',
	alignItems: 'center',
	display: 'flex',
	backgroundColor: BACKGROUND,
	flexDirection: 'column',
};

const welcomeActions: React.CSSProperties = {
	display: 'flex',
	flexDirection: 'column',
	padding: '4px 0',
	width: 220,
};

const welcomeLabel: React.CSSProperties = {
	...loaderLabel,
	textAlign: 'center',
};

const WelcomeActions: React.FC = () => {
	const {setSelectedModal} = useContext(SetSelectedModalContext);
	const {previewServerState} = useContext(StudioServerConnectionCtx);
	const {compositions} = useContext(Internals.CompositionManager);
	const leftSidebarStatus = useResponsiveSidebarStatus('left');
	const selectAsset = useSelectAsset();
	const staticFiles = useStaticFiles();
	const canMutateProject =
		getBrowserStudioOperations() !== null ||
		(previewServerState.type === 'connected' &&
			!window.remotion_isReadOnlyStudio);

	const newComposition = useCallback(() => {
		setSelectedModal({
			type: 'new-comp',
			folderName: null,
			parentName: null,
			stack: null,
			canvasCapture: null,
		});
	}, [setSelectedModal]);

	const importFiles = useCallback(
		async (files: File[]) => {
			const differentExistingFile = files.find((file) => {
				return staticFiles.some(
					(staticFile) =>
						staticFile.name === file.name &&
						staticFile.sizeInBytes !== file.size,
				);
			});
			if (differentExistingFile) {
				showNotification(
					`File with name ${differentExistingFile.name} already exists and is different`,
					4000,
				);
				return;
			}

			for (const file of files) {
				await writeStaticFile({
					contents: await file.arrayBuffer(),
					filePath: file.name,
				});
			}

			if (files.length > 1 && files.length <= 5) {
				canvasTabsRef.current?.openTabs(
					files.map((file) => ({type: 'asset', asset: file.name})),
				);
			}

			selectAsset(files[0].name);
			showNotification(
				files.length === 1
					? `Uploaded ${files[0].name} to public folder`
					: `Uploaded ${files.length} assets to public folder`,
				3000,
			);
		},
		[selectAsset, staticFiles],
	);

	const importAsset = useCallback(async () => {
		try {
			const files = await pickFilesToImport();
			if (files.length === 0) {
				return;
			}

			await importFiles(files);
		} catch (error) {
			showNotification(`Error during upload: ${error}`, 3000);
		}
	}, [importFiles]);

	const onDragOver: React.DragEventHandler<HTMLDivElement> = useCallback(
		(event) => {
			if (
				!canMutateProject ||
				!Array.from(event.dataTransfer.types).includes('Files')
			) {
				return;
			}

			event.preventDefault();
			event.dataTransfer.dropEffect = 'copy';
		},
		[canMutateProject],
	);

	const onDrop: React.DragEventHandler<HTMLDivElement> = useCallback(
		async (event) => {
			if (
				!canMutateProject ||
				!Array.from(event.dataTransfer.types).includes('Files')
			) {
				return;
			}

			event.preventDefault();
			event.stopPropagation();
			const files = Array.from(event.dataTransfer.files);
			if (files.length === 0) {
				return;
			}

			try {
				await importFiles(files);
			} catch (error) {
				showNotification(`Error during upload: ${error}`, 3000);
			}
		},
		[canMutateProject, importFiles],
	);

	const browseElements = useCallback(() => {
		setSelectedModal({
			type: 'element-library',
			name: 'Remotion Elements',
			url: 'https://www.remotion.dev/elements',
		});
	}, [setSelectedModal]);

	const openComposition = useCallback(() => {
		setSelectedModal({
			type: 'quick-switcher',
			mode: 'compositions',
			invocationTimestamp: Date.now(),
			assetSelection: null,
			compositionSelection: null,
		});
	}, [setSelectedModal]);

	return (
		<div
			style={container}
			className="css-reset"
			onDragOver={onDragOver}
			onDrop={onDrop}
		>
			{canMutateProject ||
			(leftSidebarStatus === 'collapsed' && compositions.length > 0) ? (
				<div style={welcomeActions}>
					{leftSidebarStatus === 'collapsed' && compositions.length > 0 ? (
						<InspectorQuickAction
							disabled={false}
							onClick={openComposition}
							renderIcon={(color) => (
								<SearchIcon color={color} style={inspectorActionIconStyle} />
							)}
						>
							Open composition
						</InspectorQuickAction>
					) : null}
					{canMutateProject ? (
						<>
							<InspectorQuickAction
								disabled={false}
								onClick={newComposition}
								renderIcon={(color) => (
									<FilmIcon color={color} style={inspectorActionIconStyle} />
								)}
							>
								New composition
							</InspectorQuickAction>
							<InspectorQuickAction
								disabled={false}
								onClick={importAsset}
								renderIcon={(color) => (
									<UploadIcon color={color} style={inspectorActionIconStyle} />
								)}
							>
								Import asset
							</InspectorQuickAction>
							<InspectorQuickAction
								disabled={false}
								iconContainerStyle={largeInspectorActionIconContainerStyle}
								onClick={browseElements}
								renderIcon={(color) => (
									<BrowseElementsIcon
										color={color}
										style={largeInspectorActionIconStyle}
									/>
								)}
							>
								Browse Elements
							</InspectorQuickAction>
						</>
					) : null}
				</div>
			) : (
				<div style={welcomeLabel}>Select a composition to get started.</div>
			)}
		</div>
	);
};

export const CanvasOrLoading: React.FC<{
	readonly size: Size;
}> = ({size}) => {
	const resolved = Internals.useResolvedVideoConfig(null);
	const {canvasContent} = useContext(Internals.CompositionManager);
	const {compositionListState} = useContext(CompositionListContext);
	const {error: renderError} = useContext(RenderErrorContext);

	useEffect(() => {
		if (
			resolved?.type !== 'success' &&
			resolved?.type !== 'success-and-refreshing'
		) {
			return;
		}

		const c = resolved.result;

		setTimeout(() => {
			ensureFrameIsInViewport({
				direction: 'center',
				frame: getCurrentFrame(),
				durationInFrames: c.durationInFrames,
			});
		});
	}, [resolved]);

	if (renderError) {
		return (
			<ErrorLoading
				error={renderError}
				calculateMetadataContext={false}
				onRetry={null}
			/>
		);
	}

	if (!canvasContent) {
		if (compositionListState !== 'ready') {
			return null;
		}

		const route = getRoute();
		if (route === '' || route === '/') {
			return <WelcomeActions />;
		}

		return (
			<div style={container} className="css-reset">
				<div style={loaderLabel}>
					Composition with ID {decodeURIComponent(route.substring(1))} not
					found.
				</div>
			</div>
		);
	}

	const content = (
		<>
			<ZoomPersistor />
			<Canvas size={size} canvasContent={canvasContent} />
			{resolved?.type === 'success-and-refreshing' ? (
				<RefreshCompositionOverlay />
			) : null}
		</>
	);
	if (canvasContent.type === 'output' || canvasContent.type === 'output-blob') {
		return content;
	}

	if (canvasContent.type === 'asset' && resolved === null) {
		return content;
	}

	if (!resolved) {
		return null;
	}

	if (resolved.type === 'loading') {
		return (
			<div style={container} className="css-reset">
				<RunningCalculateMetadata />
			</div>
		);
	}

	if (resolved.type === 'error') {
		return (
			<ErrorLoading
				error={resolved.error}
				calculateMetadataContext
				onRetry={() =>
					Internals.resolveCompositionsRef.current?.reloadCurrentlySelectedComposition()
				}
			/>
		);
	}

	return (
		<>
			<FramePersistor /> {content}
		</>
	);
};

const loaderContainer: React.CSSProperties = {
	marginLeft: 'auto',
	marginRight: 'auto',
	width: '100%',
	position: 'absolute',
	height: '100%',
	overflowY: 'auto',
};

const ErrorLoading: React.FC<{
	readonly error: Error;
	readonly calculateMetadataContext: boolean;
	readonly onRetry: OnRetry;
}> = ({error, calculateMetadataContext, onRetry}) => {
	return (
		<div style={loaderContainer} className={VERTICAL_SCROLLBAR_CLASSNAME}>
			<ErrorLoader
				key={error.stack}
				canHaveDismissButton={false}
				keyboardShortcuts
				error={error}
				onRetry={onRetry}
				calculateMetadata={calculateMetadataContext}
			/>
		</div>
	);
};