🎥 Make videos programmatically with React
import {CanvasInternals} from '@remotion/sdk';
import {
Internals,
type DragOverrideValue,
type GetDragOverrides,
type GetEffectDragOverrides,
type PropStatuses,
type SequencePropsSubscriptionKey,
} from 'remotion';
import type {TimelineTreeNode} from '../../helpers/timeline-layout';
import {getTimelineKeyframes} from './get-timeline-keyframes';
const {canEditKeyframeEasing} = CanvasInternals;
const hasOverride = (
overrides: Record<string, DragOverrideValue>,
key: string,
): boolean => Object.prototype.hasOwnProperty.call(overrides, key);
const withDragOverrideKeyframe = ({
propStatus,
keyframeDisplayOffset,
keyframePlaybackRate,
timelinePosition,
dragOverrideValue,
hasDragOverride,
}: {
propStatus: Parameters<typeof getTimelineKeyframes>[0];
keyframeDisplayOffset: number;
keyframePlaybackRate: number;
timelinePosition: number;
dragOverrideValue: DragOverrideValue | undefined;
hasDragOverride: boolean;
}): ReturnType<typeof getTimelineKeyframes> => {
if (dragOverrideValue?.type === 'keyframed') {
return getTimelineKeyframes(
dragOverrideValue.status,
keyframeDisplayOffset,
keyframePlaybackRate,
);
}
const keyframes = getTimelineKeyframes(
propStatus,
keyframeDisplayOffset,
keyframePlaybackRate,
);
if (!hasDragOverride || propStatus?.status !== 'keyframed') {
return keyframes;
}
const dragKeyframe = {
frame: timelinePosition,
value: dragOverrideValue?.value,
};
const existingIndex = keyframes.findIndex(
(keyframe) => keyframe.frame === timelinePosition,
);
if (existingIndex !== -1) {
return keyframes.map((keyframe, index) =>
index === existingIndex ? dragKeyframe : keyframe,
);
}
return [...keyframes, dragKeyframe].sort(
(first, second) => first.frame - second.frame,
);
};
export const getNodeKeyframes = ({
node,
nodePath,
propStatuses,
keyframeDisplayOffset,
keyframePlaybackRate,
getDragOverrides,
getEffectDragOverrides,
timelinePosition,
}: {
node: TimelineTreeNode;
nodePath: SequencePropsSubscriptionKey;
propStatuses: PropStatuses;
keyframeDisplayOffset: number;
keyframePlaybackRate: number;
getDragOverrides: GetDragOverrides;
getEffectDragOverrides: GetEffectDragOverrides;
timelinePosition: number;
}): ReturnType<typeof getTimelineKeyframes> => {
if (node.kind !== 'field' || node.field === null) {
return [];
}
if (node.field.kind === 'sequence-field') {
const dragOverrides = getDragOverrides(nodePath);
return withDragOverrideKeyframe({
propStatus: Internals.getPropStatusesCtx(propStatuses, nodePath)?.[
node.field.key
],
keyframeDisplayOffset,
keyframePlaybackRate,
timelinePosition,
dragOverrideValue: dragOverrides[node.field.key],
hasDragOverride: hasOverride(dragOverrides, node.field.key),
});
}
const effectStatus = Internals.getEffectPropStatusesCtx({
propStatuses,
nodePath,
effectIndex: node.field.effectIndex,
});
const effectDragOverrides = getEffectDragOverrides(
nodePath,
node.field.effectIndex,
);
return withDragOverrideKeyframe({
propStatus:
effectStatus.type === 'can-update-effect'
? effectStatus.props?.[node.field.key]
: null,
keyframeDisplayOffset,
keyframePlaybackRate,
timelinePosition,
dragOverrideValue: effectDragOverrides[node.field.key],
hasDragOverride: hasOverride(effectDragOverrides, node.field.key),
});
};
export const getNodeHasKeyframes = ({
node,
nodePath,
propStatuses,
getDragOverrides,
getEffectDragOverrides,
}: {
node: TimelineTreeNode;
nodePath: SequencePropsSubscriptionKey;
propStatuses: PropStatuses;
getDragOverrides: GetDragOverrides;
getEffectDragOverrides: GetEffectDragOverrides;
}): boolean => {
if (node.kind !== 'field' || node.field === null) {
return false;
}
if (node.field.kind === 'sequence-field') {
const dragOverrides = getDragOverrides(nodePath);
if (dragOverrides[node.field.key]?.type === 'keyframed') {
return true;
}
return (
Internals.getPropStatusesCtx(propStatuses, nodePath)?.[node.field.key]
?.status === 'keyframed'
);
}
const effectDragOverrides = getEffectDragOverrides(
nodePath,
node.field.effectIndex,
);
if (effectDragOverrides[node.field.key]?.type === 'keyframed') {
return true;
}
const effectStatus = Internals.getEffectPropStatusesCtx({
propStatuses,
nodePath,
effectIndex: node.field.effectIndex,
});
return (
effectStatus.type === 'can-update-effect' &&
effectStatus.props?.[node.field.key]?.status === 'keyframed'
);
};
/** Whether the row of a field shows easing segments between its keyframes. */
export const getNodeCanEditEasing = ({
node,
nodePath,
propStatuses,
}: {
node: TimelineTreeNode;
nodePath: SequencePropsSubscriptionKey;
propStatuses: PropStatuses;
}): boolean => {
if (node.kind !== 'field' || node.field === null) {
return false;
}
if (node.field.kind === 'sequence-field') {
return canEditKeyframeEasing({
field: node.field.fieldSchema,
propStatus: Internals.getPropStatusesCtx(propStatuses, nodePath)?.[
node.field.key
],
});
}
const effectStatus = Internals.getEffectPropStatusesCtx({
propStatuses,
nodePath,
effectIndex: node.field.effectIndex,
});
return canEditKeyframeEasing({
field: node.field.fieldSchema,
propStatus:
effectStatus.type === 'can-update-effect'
? effectStatus.props[node.field.key]
: null,
});
};