Skip to content

🎥 Make videos programmatically with React

5.5 KB
Raw Blame
import type {CanUpdateSequencePropStatus, PropStatuses} from 'remotion';
import {Internals} from 'remotion';
import type {
	SequenceNodePathInfo,
	TimelineTrackData,
} from '../../helpers/get-timeline-sequence-sort-key';
import {
	callDeleteKeyframes,
	type DeleteEffectKeyframeChange,
	type DeleteSequenceKeyframeChange,
} from './call-delete-keyframe';
import {findTrackForNodePathInfo} from './find-track-for-node-path-info';
import {
	getKeyframePlaybackRate,
	getKeyframeDisplayOffset,
	getKeyframeSourceFrame,
} from './get-timeline-keyframes';
import {parseKeyframeFieldFromNodePath} from './parse-keyframe-field-from-node-path';
import type {SetPropStatuses} from './save-sequence-prop';

type SelectedKeyframeDeletion =
	| ({type: 'sequence'} & DeleteSequenceKeyframeChange)
	| ({type: 'effect'} & DeleteEffectKeyframeChange);

const getValueWhenLastKeyframeDeleted = ({
	propStatus,
	playheadSourceFrame,
}: {
	propStatus: CanUpdateSequencePropStatus | null | undefined;
	playheadSourceFrame: number;
}): unknown | null => {
	if (propStatus?.status !== 'keyframed') {
		return null;
	}

	return (
		Internals.interpolateKeyframedStatus({
			forceSpringAllowTail: null,
			frame: playheadSourceFrame,
			status: propStatus,
		}) ?? null
	);
};

const getSelectedKeyframeDeletion = ({
	nodePathInfo,
	frame,
	tracks,
	propStatuses,
	timelinePosition,
}: {
	nodePathInfo: SequenceNodePathInfo;
	frame: number;
	readonly tracks: readonly TimelineTrackData[];
	propStatuses: PropStatuses;
	timelinePosition: number;
}): SelectedKeyframeDeletion | null => {
	const field = parseKeyframeFieldFromNodePath(nodePathInfo.auxiliaryKeys);
	if (field === null) {
		return null;
	}

	const track = findTrackForNodePathInfo({
		tracks,
		nodePathInfo,
	});
	const sequence = track?.sequence ?? null;
	if (!sequence?.controls) {
		return null;
	}

	const nodePath = nodePathInfo.sequenceSubscriptionKey;
	const fileName = nodePath.absolutePath;

	if (field.type === 'effect') {
		const effect = sequence.effects[field.effectIndex];
		if (!effect) {
			return null;
		}

		const effectStatus = Internals.getEffectPropStatusesCtx({
			propStatuses,
			nodePath,
			effectIndex: field.effectIndex,
		});
		const effectPropStatus =
			effectStatus?.type === 'can-update-effect'
				? effectStatus.props[field.fieldKey]
				: null;
		const effectKeyframeDisplayOffset = getKeyframeDisplayOffset({
			propStatus: effectPropStatus,
			keyframeDisplayOffset: track?.keyframeDisplayOffset ?? 0,
			keyframePlaybackRate: track?.keyframePlaybackRate ?? 1,
		});
		const effectSourceFrame = getKeyframeSourceFrame({
			displayFrame: frame,
			keyframeDisplayOffset: effectKeyframeDisplayOffset,
			keyframePlaybackRate: track?.keyframePlaybackRate ?? 1,
			propStatus: effectPropStatus,
		});
		const effectPlayheadSourceFrame =
			(timelinePosition - effectKeyframeDisplayOffset) *
			getKeyframePlaybackRate(
				effectPropStatus,
				track?.keyframePlaybackRate ?? 1,
			);
		const effectValueWhenLastKeyframeDeleted = getValueWhenLastKeyframeDeleted({
			propStatus: effectPropStatus,
			playheadSourceFrame: effectPlayheadSourceFrame,
		});

		return {
			type: 'effect',
			fileName,
			nodePath,
			effectIndex: field.effectIndex,
			fieldKey: field.fieldKey,
			sourceFrame: effectSourceFrame,
			schema: effect.schema,
			valueWhenLastKeyframeDeleted: effectValueWhenLastKeyframeDeleted,
		};
	}

	const sequencePropStatus = Internals.getPropStatusesCtx(
		propStatuses,
		nodePath,
	)?.[field.fieldKey];
	const keyframeDisplayOffset = getKeyframeDisplayOffset({
		propStatus: sequencePropStatus ?? null,
		keyframeDisplayOffset: track?.keyframeDisplayOffset ?? 0,
		keyframePlaybackRate: track?.keyframePlaybackRate ?? 1,
	});
	const sourceFrame = getKeyframeSourceFrame({
		displayFrame: frame,
		keyframeDisplayOffset,
		keyframePlaybackRate: track?.keyframePlaybackRate ?? 1,
		propStatus: sequencePropStatus ?? null,
	});
	const playheadSourceFrame =
		(timelinePosition - keyframeDisplayOffset) *
		getKeyframePlaybackRate(
			sequencePropStatus,
			track?.keyframePlaybackRate ?? 1,
		);
	const sequenceValueWhenLastKeyframeDeleted = getValueWhenLastKeyframeDeleted({
		propStatus: sequencePropStatus ?? null,
		playheadSourceFrame,
	});

	return {
		type: 'sequence',
		fileName,
		nodePath,
		fieldKey: field.fieldKey,
		sourceFrame,
		schema: sequence.controls.schema,
		valueWhenLastKeyframeDeleted: sequenceValueWhenLastKeyframeDeleted,
	};
};

export const deleteSelectedKeyframes = ({
	keyframes,
	tracks,
	setPropStatuses,
	clientId,
	propStatuses,
	timelinePosition,
}: {
	keyframes: {
		nodePathInfo: SequenceNodePathInfo;
		frame: number;
	}[];
	readonly tracks: readonly TimelineTrackData[];
	setPropStatuses: SetPropStatuses;
	clientId: string;
	propStatuses: PropStatuses;
	timelinePosition: number;
}): Promise<void> | null => {
	const deletions = keyframes
		.map((keyframe) =>
			getSelectedKeyframeDeletion({
				nodePathInfo: keyframe.nodePathInfo,
				frame: keyframe.frame,
				tracks,
				propStatuses,
				timelinePosition,
			}),
		)
		.filter(
			(deletion): deletion is SelectedKeyframeDeletion => deletion !== null,
		);

	if (deletions.length === 0) {
		return null;
	}

	return callDeleteKeyframes({
		sequenceKeyframes: deletions.filter(
			(
				deletion,
			): deletion is SelectedKeyframeDeletion & {
				type: 'sequence';
			} => deletion.type === 'sequence',
		),
		effectKeyframes: deletions.filter(
			(
				deletion,
			): deletion is SelectedKeyframeDeletion & {
				type: 'effect';
			} => deletion.type === 'effect',
		),
		setPropStatuses,
		clientId,
	});
};