Skip to content

🎥 Make videos programmatically with React

19.1 KB
Raw Blame
import {
	isSchemaFieldHoldOnly,
	isSchemaFieldKeyframable,
	optimisticUpdateForEffectPropStatuses,
} from '@remotion/studio-shared';
import React, {useCallback, useContext, useMemo, useRef} from 'react';
import type {
	CanUpdateSequencePropStatus,
	CanUpdateSequencePropStatusFalse,
	CanUpdateSequencePropStatusKeyframed,
	RuntimeValueStore,
	SequencePropsSubscriptionKey,
} from 'remotion';
import {Internals} from 'remotion';
import type {CodePosition} from '../../error-overlay/react-overlay/utils/get-source-map';
import {canUseEffectOperations} from '../../helpers/browser-studio-operations';
import {StudioServerConnectionCtx} from '../../helpers/client-id';
import {
	formatContextForAgents,
	formatFileLocation,
} from '../../helpers/format-file-location';
import type {SequenceNodePathInfo} from '../../helpers/get-timeline-sequence-sort-key';
import {openOriginalPositionInEditorAtProperty} from '../../helpers/open-in-editor';
import type {EffectSchemaFieldInfo} from '../../helpers/timeline-layout';
import {useRuntimeStoreValue} from '../../helpers/use-runtime-values';
import {ContextMenu} from '../ContextMenu';
import {saveEffectProps} from '../effect-operations-api';
import {getAnnotateWithChatGPTMenuItems} from '../get-annotate-with-chatgpt-menu-item';
import type {ComboboxValue} from '../NewComposition/ComboBox';
import {useSettings} from '../SettingsContext';
import {useEditorOpening} from '../use-default-editor-info';
import {callAddEffectKeyframe} from './call-add-keyframe';
import {getCopyContextForAgentsMenuItem} from './get-copy-context-for-agents-menu-item';
import {
	getKeyframeLocalFrame,
	getKeyframeDisplayOffset,
	getKeyframeSourceFrame,
} from './get-timeline-keyframes';
import {saveEffectProp} from './save-effect-prop';
import {enqueueSavePropChange} from './save-prop-queue';
import {TimelineExpandArrowSpacer} from './TimelineExpandArrowButton';
import {TimelineFieldRowContent} from './TimelineFieldRowContent';
import {
	shouldShowTimelineKeyframeControls,
	TimelineKeyframeControls,
	type TimelineKeyframeControlsMode,
} from './TimelineKeyframeControls';
import {TimelineKeyframedValue} from './TimelineKeyframedValue';
import {TimelineLayerEyeSpacer} from './TimelineLayerEye';
import {TimelineRowChrome} from './TimelineRowChrome';
import {
	TimelineFieldValue,
	TimelineNonEditableStatus,
	UnsupportedStatus,
} from './TimelineSchemaField';
import {
	useTimelineRowContainsSelection,
	useTimelineRowSelection,
} from './TimelineSelection';

const fieldRowBase: React.CSSProperties = {};

const isKeyframedStatus = (
	status: CanUpdateSequencePropStatus,
): status is CanUpdateSequencePropStatusKeyframed => {
	return status.status === 'keyframed';
};

const isResettableStatus = ({
	status,
	defaultValue,
}: {
	readonly status: CanUpdateSequencePropStatus;
	readonly defaultValue: unknown;
}) => {
	if (defaultValue === undefined) {
		return false;
	}

	if (status.status === 'keyframed') {
		return true;
	}

	if (status.status === 'computed') {
		return false;
	}

	const effectiveCodeValue = status.codeValue ?? defaultValue;
	return JSON.stringify(effectiveCodeValue) !== JSON.stringify(defaultValue);
};

const TimelineComputedEffectPropValue: React.FC<{
	readonly field: EffectSchemaFieldInfo;
	readonly propStatus: CanUpdateSequencePropStatusFalse;
	readonly runtimeValueStore: RuntimeValueStore | null;
	readonly validatedLocation: CodePosition;
}> = ({field, propStatus, runtimeValueStore, validatedLocation}) => {
	const runtimeValue = useRuntimeStoreValue(runtimeValueStore, field.key);

	return (
		<TimelineNonEditableStatus
			propStatus={propStatus}
			field={field}
			runtimeValue={runtimeValue}
			validatedLocation={validatedLocation}
		/>
	);
};

export const TimelineEffectPropValue: React.FC<{
	readonly field: EffectSchemaFieldInfo;
	readonly nodePath: SequencePropsSubscriptionKey;
	readonly validatedLocation: CodePosition;
	readonly sourceFrame: number;
	readonly runtimeValueStore: RuntimeValueStore | null;
}> = ({field, nodePath, validatedLocation, sourceFrame, runtimeValueStore}) => {
	const {setEffectDragOverrides, clearEffectDragOverrides, setPropStatuses} =
		useContext(Internals.VisualModeSettersContext);

	const {getEffectDragOverrides} = useContext(
		Internals.VisualModeDragOverridesContext,
	);

	const {propStatuses: visualModePropStatuses} = useContext(
		Internals.VisualModePropStatusesContext,
	);

	const {previewServerState} = useContext(StudioServerConnectionCtx);
	const clientId =
		previewServerState.type === 'connected'
			? previewServerState.clientId
			: null;

	const effectStatus = Internals.getEffectPropStatusesCtx({
		propStatuses: visualModePropStatuses,
		nodePath,
		effectIndex: field.effectIndex,
	});

	const propStatus =
		effectStatus.type === 'can-update-effect'
			? (effectStatus.props?.[field.key] ?? null)
			: null;

	const onDragValueChange = useCallback(
		(value: unknown) => {
			const nextDragOverrideValue =
				propStatus !== null && isKeyframedStatus(propStatus)
					? Internals.makeKeyframedDragOverride({
							status: propStatus,
							frame: sourceFrame,
							value,
							defaultEasing: isSchemaFieldHoldOnly({
								schema: field.effectSchema,
								key: field.key,
							})
								? {type: 'step1'}
								: undefined,
						})
					: Internals.makeStaticDragOverride(value);

			setEffectDragOverrides(
				nodePath,
				field.effectIndex,
				field.key,
				nextDragOverrideValue,
			);
		},
		[
			field.effectIndex,
			field.effectSchema,
			field.key,
			nodePath,
			propStatus,
			setEffectDragOverrides,
			sourceFrame,
		],
	);

	const onDragEnd = useCallback(() => {
		clearEffectDragOverrides(nodePath, field.effectIndex);
	}, [clearEffectDragOverrides, nodePath, field.effectIndex]);

	const dragOverrideValue = useMemo(() => {
		const overrides = getEffectDragOverrides(nodePath, field.effectIndex);
		return overrides[field.key];
	}, [getEffectDragOverrides, nodePath, field.effectIndex, field.key]);

	const onSave = useCallback(
		(value: unknown) => {
			if (!validatedLocation) {
				return Promise.reject(new Error('Cannot save'));
			}

			if (!propStatus) {
				return Promise.reject(new Error('Cannot save'));
			}

			if (propStatus.status !== 'static') {
				return Promise.reject(new Error('Cannot save'));
			}

			if (!clientId) {
				return Promise.reject(new Error('Not connected to studio server'));
			}

			const defaultValue =
				field.fieldSchema.default !== undefined
					? JSON.stringify(field.fieldSchema.default)
					: null;

			const stringifiedValue = JSON.stringify(value);

			if (value === propStatus.codeValue) {
				return Promise.resolve();
			}

			if (
				defaultValue === stringifiedValue &&
				propStatus.codeValue === undefined
			) {
				return Promise.resolve();
			}

			return enqueueSavePropChange({
				nodePath,
				setPropStatuses,
				applyOptimistic: (prev) =>
					optimisticUpdateForEffectPropStatuses({
						previous: prev,
						effectIndex: field.effectIndex,
						fieldKey: field.key,
						value,
						schema: field.effectSchema,
					}),
				apiCall: () =>
					saveEffectProps({
						type: 'value',
						fileName: validatedLocation.source,
						sequenceNodePath: nodePath,
						effectIndex: field.effectIndex,
						key: field.key,
						value: stringifiedValue,
						defaultValue,
						schema: field.effectSchema,
						clientId,
					}),
				errorLabel: 'Could not save effect prop',
			});
		},
		[
			clientId,
			field.effectIndex,
			field.effectSchema,
			field.fieldSchema.default,
			field.key,
			nodePath,
			propStatus,
			setPropStatuses,
			validatedLocation,
		],
	);

	const onSaveKeyframed = useCallback(
		(value: unknown, frame: number) => {
			if (!validatedLocation) {
				return Promise.reject(new Error('Cannot save'));
			}

			if (!clientId) {
				return Promise.reject(new Error('Not connected to studio server'));
			}

			return callAddEffectKeyframe({
				fileName: validatedLocation.source,
				nodePath,
				effectIndex: field.effectIndex,
				fieldKey: field.key,
				sourceFrame: frame,
				value,
				schema: field.effectSchema,
				setPropStatuses,
				clientId,
			});
		},
		[
			clientId,
			field.effectIndex,
			field.effectSchema,
			field.key,
			nodePath,
			setPropStatuses,
			validatedLocation,
		],
	);

	if (field.fieldSchema.type === 'scale') {
		throw new Error(`Effects do not support scale fields: ${field.key}`);
	}

	if (!canUseEffectOperations()) {
		return <UnsupportedStatus label="read only" formattedValue={false} />;
	}

	if (effectStatus.type === 'cannot-update-effect') {
		if (effectStatus.reason === 'computed') {
			return (
				<TimelineComputedEffectPropValue
					propStatus={{status: 'computed'}}
					field={field}
					runtimeValueStore={runtimeValueStore}
					validatedLocation={validatedLocation}
				/>
			);
		}

		if (effectStatus.reason === 'not-call-expression') {
			return <UnsupportedStatus label="not inline" formattedValue={false} />;
		}

		if (effectStatus.reason === 'not-found') {
			return (
				<UnsupportedStatus label="not found in code" formattedValue={false} />
			);
		}

		throw new Error(
			`Unsupported effect status: ${effectStatus.reason satisfies never}`,
		);
	}

	if (effectStatus.type === 'cannot-update-sequence') {
		if (effectStatus.reason === 'not-found') {
			return (
				<UnsupportedStatus label="not found in code" formattedValue={false} />
			);
		}

		if (effectStatus.reason === 'error') {
			return <UnsupportedStatus label="error" formattedValue={false} />;
		}

		throw new Error(
			`Unsupported effect status: ${effectStatus.reason satisfies never}`,
		);
	}

	if (propStatus === null) {
		return null;
	}

	if (isKeyframedStatus(propStatus)) {
		return (
			<TimelineKeyframedValue
				field={field}
				propStatus={propStatus}
				sourceFrame={sourceFrame}
				dragOverrideValue={dragOverrideValue}
				onSave={onSaveKeyframed}
				onDragValueChange={onDragValueChange}
				onDragEnd={onDragEnd}
				scaleLockNodePath={nodePath}
			/>
		);
	}

	if (propStatus.status === 'computed') {
		return (
			<TimelineComputedEffectPropValue
				propStatus={propStatus}
				field={field}
				runtimeValueStore={runtimeValueStore}
				validatedLocation={validatedLocation}
			/>
		);
	}

	const effectiveValue = Internals.getEffectiveVisualModeValue({
		propStatus,
		dragOverrideValue,
		defaultValue: field.fieldSchema.default,
		frame: getKeyframeLocalFrame(sourceFrame, propStatus),
		shouldResortToDefaultValueIfUndefined: true,
	});

	return (
		<TimelineFieldValue
			field={field}
			propStatus={propStatus}
			onSave={onSave}
			onDragValueChange={onDragValueChange}
			onDragEnd={onDragEnd}
			effectiveValue={effectiveValue}
			scaleLockNodePath={null}
		/>
	);
};

const TimelineEffectPropValueAtCurrentFrame: React.FC<{
	readonly field: EffectSchemaFieldInfo;
	readonly nodePath: SequencePropsSubscriptionKey;
	readonly validatedLocation: CodePosition;
	readonly keyframeDisplayOffset: number;
	readonly keyframePlaybackRate: number;
	readonly propStatus: CanUpdateSequencePropStatus | null;
	readonly runtimeValueStore: RuntimeValueStore | null;
	readonly subscribeToTimelinePosition: boolean;
}> = ({
	field,
	nodePath,
	validatedLocation,
	keyframeDisplayOffset,
	keyframePlaybackRate,
	propStatus,
	runtimeValueStore,
	subscribeToTimelinePosition,
}) => {
	const timelinePosition =
		Internals.Timeline.useTimelinePositionWithOptionalSubscription(
			subscribeToTimelinePosition,
		);

	return (
		<TimelineEffectPropValue
			field={field}
			nodePath={nodePath}
			validatedLocation={validatedLocation}
			sourceFrame={getKeyframeSourceFrame({
				displayFrame: timelinePosition,
				keyframeDisplayOffset,
				keyframePlaybackRate,
				propStatus,
			})}
			runtimeValueStore={runtimeValueStore}
		/>
	);
};

export const TimelineEffectPropItem: React.FC<{
	readonly field: EffectSchemaFieldInfo;
	readonly validatedLocation: CodePosition;
	readonly rowDepth: number;
	readonly nodePath: SequencePropsSubscriptionKey;
	readonly nodePathInfo: SequenceNodePathInfo;
	readonly keyframeDisplayOffset: number;
	readonly keyframePlaybackRate: number;
	readonly keyframeControlsMode: TimelineKeyframeControlsMode;
	readonly revealInInspector: boolean;
	readonly runtimeValueStore: RuntimeValueStore | null;
}> = ({
	field,
	validatedLocation,
	rowDepth,
	nodePath,
	nodePathInfo,
	keyframeDisplayOffset,
	keyframePlaybackRate,
	keyframeControlsMode,
	revealInInspector,
	runtimeValueStore,
}) => {
	const {previewServerState} = useContext(StudioServerConnectionCtx);
	const annotationTarget = useRef<HTMLDivElement>(null);
	const {remotionSkillsInfo} = useSettings();
	const markupSkill = remotionSkillsInfo?.skills.find(
		({name}) => name === 'remotion-markup',
	);
	const markupSkillAvailable = Boolean(
		markupSkill?.installedInProject || markupSkill?.installedGlobally,
	);
	const {canOpenInEditor, defaultEditorId} = useEditorOpening(
		previewServerState.type === 'connected',
	);
	const {setPropStatuses} = useContext(Internals.VisualModeSettersContext);
	const {propStatuses} = useContext(Internals.VisualModePropStatusesContext);
	const {getEffectDragOverrides} = useContext(
		Internals.VisualModeDragOverridesContext,
	);
	const selection = useTimelineRowSelection(nodePathInfo, revealInInspector);
	const containsSelection = useTimelineRowContainsSelection(nodePathInfo);
	const style = useMemo((): React.CSSProperties => {
		return field.typeName === 'string' || field.typeName === 'text-content'
			? fieldRowBase
			: {...fieldRowBase, height: field.rowHeight};
	}, [field.rowHeight, field.typeName]);

	const effectStatus = useMemo(
		() =>
			Internals.getEffectPropStatusesCtx({
				propStatuses,
				nodePath,
				effectIndex: field.effectIndex,
			}),
		[propStatuses, nodePath, field.effectIndex],
	);

	const propStatus =
		effectStatus.type === 'can-update-effect'
			? (effectStatus.props?.[field.key] ?? null)
			: null;
	const resolvedKeyframeDisplayOffset = getKeyframeDisplayOffset({
		propStatus,
		keyframeDisplayOffset,
		keyframePlaybackRate,
	});

	const dragOverrideValue = useMemo(() => {
		const overrides = getEffectDragOverrides(nodePath, field.effectIndex);
		return overrides[field.key];
	}, [getEffectDragOverrides, nodePath, field.effectIndex, field.key]);

	const keyframable =
		!(propStatus?.status === 'static' && propStatus.canKeyframe === false) &&
		isSchemaFieldKeyframable({
			schema: field.effectSchema,
			key: field.key,
		});
	const keyframeControls =
		propStatus !== null &&
		(keyframeControlsMode === 'inspector'
			? keyframable
			: shouldShowTimelineKeyframeControls({
					propStatus,
					selected: selection.selected,
					keyframable,
				})) ? (
			<TimelineKeyframeControls
				fieldKey={field.key}
				propStatus={propStatus}
				nodePath={nodePath}
				fileName={validatedLocation.source}
				keyframeDisplayOffset={keyframeDisplayOffset}
				keyframePlaybackRate={keyframePlaybackRate}
				defaultValue={field.fieldSchema.default}
				dragOverrideValue={dragOverrideValue}
				schema={field.effectSchema}
				effectIndex={field.effectIndex}
				nodePathInfo={nodePathInfo}
				mode={keyframeControlsMode}
			/>
		) : null;

	const canResetToDefault = useMemo(() => {
		if (!propStatus || propStatus.status === 'computed') {
			return false;
		}

		return isResettableStatus({
			status: propStatus,
			defaultValue: field.fieldSchema.default,
		});
	}, [field.fieldSchema.default, propStatus]);

	const canPerformReset =
		previewServerState.type === 'connected' &&
		propStatus !== null &&
		propStatus.status !== 'computed';
	const canShowReset =
		canPerformReset && field.fieldSchema.default !== undefined;

	const onReset = useCallback(() => {
		if (
			!canShowReset ||
			!canResetToDefault ||
			previewServerState.type !== 'connected'
		) {
			return;
		}

		const defaultValue =
			field.fieldSchema.default !== undefined
				? JSON.stringify(field.fieldSchema.default)
				: null;

		saveEffectProp({
			type: 'value',
			fileName: validatedLocation.source,
			nodePath,
			effectIndex: field.effectIndex,
			fieldKey: field.key,
			value: field.fieldSchema.default,
			defaultValue,
			schema: field.effectSchema,
			setPropStatuses,
			clientId: previewServerState.clientId,
		});
	}, [
		canResetToDefault,
		canShowReset,
		field.effectIndex,
		field.effectSchema,
		field.fieldSchema.default,
		field.key,
		nodePath,
		previewServerState,
		setPropStatuses,
		validatedLocation.source,
	]);

	const getContextMenuItems = useCallback((): ComboboxValue[] => {
		if (selection.selectable) {
			selection.onSelect({shiftKey: false, toggleKey: false});
		}

		return [
			getCopyContextForAgentsMenuItem({
				contextForAgents: formatContextForAgents({
					location: validatedLocation,
					name: `Effect property "${field.key}"`,
					root: window.remotion_cwd,
				}),
			}),
			...getAnnotateWithChatGPTMenuItems({
				id: 'annotate-effect-property',
				getTarget: () => annotationTarget.current,
				initialComment: markupSkillAvailable ? '$remotion-markup' : null,
				getMetadata: () => ({
					layer: nodePath.nodePath.join('.'),
					layerKeys: JSON.stringify(nodePath.sequenceKeys),
					effectIndex: field.effectIndex,
					effectKeys: JSON.stringify(
						nodePath.effectKeys[field.effectIndex] ?? [],
					),
					property: field.key,
					source:
						formatFileLocation({
							location: validatedLocation,
							root: window.remotion_cwd,
						}) ?? validatedLocation.source,
				}),
			}),
			{
				type: 'divider',
				id: 'copy-context-for-agents-divider',
			},
			{
				type: 'item',
				id: 'reset-effect-field',
				keyHint: null,
				label: 'Reset',
				leftItem: null,
				disabled: !canShowReset,
				onClick: onReset,
				quickSwitcherLabel: null,
				subMenu: null,
				value: 'reset-effect-field',
			},
		];
	}, [
		canShowReset,
		field.effectIndex,
		field.key,
		markupSkillAvailable,
		nodePath,
		onReset,
		selection,
		validatedLocation,
	]);

	const onPropertyDoubleClick = useCallback<
		React.MouseEventHandler<HTMLDivElement>
	>(
		(event) => {
			if (!canOpenInEditor || !defaultEditorId) {
				return;
			}

			event.stopPropagation();
			openOriginalPositionInEditorAtProperty({
				editorId: defaultEditorId,
				originalPosition: validatedLocation,
				property: field.key,
			}).catch(() => undefined);
		},
		[canOpenInEditor, defaultEditorId, field.key, validatedLocation],
	);

	const row = (
		<TimelineRowChrome
			depth={rowDepth}
			eye={<TimelineLayerEyeSpacer />}
			keyframeControls={keyframeControls}
			arrow={<TimelineExpandArrowSpacer />}
			style={style}
			selected={selection.selected}
			selectable={selection.selectable}
			onSelect={selection.onSelect}
			onDoubleClick={onPropertyDoubleClick}
			showSelectedBackground
			containsSelection={containsSelection}
			outerHeight={null}
			showBottomBorder={false}
		>
			<TimelineFieldRowContent
				field={field}
				rowDepth={rowDepth}
				selected={selection.selected || containsSelection}
			>
				<TimelineEffectPropValueAtCurrentFrame
					field={field}
					nodePath={nodePath}
					validatedLocation={validatedLocation}
					keyframeDisplayOffset={resolvedKeyframeDisplayOffset}
					keyframePlaybackRate={keyframePlaybackRate}
					propStatus={propStatus}
					runtimeValueStore={runtimeValueStore}
					subscribeToTimelinePosition={
						propStatus?.status === 'keyframed' ||
						dragOverrideValue?.type === 'keyframed'
					}
				/>
			</TimelineFieldRowContent>
		</TimelineRowChrome>
	);

	return (
		<ContextMenu ref={annotationTarget} getItems={getContextMenuItems}>
			{row}
		</ContextMenu>
	);
};