🎥 Make videos programmatically with React
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,
});
};