Skip to content

🎥 Make videos programmatically with React

4.8 KB
Raw Blame
import {createContext, createRef, useContext, useMemo} from 'react';
import type {AnyComposition} from './CompositionManager.js';
import {
	CompositionManager,
	getAssetPreviewCompositionId,
} from './CompositionManagerContext.js';
import {getInputProps} from './config/input-props.js';
import {EditorPropsContext} from './EditorProps.js';
import type {VideoConfigMetadataSource} from './resolve-video-config.js';
import {useRemotionEnvironment} from './use-remotion-environment.js';
import {validateDimension} from './validation/validate-dimensions.js';
import {validateDurationInFrames} from './validation/validate-duration-in-frames.js';
import {validateFps} from './validation/validate-fps.js';
import type {VideoConfig} from './video-config.js';

type ResolveCompositionConfigContect = Record<
	string,
	VideoConfigState | undefined
>;

export const ResolveCompositionContext =
	createContext<ResolveCompositionConfigContect | null>(null);

export const resolveCompositionsRef = createRef<{
	setCurrentRenderModalComposition: (compositionId: string | null) => void;
	reloadCurrentlySelectedComposition: () => void;
	resolveComposition: (compositionId: string) => Promise<VideoConfig>;
}>();

type VideoConfigState =
	| {
			type: 'loading';
	  }
	| {
			type: 'success';
			result: VideoConfig;
			metadataSource: VideoConfigMetadataSource | null;
	  }
	| {
			type: 'success-and-refreshing';
			result: VideoConfig;
			metadataSource: VideoConfigMetadataSource | null;
	  }
	| {
			type: 'error';
			error: Error;
	  };

export const needsResolution = (composition: AnyComposition) => {
	return Boolean(composition.calculateMetadata);
};

export const useResolvedVideoConfig = (
	preferredCompositionId: string | null,
): VideoConfigState | null => {
	const context = useContext(ResolveCompositionContext);

	const {props: allEditorProps} = useContext(EditorPropsContext);

	const {
		compositions,
		canvasContent,
		currentCompositionMetadata,
		currentAssetMetadata,
	} = useContext(CompositionManager);
	const currentComposition =
		canvasContent?.type === 'composition' ? canvasContent.compositionId : null;
	const compositionId = preferredCompositionId ?? currentComposition;
	const composition = compositions.find((c) => c.id === compositionId);

	const selectedEditorProps = useMemo(() => {
		return composition ? (allEditorProps[composition.id] ?? {}) : {};
	}, [allEditorProps, composition]);

	const env = useRemotionEnvironment();

	return useMemo(() => {
		if (
			preferredCompositionId === null &&
			canvasContent?.type === 'asset' &&
			currentAssetMetadata?.asset === canvasContent.asset
		) {
			return {
				type: 'success',
				metadataSource: null,
				result: {
					...currentAssetMetadata,
					id: getAssetPreviewCompositionId(canvasContent.asset),
					defaultProps: {},
				},
			} as const;
		}

		if (!composition) {
			return null;
		}

		if (currentCompositionMetadata) {
			return {
				type: 'success',
				metadataSource: null,
				result: {
					...currentCompositionMetadata,
					id: composition.id,
					defaultProps: composition.defaultProps ?? {},
				},
			};
		}

		if (!needsResolution(composition)) {
			validateDurationInFrames(composition.durationInFrames, {
				allowFloats: false,
				component: `in <Composition id="${composition.id}">`,
			});
			validateFps(
				composition.fps,
				`in <Composition id="${composition.id}">`,
				false,
			);
			validateDimension(
				composition.width,
				'width',
				`in <Composition id="${composition.id}">`,
			);
			validateDimension(
				composition.height,
				'height',
				`in <Composition id="${composition.id}">`,
			);

			return {
				type: 'success',
				metadataSource: null,
				result: {
					width: composition.width as number,
					height: composition.height as number,
					fps: composition.fps as number,
					id: composition.id,
					durationInFrames: composition.durationInFrames as number,
					defaultProps: composition.defaultProps ?? {},
					props: {
						...(composition.defaultProps ?? {}),
						...(selectedEditorProps ?? {}),
						...(typeof window === 'undefined' ||
						env.isPlayer ||
						// In tests, we don't set window.remotion_inputProps,
						// otherwise it should be available here
						!window.remotion_inputProps
							? {}
							: (getInputProps() ?? {})),
					},
					defaultCodec: null,
					defaultOutName: null,
					defaultVideoImageFormat: null,
					defaultPixelFormat: null,
					defaultProResProfile: null,
					defaultSampleRate: null,
				},
			};
		}

		// Could be the case in selectComposition()
		if (!context) {
			return null;
		}

		if (!context[composition.id]) {
			return null;
		}

		return context[composition.id] as VideoConfigState;
	}, [
		composition,
		canvasContent,
		context,
		currentAssetMetadata,
		currentCompositionMetadata,
		preferredCompositionId,
		selectedEditorProps,
		env.isPlayer,
	]);
};