Skip to content

🎥 Make videos programmatically with React

`@remotion/studio`: Retime keyframes when changing `playbackRate`

Jonny Burger654284dc5968
diff --git a/packages/studio/src/components/Timeline/TimelineSequencePropItem.tsx b/packages/studio/src/components/Timeline/TimelineSequencePropItem.tsx
index bbc2a1c6e6..a9ff427713 100644
--- a/packages/studio/src/components/Timeline/TimelineSequencePropItem.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequencePropItem.tsx
@@ -28,6 +28,7 @@ import type {ComboboxValue} from '../NewComposition/ComboBox';
import {useEditorOpening} from '../use-default-editor-info';
import {callAddSequenceKeyframe} from './call-add-keyframe';
import {getCopyContextForAgentsMenuItem} from './get-copy-context-for-agents-menu-item';
+import {getPlaybackRateKeyframeChanges} from './get-playback-rate-keyframe-changes';
import {getSequencePropResetChanges} from './get-sequence-prop-reset-changes';
import {
getKeyframeDisplayOffset,
@@ -98,6 +99,29 @@ const isResettableStatus = ({
return JSON.stringify(effectiveCodeValue) !== JSON.stringify(defaultValue);
};
+const getPlaybackRateAdjustedDuration = ({
+ durationInFrames,
+ previousPlaybackRate,
+ playbackRate,
+}: {
+ readonly durationInFrames: number;
+ readonly previousPlaybackRate: number;
+ readonly playbackRate: number;
+}): number | null => {
+ const adjustedDuration =
+ (durationInFrames * previousPlaybackRate) / playbackRate;
+ if (!Number.isFinite(adjustedDuration) || adjustedDuration <= 0) {
+ return null;
+ }
+
+ const nearestInteger = Math.round(adjustedDuration);
+ return nearestInteger > 0 &&
+ Math.abs(adjustedDuration - nearestInteger) <=
+ Number.EPSILON * Math.max(1, Math.abs(adjustedDuration)) * 2
+ ? nearestInteger
+ : adjustedDuration;
+};
+
const Value: React.FC<{
readonly field: SchemaFieldInfo;
readonly nodePath: SequencePropsSubscriptionKey;
@@ -119,6 +143,57 @@ const Value: React.FC<{
lastSavedDurationInFrames: number;
lastSavedPlaybackRate: number;
} | null>(null);
+ const previewedKeyframes = useRef<
+ ReturnType<typeof getPlaybackRateKeyframeChanges>['previews']
+ >([]);
+ const propStatusesRef = useContext(
+ Internals.VisualModePropStatusesRefContext,
+ );
+ const sequencesRef = useContext(Internals.SequenceManagerRefContext);
+ const {overrideIdToNodePathMappings} = useContext(
+ Internals.OverrideIdsToNodePathsGettersContext,
+ );
+ const getPlaybackRateChanges = useCallback(
+ (value: unknown) => {
+ if (
+ field.key !== 'playbackRate' ||
+ nodePath === null ||
+ typeof value !== 'number'
+ ) {
+ return null;
+ }
+
+ const currentStatus = Internals.getPropStatusesCtx(
+ propStatusesRef.current,
+ nodePath,
+ )?.playbackRate;
+ const previousPlaybackRate =
+ currentStatus?.status === 'static' &&
+ typeof currentStatus.codeValue === 'number'
+ ? currentStatus.codeValue
+ : field.fieldSchema.default;
+ if (typeof previousPlaybackRate !== 'number') {
+ return null;
+ }
+
+ return getPlaybackRateKeyframeChanges({
+ nodePath,
+ sequences: sequencesRef.current,
+ overrideIdsToNodePaths: overrideIdToNodePathMappings,
+ propStatuses: propStatusesRef.current,
+ previousPlaybackRate,
+ playbackRate: value,
+ });
+ },
+ [
+ field.fieldSchema.default,
+ field.key,
+ nodePath,
+ overrideIdToNodePathMappings,
+ propStatusesRef,
+ sequencesRef,
+ ],
+ );
const getAdjustedDuration = useCallback(
(playbackRate: unknown): number | null => {
if (
@@ -168,18 +243,11 @@ const Value: React.FC<{
playbackRateBaseline.current = baseline;
}
- const adjustedDuration =
- (baseline.durationInFrames * baseline.playbackRate) / playbackRate;
- if (!Number.isFinite(adjustedDuration) || adjustedDuration <= 0) {
- return null;
- }
-
- const nearestInteger = Math.round(adjustedDuration);
- return nearestInteger > 0 &&
- Math.abs(adjustedDuration - nearestInteger) <=
- Number.EPSILON * Math.max(1, Math.abs(adjustedDuration)) * 2
- ? nearestInteger
- : adjustedDuration;
+ return getPlaybackRateAdjustedDuration({
+ durationInFrames: baseline.durationInFrames,
+ previousPlaybackRate: baseline.playbackRate,
+ playbackRate,
+ });
},
[
durationPropStatus,
@@ -192,9 +260,12 @@ const Value: React.FC<{
const {getDragOverrides} = useContext(
Internals.VisualModeDragOverridesContext,
);
- const {setDragOverrides, clearDragOverrides} = useContext(
- Internals.VisualModeSettersContext,
- );
+ const {
+ setDragOverrides,
+ clearDragOverrides,
+ setEffectDragOverrides,
+ clearEffectDragOverrides,
+ } = useContext(Internals.VisualModeSettersContext);
const dragOverrideValue = useMemo(() => {
return nodePath === null
? undefined
@@ -231,6 +302,7 @@ const Value: React.FC<{
const stringifiedValue = JSON.stringify(value);
const fieldLabel = field.description ?? field.key;
const adjustedDuration = getAdjustedDuration(value);
+ const keyframeChanges = getPlaybackRateChanges(value);
if (value === propStatus.codeValue) {
return Promise.resolve();
@@ -252,7 +324,12 @@ const Value: React.FC<{
return unstable_batchedUpdates(() =>
saveSequenceProps({
addedKeyframes: null,
- movedKeyframes: null,
+ movedKeyframes: keyframeChanges
+ ? {
+ sequenceKeyframes: keyframeChanges.sequenceKeyframes,
+ effectKeyframes: keyframeChanges.effectKeyframes,
+ }
+ : null,
changes: [
{
fileName: validatedLocation.source,
@@ -291,6 +368,7 @@ const Value: React.FC<{
field.fieldSchema.type,
field.key,
getAdjustedDuration,
+ getPlaybackRateChanges,
nodePath,
schema,
setPropStatuses,
@@ -305,7 +383,17 @@ const Value: React.FC<{
}
const adjustedDuration = getAdjustedDuration(value);
+ const keyframeChanges = getPlaybackRateChanges(value);
unstable_batchedUpdates(() => {
+ for (const preview of previewedKeyframes.current) {
+ if (preview.effectIndex === null) {
+ clearDragOverrides(preview.nodePath);
+ } else {
+ clearEffectDragOverrides(preview.nodePath, preview.effectIndex);
+ }
+ }
+
+ previewedKeyframes.current = keyframeChanges?.previews ?? [];
setDragOverrides(
nodePath,
field.key,
@@ -318,9 +406,34 @@ const Value: React.FC<{
Internals.makeStaticDragOverride(adjustedDuration),
);
}
+
+ for (const preview of previewedKeyframes.current) {
+ if (preview.effectIndex === null) {
+ setDragOverrides(preview.nodePath, preview.fieldKey, {
+ type: 'keyframed',
+ status: preview.status,
+ });
+ } else {
+ setEffectDragOverrides(
+ preview.nodePath,
+ preview.effectIndex,
+ preview.fieldKey,
+ {type: 'keyframed', status: preview.status},
+ );
+ }
+ }
});
},
- [setDragOverrides, nodePath, field.key, getAdjustedDuration],
+ [
+ clearDragOverrides,
+ clearEffectDragOverrides,
+ setDragOverrides,
+ setEffectDragOverrides,
+ nodePath,
+ field.key,
+ getAdjustedDuration,
+ getPlaybackRateChanges,
+ ],
);
const onDragEnd = useCallback(() => {
@@ -329,7 +442,16 @@ const Value: React.FC<{
}
clearDragOverrides(nodePath);
- }, [clearDragOverrides, nodePath]);
+ for (const preview of previewedKeyframes.current) {
+ if (preview.effectIndex === null) {
+ clearDragOverrides(preview.nodePath);
+ } else {
+ clearEffectDragOverrides(preview.nodePath, preview.effectIndex);
+ }
+ }
+
+ previewedKeyframes.current = [];
+ }, [clearDragOverrides, clearEffectDragOverrides, nodePath]);
return (
<TimelineFieldValue
@@ -559,6 +681,13 @@ export const TimelineSequencePropItem: React.FC<{
const {propStatuses: visualModePropStatuses} = useContext(
Internals.VisualModePropStatusesContext,
);
+ const propStatusesRef = useContext(
+ Internals.VisualModePropStatusesRefContext,
+ );
+ const sequencesRef = useContext(Internals.SequenceManagerRefContext);
+ const {overrideIdToNodePathMappings} = useContext(
+ Internals.OverrideIdsToNodePathsGettersContext,
+ );
const {getDragOverrides} = useContext(
Internals.VisualModeDragOverridesContext,
);
@@ -648,18 +777,74 @@ export const TimelineSequencePropItem: React.FC<{
? JSON.stringify(field.fieldSchema.default)
: null;
const fieldLabel = field.description ?? field.key;
+ const previousPlaybackRate =
+ field.key === 'playbackRate' &&
+ propStatus.status === 'static' &&
+ typeof propStatus.codeValue === 'number'
+ ? propStatus.codeValue
+ : null;
+ const nextPlaybackRate = field.fieldSchema.default;
+ const canRetime =
+ previousPlaybackRate !== null &&
+ Number.isFinite(previousPlaybackRate) &&
+ previousPlaybackRate > 0 &&
+ typeof nextPlaybackRate === 'number' &&
+ Number.isFinite(nextPlaybackRate) &&
+ nextPlaybackRate > 0;
+ const keyframeChanges = canRetime
+ ? getPlaybackRateKeyframeChanges({
+ nodePath,
+ sequences: sequencesRef.current,
+ overrideIdsToNodePaths: overrideIdToNodePathMappings,
+ propStatuses: propStatusesRef.current,
+ previousPlaybackRate,
+ playbackRate: nextPlaybackRate,
+ })
+ : null;
+ const durationStatus = propStatusesForOverride?.durationInFrames;
+ const adjustedDuration =
+ canRetime &&
+ schema.durationInFrames &&
+ durationStatus?.status === 'static' &&
+ typeof durationStatus.codeValue === 'number' &&
+ Number.isFinite(durationStatus.codeValue)
+ ? getPlaybackRateAdjustedDuration({
+ durationInFrames: durationStatus.codeValue,
+ previousPlaybackRate,
+ playbackRate: nextPlaybackRate,
+ })
+ : null;
saveSequenceProps({
addedKeyframes: null,
- movedKeyframes: null,
- changes: getSequencePropResetChanges({
- fileName: validatedLocation.source,
- nodePath,
- fieldKey: field.key,
- value: field.fieldSchema.default,
- defaultValue,
- schema,
- }),
+ movedKeyframes: keyframeChanges
+ ? {
+ sequenceKeyframes: keyframeChanges.sequenceKeyframes,
+ effectKeyframes: keyframeChanges.effectKeyframes,
+ }
+ : null,
+ changes: [
+ ...getSequencePropResetChanges({
+ fileName: validatedLocation.source,
+ nodePath,
+ fieldKey: field.key,
+ value: field.fieldSchema.default,
+ defaultValue,
+ schema,
+ }),
+ ...(adjustedDuration !== null
+ ? [
+ {
+ fileName: validatedLocation.source,
+ nodePath,
+ fieldKey: 'durationInFrames',
+ value: adjustedDuration,
+ defaultValue: null,
+ schema,
+ },
+ ]
+ : []),
+ ],
setPropStatuses,
clientId: previewServerState.clientId,
undoLabel: `Reset ${fieldLabel}`,
@@ -672,8 +857,12 @@ export const TimelineSequencePropItem: React.FC<{
field.fieldSchema.default,
field.key,
nodePath,
+ overrideIdToNodePathMappings,
previewServerState,
+ propStatusesForOverride?.durationInFrames,
+ propStatusesRef,
schema,
+ sequencesRef,
setPropStatuses,
validatedLocation.source,
propStatus,
diff --git a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
index 0158beb866..c022b50c63 100644
--- a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
@@ -34,6 +34,11 @@ import type {
MoveEffectKeyframeChange,
MoveSequenceKeyframeChange,
} from './call-move-keyframe';
+import {
+ getKeyframedSequenceDragTargets,
+ type TimelineSequenceEffectKeyframeDragTarget,
+ type TimelineSequenceKeyframeDragTarget,
+} from './get-keyframed-sequence-drag-targets';
import {
saveSequenceProps,
type SaveSequencePropChange,
@@ -204,103 +209,6 @@ export type TimelineSequenceFromDragTarget = {
readonly sequenceKeyframes: TimelineSequenceKeyframeDragTarget[];
};
-type TimelineSequenceKeyframeDragTarget = {
- readonly parentPlaybackRate: number;
- readonly fileName: string;
- readonly fieldKey: string;
- readonly isDescendant: boolean;
- readonly nodePath: SequencePropsSubscriptionKey;
- readonly schema: InteractivitySchema;
- readonly status: CanUpdateSequencePropStatusKeyframed;
-};
-
-type TimelineSequenceEffectKeyframeDragTarget =
- TimelineSequenceKeyframeDragTarget & {
- readonly effectIndex: number;
- };
-
-const getKeyframedSequenceDragTargets = ({
- nodePath,
- sequence,
- sequences,
- propStatuses,
- isDescendant,
-}: {
- readonly nodePath: SequencePropsSubscriptionKey;
- readonly sequence: TSequence;
- readonly sequences: TSequence[];
- readonly propStatuses: PropStatuses;
- readonly isDescendant: boolean;
-}): {
- readonly effectKeyframes: TimelineSequenceEffectKeyframeDragTarget[];
- readonly sequenceKeyframes: TimelineSequenceKeyframeDragTarget[];
-} => {
- const status =
- propStatuses[Internals.makeSequencePropsSubscriptionKey(nodePath)];
- if (status === null || status === undefined || !status.canUpdate) {
- return {effectKeyframes: [], sequenceKeyframes: []};
- }
-
- const sequenceSchema = sequence.controls?.schema;
- const sequenceKeyframes =
- sequenceSchema === undefined
- ? []
- : Object.entries(status.props).flatMap(([fieldKey, propStatus]) =>
- propStatus.status === 'keyframed' &&
- (!isDescendant || propStatus.keyframeDisplayOffsetAdjustment !== null)
- ? [
- {
- parentPlaybackRate: getParentSequencePlaybackRate(
- sequence,
- sequences,
- ),
- fileName: nodePath.absolutePath,
- fieldKey,
- isDescendant,
- nodePath,
- schema: sequenceSchema,
- status: propStatus,
- },
- ]
- : [],
- );
-
- const effectKeyframes = status.effects.flatMap((effectStatus) => {
- if (!effectStatus.canUpdate) {
- return [];
- }
-
- const effectSchema = sequence.effects[effectStatus.effectIndex]?.schema;
- if (effectSchema === undefined) {
- return [];
- }
-
- return Object.entries(effectStatus.props).flatMap(
- ([fieldKey, propStatus]) =>
- propStatus.status === 'keyframed' &&
- (!isDescendant || propStatus.keyframeDisplayOffsetAdjustment !== null)
- ? [
- {
- effectIndex: effectStatus.effectIndex,
- parentPlaybackRate: getParentSequencePlaybackRate(
- sequence,
- sequences,
- ),
- fileName: nodePath.absolutePath,
- fieldKey,
- isDescendant,
- nodePath,
- schema: effectSchema,
- status: propStatus,
- },
- ]
- : [],
- );
- });
-
- return {effectKeyframes, sequenceKeyframes};
-};
-
const shiftKeyframedStatus = ({
status,
deltaFrames,
diff --git a/packages/studio/src/components/Timeline/get-keyframed-sequence-drag-targets.ts b/packages/studio/src/components/Timeline/get-keyframed-sequence-drag-targets.ts
new file mode 100644
index 0000000000..2ecd16946b
--- /dev/null
+++ b/packages/studio/src/components/Timeline/get-keyframed-sequence-drag-targets.ts
@@ -0,0 +1,108 @@
+import {CanvasInternals} from '@remotion/canvas';
+import type {
+ CanUpdateSequencePropStatusKeyframed,
+ InteractivitySchema,
+ PropStatuses,
+ SequencePropsSubscriptionKey,
+ TSequence,
+} from 'remotion';
+import {Internals} from 'remotion';
+
+const {getParentSequencePlaybackRate} = CanvasInternals;
+
+export type TimelineSequenceKeyframeDragTarget = {
+ readonly parentPlaybackRate: number;
+ readonly fileName: string;
+ readonly fieldKey: string;
+ readonly isDescendant: boolean;
+ readonly nodePath: SequencePropsSubscriptionKey;
+ readonly schema: InteractivitySchema;
+ readonly status: CanUpdateSequencePropStatusKeyframed;
+};
+
+export type TimelineSequenceEffectKeyframeDragTarget =
+ TimelineSequenceKeyframeDragTarget & {
+ readonly effectIndex: number;
+ };
+
+export const getKeyframedSequenceDragTargets = ({
+ nodePath,
+ sequence,
+ sequences,
+ propStatuses,
+ isDescendant,
+}: {
+ readonly nodePath: SequencePropsSubscriptionKey;
+ readonly sequence: TSequence;
+ readonly sequences: TSequence[];
+ readonly propStatuses: PropStatuses;
+ readonly isDescendant: boolean;
+}): {
+ readonly effectKeyframes: TimelineSequenceEffectKeyframeDragTarget[];
+ readonly sequenceKeyframes: TimelineSequenceKeyframeDragTarget[];
+} => {
+ const status =
+ propStatuses[Internals.makeSequencePropsSubscriptionKey(nodePath)];
+ if (status === null || status === undefined || !status.canUpdate) {
+ return {effectKeyframes: [], sequenceKeyframes: []};
+ }
+
+ const sequenceSchema = sequence.controls?.schema;
+ const sequenceKeyframes =
+ sequenceSchema === undefined
+ ? []
+ : Object.entries(status.props).flatMap(([fieldKey, propStatus]) =>
+ propStatus.status === 'keyframed' &&
+ (!isDescendant || propStatus.keyframeDisplayOffsetAdjustment !== null)
+ ? [
+ {
+ parentPlaybackRate: getParentSequencePlaybackRate(
+ sequence,
+ sequences,
+ ),
+ fileName: nodePath.absolutePath,
+ fieldKey,
+ isDescendant,
+ nodePath,
+ schema: sequenceSchema,
+ status: propStatus,
+ },
+ ]
+ : [],
+ );
+
+ const effectKeyframes = status.effects.flatMap((effectStatus) => {
+ if (!effectStatus.canUpdate) {
+ return [];
+ }
+
+ const effectSchema = sequence.effects[effectStatus.effectIndex]?.schema;
+ if (effectSchema === undefined) {
+ return [];
+ }
+
+ return Object.entries(effectStatus.props).flatMap(
+ ([fieldKey, propStatus]) =>
+ propStatus.status === 'keyframed' &&
+ (!isDescendant || propStatus.keyframeDisplayOffsetAdjustment !== null)
+ ? [
+ {
+ effectIndex: effectStatus.effectIndex,
+ parentPlaybackRate: getParentSequencePlaybackRate(
+ sequence,
+ sequences,
+ ),
+ fileName: nodePath.absolutePath,
+ fieldKey,
+ isDescendant,
+ nodePath,
+ schema: effectSchema,
+ status: propStatus,
+ },
+ ]
+ : [],
+ );
+ });
+
+ return {effectKeyframes, sequenceKeyframes};
+};
diff --git a/packages/studio/src/components/Timeline/get-playback-rate-keyframe-changes.ts b/packages/studio/src/components/Timeline/get-playback-rate-keyframe-changes.ts
new file mode 100644
index 0000000000..7bcf10fe91
--- /dev/null
+++ b/packages/studio/src/components/Timeline/get-playback-rate-keyframe-changes.ts
@@ -0,0 +1,203 @@
+import {stringifySequenceSubscriptionKey} from '@remotion/studio-shared';
+import type {
+ CanUpdateSequencePropStatusKeyframed,
+ OverrideIdToNodePaths,
+ PropStatuses,
+ SequencePropsSubscriptionKey,
+ TSequence,
+} from 'remotion';
+import type {
+ MoveEffectKeyframeChange,
+ MoveSequenceKeyframeChange,
+} from './call-move-keyframe';
+import {
+ getKeyframedSequenceDragTargets,
+ type TimelineSequenceEffectKeyframeDragTarget,
+ type TimelineSequenceKeyframeDragTarget,
+} from './get-keyframed-sequence-drag-targets';
+
+type KeyframePreview = {
+ readonly nodePath: SequencePropsSubscriptionKey;
+ readonly fieldKey: string;
+ readonly effectIndex: number | null;
+ readonly status: CanUpdateSequencePropStatusKeyframed;
+};
+
+export const getPlaybackRateKeyframeChanges = ({
+ nodePath,
+ sequences,
+ overrideIdsToNodePaths,
+ propStatuses,
+ previousPlaybackRate,
+ playbackRate,
+}: {
+ readonly nodePath: SequencePropsSubscriptionKey;
+ readonly sequences: TSequence[];
+ readonly overrideIdsToNodePaths: OverrideIdToNodePaths;
+ readonly propStatuses: PropStatuses;
+ readonly previousPlaybackRate: number;
+ readonly playbackRate: number;
+}): {
+ readonly sequenceKeyframes: MoveSequenceKeyframeChange[];
+ readonly effectKeyframes: MoveEffectKeyframeChange[];
+ readonly previews: KeyframePreview[];
+} => {
+ const sequenceKeyframes: MoveSequenceKeyframeChange[] = [];
+ const effectKeyframes: MoveEffectKeyframeChange[] = [];
+ const previews: KeyframePreview[] = [];
+ if (
+ previousPlaybackRate === playbackRate ||
+ !Number.isFinite(previousPlaybackRate) ||
+ previousPlaybackRate <= 0 ||
+ !Number.isFinite(playbackRate) ||
+ playbackRate <= 0
+ ) {
+ return {sequenceKeyframes, effectKeyframes, previews};
+ }
+
+ const key = stringifySequenceSubscriptionKey(nodePath);
+ const root = sequences.find((sequence) => {
+ const overrideId = sequence.controls?.overrideId;
+ const path = overrideId ? overrideIdsToNodePaths[overrideId] : undefined;
+ return path && stringifySequenceSubscriptionKey(path) === key;
+ });
+ if (!root) {
+ return {sequenceKeyframes, effectKeyframes, previews};
+ }
+
+ const sequencesById = new Map(
+ sequences.map((sequence) => [sequence.id, sequence]),
+ );
+ const ratio = previousPlaybackRate / playbackRate;
+ const includedNodePaths = new Set<string>();
+
+ for (const sequence of sequences) {
+ let ancestorId: string | null = sequence.id;
+ let belongsToRoot = false;
+ let descendantOffset = 0;
+ while (ancestorId !== null) {
+ if (ancestorId === root.id) {
+ belongsToRoot = true;
+ break;
+ }
+
+ const ancestor = sequencesById.get(ancestorId);
+ if (!ancestor) {
+ break;
+ }
+
+ descendantOffset += ancestor.from - (ancestor.trimBefore ?? 0);
+ ancestorId = ancestor.parent;
+ }
+
+ if (!belongsToRoot) {
+ continue;
+ }
+
+ const overrideId = sequence.controls?.overrideId;
+ const descendantNodePath = overrideId
+ ? overrideIdsToNodePaths[overrideId]
+ : undefined;
+ if (!descendantNodePath) {
+ continue;
+ }
+
+ const descendantKey = stringifySequenceSubscriptionKey(descendantNodePath);
+ if (includedNodePaths.has(descendantKey)) {
+ continue;
+ }
+
+ includedNodePaths.add(descendantKey);
+ // Local-clock descendant keyframes already follow their parent's rate.
+ // The shared collector includes only outer-clock descendants.
+ const targets = getKeyframedSequenceDragTargets({
+ nodePath: descendantNodePath,
+ sequence,
+ sequences,
+ propStatuses,
+ isDescendant: sequence.id !== root.id,
+ });
+
+ const addMoves = (
+ target:
+ | TimelineSequenceKeyframeDragTarget
+ | TimelineSequenceEffectKeyframeDragTarget,
+ effectIndex: number | null,
+ ) => {
+ const adjustment = target.status.keyframeDisplayOffsetAdjustment ?? 0;
+ // The adjustment includes the timing offsets between this element and
+ // the useCurrentFrame() binding. Remove the descendant offsets to find
+ // the edited element's start in that binding's source clock.
+ const anchor =
+ sequence.id === root.id
+ ? root.from - adjustment
+ : -adjustment - descendantOffset;
+ if (!Number.isFinite(anchor)) {
+ return;
+ }
+
+ const nextKeyframes = target.status.keyframes.map((keyframe) => {
+ const frame = anchor + (keyframe.frame - anchor) * ratio;
+ const nearestInteger = Math.round(frame);
+ return {
+ ...keyframe,
+ frame:
+ Math.abs(frame - nearestInteger) <=
+ Number.EPSILON * Math.max(1, Math.abs(frame)) * 2
+ ? nearestInteger
+ : frame,
+ };
+ });
+ if (
+ nextKeyframes.some((keyframe) => !Number.isFinite(keyframe.frame)) ||
+ new Set(nextKeyframes.map((keyframe) => keyframe.frame)).size !==
+ nextKeyframes.length
+ ) {
+ return;
+ }
+
+ const moves = target.status.keyframes.flatMap((keyframe, index) => {
+ const toFrame = nextKeyframes[index]?.frame;
+ if (toFrame === undefined || toFrame === keyframe.frame) {
+ return [];
+ }
+
+ return [
+ {
+ fileName: target.fileName,
+ nodePath: target.nodePath,
+ fieldKey: target.fieldKey,
+ fromFrame: keyframe.frame,
+ toFrame,
+ schema: target.schema,
+ },
+ ];
+ });
+ if (moves.length === 0) {
+ return;
+ }
+
+ previews.push({
+ nodePath: target.nodePath,
+ fieldKey: target.fieldKey,
+ effectIndex,
+ status: {...target.status, keyframes: nextKeyframes},
+ });
+ if (effectIndex === null) {
+ sequenceKeyframes.push(...moves);
+ } else {
+ effectKeyframes.push(...moves.map((move) => ({...move, effectIndex})));
+ }
+ };
+
+ for (const target of targets.sequenceKeyframes) {
+ addMoves(target, null);
+ }
+
+ for (const target of targets.effectKeyframes) {
+ addMoves(target, target.effectIndex);
+ }
+ }
+
+ return {sequenceKeyframes, effectKeyframes, previews};
+};