🎥 Make videos programmatically with React
"use client";
import { Internals } from "remotion";
import {
canvasKeyframeEasingPresets,
getCanvasSelectionItemKey,
getCanvasSequenceReorderInsertionIndex,
getCanvasSequenceReorderSelection,
startCanvasKeyframeDrag,
useCanvasSelection,
useCanvasSequenceHover,
type CanvasKeyframeDragTarget,
type CanvasKeyframeEasingSegment,
type CanvasSelectionInteraction,
} from "@remotion/sdk";
import { getNodeProps } from "@remotion/codemods";
import type { NodeReference } from "@remotion/codemods";
import {
ChevronDownIcon,
ChevronRightIcon,
FilmIcon,
ImageIcon,
LayersIcon,
Music2Icon,
ZoomInIcon,
ZoomOutIcon,
} from "lucide-react";
import React, {
memo,
useCallback,
useEffect,
useMemo,
useRef,
useState,
} from "react";
import {
ContextMenu,
ContextMenuContent,
ContextMenuItem,
ContextMenuTrigger,
} from "@/components/ui/context-menu";
import { cn } from "@/lib/utils";
import { usePlaybackFrame } from "../../hooks/use-playback";
import { getErrorMessage } from "../../hooks/use-preview-host";
import {
findKeyframedProp,
getEasingSelectionItem,
getKeyframeSelectionItem,
getSelectedEasings,
getSelectedKeyframes,
type KeyframedProp,
type KeyframeSelectionItem,
} from "../../model/keyframes";
import {
areSiblingNodes,
getLayerLabel,
getNodeReference,
type Layer,
} from "../../model/layers";
import {
getFieldLabel,
getLayerSchema,
hasTimingProps,
} from "../../model/schemas";
import { clamp, formatTimecode } from "../../model/values";
import { useEditor } from "../../state/editor-context";
import { fallbackSelectionController } from "../../state/fallback-selection";
import { EasingCurve } from "../EasingCurve";
import { LayerContextMenu } from "../Inspector/LayerActions";
import { KeyframeDiamond } from "../KeyframeDiamond";
import { ToolbarButton } from "../TopBar";
const LABEL_WIDTH = 220;
const RULER_HEIGHT = 26;
const ROW_HEIGHT = 30;
const KEYFRAME_ROW_HEIGHT = 22;
const EDGE_WIDTH = 7;
const playbackRateComponentIdentities = new Set([
"dev.remotion.gif.Gif",
"dev.remotion.media.Audio",
"dev.remotion.media.Video",
"dev.remotion.remotion.AnimatedImage",
]);
type DragState = {
layerId: string;
mode: "move" | "start" | "end";
startX: number;
deltaFrames: number;
// Timeline geometry when the drag started. The preview moves the sequence
// live, so the bar is drawn from these values instead of the live track.
startFrom: number;
startDuration: number;
};
type ReorderDragState = {
nodes: NodeReference[];
sourceKeys: string[];
targetId: string | null;
position: "before" | "after" | null;
};
// The keyframes being dragged are drawn shifted by the previewed delta; the
// source keeps the original frames until the move is committed.
type KeyframeDragState = {
keys: ReadonlySet<string>;
delta: number;
};
const getTickInterval = (pxPerFrame: number, fps: number) => {
const candidates = [
1,
2,
5,
10,
fps / 2,
fps,
fps * 2,
fps * 5,
fps * 10,
fps * 30,
fps * 60,
].filter((value) => Number.isInteger(value) && value > 0);
return (
candidates.find((interval) => interval * pxPerFrame >= 70) ??
candidates.at(-1)!
);
};
const TypeIcon: React.FC<{ readonly layer: Layer }> = ({ layer }) => {
const className = "size-3 shrink-0 opacity-70";
switch (layer.track.sequence.type) {
case "video":
return <FilmIcon className={className} />;
case "audio":
return <Music2Icon className={className} />;
case "image":
return <ImageIcon className={className} />;
default:
return <LayersIcon className={className} />;
}
};
const Playhead: React.FC<{
readonly pxPerFrame: number;
readonly height: number;
}> = ({ pxPerFrame, height }) => {
const { playback } = useEditor();
const frame = usePlaybackFrame(playback);
return (
<div
className="pointer-events-none absolute top-0 z-30"
style={{
left: LABEL_WIDTH + frame * pxPerFrame,
height,
width: 1,
backgroundColor: "#f43f5e",
}}
>
<div
className="absolute -top-0 left-1/2 -translate-x-1/2 border-x-[5px] border-t-[7px] border-x-transparent"
style={{ borderTopColor: "#f43f5e" }}
/>
</div>
);
};
const TrackRow = memo(function TrackRow({
layer,
index,
pxPerFrame,
durationInFrames,
selected,
drag,
keyframeRows,
reorderDropPosition,
onToggleKeyframeRows,
onPointerDownBar,
onDragStartLabel,
onDragOverLabel,
onDropLabel,
onDragEndLabel,
}: {
readonly layer: Layer;
readonly index: number;
readonly pxPerFrame: number;
readonly durationInFrames: number;
readonly selected: boolean;
readonly drag: DragState | null;
/** Whether the layer has animated props and whether their rows are shown. */
readonly keyframeRows: "none" | "expanded" | "collapsed";
readonly reorderDropPosition: "before" | "after" | null;
readonly onToggleKeyframeRows: (layer: Layer) => void;
readonly onPointerDownBar: (
event: React.PointerEvent,
layer: Layer,
mode: DragState["mode"],
) => void;
readonly onDragStartLabel: (event: React.DragEvent, layer: Layer) => void;
readonly onDragOverLabel: (event: React.DragEvent, layer: Layer) => void;
readonly onDropLabel: (event: React.DragEvent, layer: Layer) => void;
readonly onDragEndLabel: () => void;
}) {
const { host, actions } = useEditor();
const { hovered, onPointerEnter, onPointerLeave } = useCanvasSequenceHover(
host!.controller.hover,
layer.nodePathInfo,
"timeline",
);
const { sequence, depth } = layer.track;
const schema = getLayerSchema(layer);
const editable = layer.source !== null && hasTimingProps(schema);
const isDragging = drag?.layerId === sequence.id;
const delta = isDragging ? drag.deltaFrames : 0;
const baseFrom = isDragging ? drag.startFrom : sequence.from;
const baseDuration = isDragging ? drag.startDuration : sequence.duration;
const from = baseFrom + (isDragging && drag.mode !== "end" ? delta : 0);
const duration = Math.max(
1,
isDragging && drag.mode === "start"
? baseDuration - delta
: isDragging && drag.mode === "end"
? baseDuration + delta
: baseDuration,
);
const label = getLayerLabel(layer);
const select = (event: React.MouseEvent) =>
actions.selectLayer(layer, {
shiftKey: event.shiftKey,
toggleKey: event.metaKey || event.ctrlKey,
});
return (
<LayerContextMenu layer={layer}>
<div
role="row"
aria-selected={selected}
className={cn(
"group flex",
selected ? "bg-selection-dim/40" : hovered ? "bg-accent/40" : "",
)}
style={{ height: ROW_HEIGHT }}
onPointerEnter={onPointerEnter}
onPointerLeave={onPointerLeave}
>
<div
className={cn(
"bg-background-panel border-border-dim sticky left-0 z-20 flex shrink-0 items-center gap-1.5 border-r border-b pr-2 text-xs",
layer.source && "cursor-grab",
selected && "bg-[#141a2a]",
)}
style={{ width: LABEL_WIDTH, paddingLeft: 6 + depth * 14 }}
draggable={layer.source !== null}
onDragStart={(event) => onDragStartLabel(event, layer)}
onDragOver={(event) => onDragOverLabel(event, layer)}
onDrop={(event) => onDropLabel(event, layer)}
onDragEnd={onDragEndLabel}
onClick={select}
onDoubleClick={() => {
if (layer.source) {
actions.reveal(
layer.source.filePath,
layer.source.location?.line ?? null,
layer.source.location?.column ?? null,
);
}
}}
>
{keyframeRows === "none" ? (
<span className="size-3 shrink-0" />
) : (
<button
type="button"
className="text-muted-foreground-dim hover:text-foreground flex size-3 shrink-0 items-center justify-center"
aria-label={
keyframeRows === "expanded"
? "Hide keyframes"
: "Show keyframes"
}
aria-expanded={keyframeRows === "expanded"}
onClick={(event) => {
event.stopPropagation();
onToggleKeyframeRows(layer);
}}
>
{keyframeRows === "expanded" ? (
<ChevronDownIcon className="size-3" />
) : (
<ChevronRightIcon className="size-3" />
)}
</button>
)}
<TypeIcon layer={layer} />
<span
className={cn(
"min-w-0 flex-1 truncate",
selected
? "text-foreground"
: "text-muted-foreground group-hover:text-foreground",
)}
>
{label}
</span>
{!layer.source ? (
<span
className="text-muted-foreground-dim shrink-0 text-[9px] uppercase"
title="This layer has no source location, so it cannot be edited here."
>
no source
</span>
) : null}
{reorderDropPosition ? (
<div
className={cn(
"bg-primary pointer-events-none absolute right-0 left-0 h-0.5",
reorderDropPosition === "before" ? "top-0" : "bottom-0",
)}
/>
) : null}
</div>
<div
className="border-border-dim relative min-w-0 flex-1 border-b"
style={{ width: durationInFrames * pxPerFrame }}
data-track-area
data-row-index={index}
>
<div
role="button"
tabIndex={-1}
aria-label={`${label}: from frame ${from}, ${duration} frames`}
className={cn(
"absolute top-[5px] flex h-[20px] items-center overflow-hidden rounded-[4px] border text-[10px] whitespace-nowrap select-none",
editable
? "cursor-grab active:cursor-grabbing"
: "cursor-default",
selected
? "border-selection bg-selection/70 text-white"
: hovered
? "border-[#4b6383] bg-[#2f4160] text-white"
: sequence.type === "audio"
? "border-emerald-900 bg-emerald-950/80 text-emerald-100"
: sequence.type === "video" || sequence.type === "image"
? "border-violet-900 bg-violet-950/80 text-violet-100"
: "border-[#334155] bg-[#1e293b] text-slate-200",
isDragging && "opacity-80 ring-1 ring-white/40",
)}
style={{
left: from * pxPerFrame,
width: Math.max(4, duration * pxPerFrame),
}}
onClick={select}
onPointerDown={(event) => {
if (event.button !== 0) {
return;
}
if (!editable) {
return;
}
const rect = event.currentTarget.getBoundingClientRect();
const offset = event.clientX - rect.left;
const mode: DragState["mode"] =
offset <= EDGE_WIDTH && rect.width > EDGE_WIDTH * 3
? "start"
: rect.width - offset <= EDGE_WIDTH &&
rect.width > EDGE_WIDTH * 3
? "end"
: "move";
onPointerDownBar(event, layer, mode);
}}
>
{editable ? (
<>
<div className="absolute top-0 left-0 h-full w-[7px] cursor-ew-resize" />
<div className="absolute top-0 right-0 h-full w-[7px] cursor-ew-resize" />
</>
) : null}
<span className="truncate px-2">
{isDragging
? `${from} · ${duration}f`
: duration * pxPerFrame > 60
? `${label}`
: ""}
</span>
</div>
</div>
</div>
</LayerContextMenu>
);
});
/**
* The line between two keyframes. Clicking it selects the segment so the
* inspector can edit its easing; the context menu applies a preset directly.
*/
const EasingSegment: React.FC<{
readonly prop: KeyframedProp;
readonly segment: CanvasKeyframeEasingSegment;
readonly label: string;
readonly pxPerFrame: number;
readonly selectedKeys: ReadonlySet<string>;
readonly keyframeDrag: KeyframeDragState | null;
}> = ({ prop, segment, label, pxPerFrame, selectedKeys, keyframeDrag }) => {
const { host, actions } = useEditor();
const item = getEasingSelectionItem(prop, segment);
const selected = selectedKeys.has(getCanvasSelectionItemKey(item));
// The line follows the dragged keyframes at its ends.
const shift = (frame: number) =>
keyframeDrag?.keys.has(
getCanvasSelectionItemKey(getKeyframeSelectionItem(prop, frame)),
)
? frame + keyframeDrag.delta
: frame;
const from = shift(segment.fromFrame);
const to = shift(segment.toFrame);
return (
<ContextMenu>
<ContextMenuTrigger asChild>
<button
type="button"
aria-label={`${label} easing from frame ${segment.fromFrame} to ${segment.toFrame}`}
aria-pressed={selected}
className="group/easing absolute top-1/2 flex h-3 -translate-y-1/2 items-center px-1"
style={{
left: Math.min(from, to) * pxPerFrame,
width: Math.abs(to - from) * pxPerFrame,
}}
onPointerDown={(event) => {
if (event.button !== 0) {
return;
}
event.preventDefault();
event.stopPropagation();
actions.selectKeyframes([item], {
shiftKey: event.shiftKey,
toggleKey: event.metaKey || event.ctrlKey,
});
}}
>
<div
className={cn(
"h-0.5 w-full rounded-full",
selected
? "bg-primary"
: "bg-border group-hover/easing:bg-muted-foreground",
)}
/>
</button>
</ContextMenuTrigger>
<ContextMenuContent
onCloseAutoFocus={(event) => event.preventDefault()}
className="min-w-[160px]"
>
{canvasKeyframeEasingPresets.map((preset) => (
<ContextMenuItem
key={preset.id}
onSelect={() => {
// A preset from the menu of a selected segment applies to the
// whole selection, like in the Studio.
const selectedEasings = getSelectedEasings(
host?.controller.selection.getSnapshot().selectedItems ?? [],
);
void actions.applyEasing(
selected && selectedEasings.length > 0
? selectedEasings
: [item],
preset.easing,
);
}}
>
<EasingCurve easing={preset.easing} width={18} height={14} />
{preset.label}
</ContextMenuItem>
))}
</ContextMenuContent>
</ContextMenu>
);
};
/** A row with the keyframes of one animated prop, below its layer. */
const KeyframeRow = memo(function KeyframeRow({
prop,
pxPerFrame,
durationInFrames,
selectedKeys,
keyframeDrag,
onPointerDownKeyframe,
}: {
readonly prop: KeyframedProp;
readonly pxPerFrame: number;
readonly durationInFrames: number;
readonly selectedKeys: ReadonlySet<string>;
readonly keyframeDrag: KeyframeDragState | null;
readonly onPointerDownKeyframe: (
event: React.PointerEvent<HTMLButtonElement>,
prop: KeyframedProp,
frame: number,
) => void;
}) {
const { actions } = useEditor();
const label = getFieldLabel(prop.key, prop.field);
const layerSelected = selectedKeys.has(
getCanvasSelectionItemKey(prop.layer.selectionItem),
);
return (
<div
role="row"
className={cn("flex", layerSelected && "bg-selection-dim/20")}
style={{ height: KEYFRAME_ROW_HEIGHT }}
>
<div
className="bg-background-panel border-border-dim text-muted-foreground-dim sticky left-0 z-20 flex shrink-0 items-center gap-1.5 border-r border-b pr-2 text-[10px]"
style={{
width: LABEL_WIDTH,
paddingLeft: 24 + (prop.layer.track.depth + 1) * 14,
}}
>
<KeyframeDiamond filled size={7} />
<span className="min-w-0 flex-1 truncate">{label}</span>
</div>
<div
className="border-border-dim relative min-w-0 flex-1 border-b"
style={{ width: durationInFrames * pxPerFrame }}
data-track-area
>
{prop.easingSegments.map((segment) => (
<EasingSegment
key={segment.segmentIndex}
prop={prop}
segment={segment}
label={label}
pxPerFrame={pxPerFrame}
selectedKeys={selectedKeys}
keyframeDrag={keyframeDrag}
/>
))}
{prop.keyframes.map((keyframe) => {
if (keyframe.frame < 0 || keyframe.frame >= durationInFrames) {
return null;
}
const itemKey = getCanvasSelectionItemKey(
getKeyframeSelectionItem(prop, keyframe.frame),
);
const dragging = keyframeDrag?.keys.has(itemKey) === true;
const frame = keyframe.frame + (dragging ? keyframeDrag.delta : 0);
const selected = selectedKeys.has(itemKey);
return (
<button
key={keyframe.frame}
type="button"
aria-label={`${label} keyframe at frame ${keyframe.frame}`}
aria-pressed={selected}
className={cn(
"absolute top-1/2 flex size-4 -translate-x-1/2 -translate-y-1/2 items-center justify-center",
selected || dragging
? "text-primary"
: "text-muted-foreground hover:text-foreground",
dragging ? "cursor-grabbing" : "cursor-grab",
)}
style={{ left: frame * pxPerFrame }}
onPointerDown={(event) =>
onPointerDownKeyframe(event, prop, keyframe.frame)
}
onDoubleClick={() => actions.seek(keyframe.frame)}
>
<KeyframeDiamond filled size={10} />
</button>
);
})}
</div>
</div>
);
});
export const Timeline: React.FC = () => {
const {
host,
layers,
keyframedProps,
composition,
playback,
actions,
state,
project,
dispatch,
} = useEditor();
const scrollRef = useRef<HTMLDivElement | null>(null);
const [width, setWidth] = useState(800);
const [zoom, setZoom] = useState(1);
const [drag, setDrag] = useState<DragState | null>(null);
const dragRef = useRef<DragState | null>(null);
const [reorderDrag, setReorderDrag] = useState<ReorderDragState | null>(null);
const [keyframeDrag, setKeyframeDrag] = useState<KeyframeDragState | null>(
null,
);
const [collapsedLayers, setCollapsedLayers] = useState<ReadonlySet<string>>(
() => new Set(),
);
const durationInFrames = composition?.durationInFrames ?? 1;
const fps = composition?.fps ?? 30;
const basePxPerFrame = Math.max(
0.05,
(width - LABEL_WIDTH - 16) / durationInFrames,
);
const pxPerFrame = basePxPerFrame * zoom;
const timelineWidth = durationInFrames * pxPerFrame;
const { inFrame, outFrame } = state.playback;
useEffect(() => {
const element = scrollRef.current;
if (!element) {
return;
}
const observer = new ResizeObserver(([entry]) => {
setWidth(entry.contentRect.width);
});
observer.observe(element);
return () => observer.disconnect();
}, []);
const selection = useCanvasSelection(
host?.controller.selection ?? fallbackSelectionController,
);
const selectedKeys = useMemo(
() => new Set(selection.selectedItems.map(getCanvasSelectionItemKey)),
[selection.selectedItems],
);
const keyframedPropsByLayer = useMemo(() => {
const byLayer = new Map<string, KeyframedProp[]>();
for (const prop of keyframedProps) {
const key = getCanvasSelectionItemKey(prop.layer.selectionItem);
byLayer.set(key, [...(byLayer.get(key) ?? []), prop]);
}
return byLayer;
}, [keyframedProps]);
const getVisibleKeyframeRows = (layer: Layer): KeyframedProp[] => {
const key = getCanvasSelectionItemKey(layer.selectionItem);
return collapsedLayers.has(key)
? []
: (keyframedPropsByLayer.get(key) ?? []);
};
const toggleKeyframeRows = useCallback((layer: Layer) => {
const key = getCanvasSelectionItemKey(layer.selectionItem);
setCollapsedLayers((current) => {
const next = new Set(current);
if (next.has(key)) {
next.delete(key);
} else {
next.add(key);
}
return next;
});
}, []);
const onDragStartLabel = useCallback(
(event: React.DragEvent, layer: Layer) => {
if (!layer.source || !host) {
event.preventDefault();
return;
}
const selected = getCanvasSequenceReorderSelection({
draggedItem: layer.selectionItem,
selectedItems: host.controller.selection.getSnapshot().selectedItems,
});
const sourceLayers = selected.map((info) =>
layers.find(
(candidate) =>
getCanvasSelectionItemKey(candidate.selectionItem) ===
getCanvasSelectionItemKey({ type: "sequence", nodePathInfo: info }),
),
);
if (
sourceLayers.some(
(sourceLayer) =>
!sourceLayer?.source ||
sourceLayer.nodePathInfo.numberOfSequencesWithThisNodePath !== 1 ||
!areSiblingNodes(sourceLayer.source, layer.source!),
)
) {
event.preventDefault();
actions.notifyError(
new Error("Selected clips must be unique JSX siblings to reorder."),
);
return;
}
const nodes = sourceLayers.map((sourceLayer) =>
getNodeReference(sourceLayer!.selectionItem),
);
if (nodes.some((node) => node === null)) {
event.preventDefault();
return;
}
if (sourceLayers.length > 1) {
const orderedLayers = sourceLayers
.map((sourceLayer) => sourceLayer!)
.sort((left, right) => layers.indexOf(left) - layers.indexOf(right));
const dragImage = document.createElement("div");
Object.assign(dragImage.style, {
backgroundColor: "#141a2a",
boxShadow: "0 4px 16px #0008",
color: "#fff",
fontFamily: "Arial, Helvetica, sans-serif",
fontSize: "12px",
left: "0",
pointerEvents: "none",
position: "fixed",
top: "0",
width: `${LABEL_WIDTH}px`,
zIndex: "2147483647",
});
for (const selectedLayer of orderedLayers) {
const row = document.createElement("div");
row.textContent = getLayerLabel(selectedLayer);
Object.assign(row.style, {
alignItems: "center",
borderBottom: "1px solid #ffffff24",
boxSizing: "border-box",
display: "flex",
height: `${ROW_HEIGHT}px`,
overflow: "hidden",
paddingLeft: `${6 + selectedLayer.track.depth * 14}px`,
textOverflow: "ellipsis",
whiteSpace: "nowrap",
});
dragImage.appendChild(row);
}
document.body.appendChild(dragImage);
const labelRect = event.currentTarget.getBoundingClientRect();
event.dataTransfer.setDragImage(
dragImage,
event.clientX - labelRect.left,
orderedLayers.indexOf(layer) * ROW_HEIGHT + event.clientY - labelRect.top,
);
requestAnimationFrame(() => dragImage.remove());
}
event.dataTransfer.effectAllowed = "move";
event.dataTransfer.setData("application/x-remotion-layer-reorder", "move");
setReorderDrag({
nodes: nodes as NodeReference[],
sourceKeys: sourceLayers.map((sourceLayer) =>
getCanvasSelectionItemKey(sourceLayer!.selectionItem),
),
targetId: null,
position: null,
});
},
[actions, host, layers],
);
const onDragOverLabel = useCallback(
(event: React.DragEvent, layer: Layer) => {
if (!reorderDrag || !layer.source) {
return;
}
const siblings = layers.filter(
(candidate) =>
candidate.source && areSiblingNodes(candidate.source, layer.source!),
);
const sourceIndexes = reorderDrag.nodes.map((node) =>
siblings.findIndex(
(candidate) =>
JSON.stringify(candidate.source?.nodePath) ===
JSON.stringify(node.nodePath),
),
);
const targetIndex = siblings.indexOf(layer);
const position =
event.clientY < event.currentTarget.getBoundingClientRect().top + 15
? "before"
: "after";
if (
sourceIndexes.some((index) => index === -1) ||
getCanvasSequenceReorderInsertionIndex({
sourceIndexes,
targetIndex,
position,
}) === null
) {
setReorderDrag((current) =>
current?.targetId === null
? current
: current && { ...current, targetId: null, position: null },
);
return;
}
event.preventDefault();
event.dataTransfer.dropEffect = "move";
setReorderDrag((current) =>
current?.targetId === layer.track.sequence.id &&
current.position === position
? current
: current && {
...current,
targetId: layer.track.sequence.id,
position,
},
);
},
[layers, reorderDrag],
);
const onDropLabel = useCallback(
(event: React.DragEvent, layer: Layer) => {
if (
!reorderDrag ||
!layer.source ||
reorderDrag.targetId !== layer.track.sequence.id ||
reorderDrag.position === null
) {
return;
}
event.preventDefault();
void actions.reorderNodes(
reorderDrag.nodes,
layer.source,
reorderDrag.position,
);
setReorderDrag(null);
},
[actions, reorderDrag],
);
const frameFromClientX = useCallback(
(clientX: number) => {
const element = scrollRef.current;
if (!element) {
return 0;
}
const rect = element.getBoundingClientRect();
const x = clientX - rect.left + element.scrollLeft - LABEL_WIDTH;
return clamp(Math.round(x / pxPerFrame), 0, durationInFrames - 1);
},
[durationInFrames, pxPerFrame],
);
const scrub = useCallback(
(event: React.PointerEvent) => {
playback.getPlayer()?.pause();
actions.seek(frameFromClientX(event.clientX));
},
[actions, frameFromClientX, playback],
);
const onPointerDownBar = useCallback(
(event: React.PointerEvent, layer: Layer, mode: DragState["mode"]) => {
const start: DragState = {
layerId: layer.track.sequence.id,
mode,
startX: event.clientX,
deltaFrames: 0,
startFrom: layer.track.sequence.from,
startDuration: layer.track.sequence.duration,
};
dragRef.current = start;
const target = event.currentTarget as HTMLElement;
try {
target.setPointerCapture(event.pointerId);
} catch {
// Capture is an optimization; the window listeners below track the
// pointer either way.
}
// The props as written in the source. Dragging previews and then
// commits these values shifted by the dragged distance.
const node = getNodeReference(layer.selectionItem);
const { sequence } = layer.track;
const runtimeValues =
sequence.controls?.runtimeValues.getSnapshot() ?? {};
const runtimePlaybackRate = runtimeValues.playbackRate;
const playbackRate = playbackRateComponentIdentities.has(
sequence.controls?.componentIdentity ?? "",
)
? typeof runtimePlaybackRate === "number"
? runtimePlaybackRate
: 1
: sequence.sequencePlaybackRate;
let sourceFrom = 0;
let sourceDuration = sequence.duration * playbackRate;
let sourceTrimBefore =
typeof runtimeValues.trimBefore === "number"
? runtimeValues.trimBefore
: 0;
let blocked: string | null = null;
if (node) {
try {
const props = Internals.evaluateSourcePropStatuses(getNodeProps({
project,
node,
keys: ["from", "durationInFrames", "trimBefore"],
}).props, sequence.controls?.videoConfigValues ?? null);
const fromStatus = props.from;
const durationStatus = props.durationInFrames;
const trimBeforeStatus = props.trimBefore;
if (fromStatus?.status === "computed" && mode !== "end") {
blocked = `The "from" prop of ${getLayerLabel(layer)} is computed. Edit it in the code instead.`;
} else if (durationStatus?.status === "computed" && mode !== "move") {
blocked = `The "durationInFrames" prop of ${getLayerLabel(layer)} is computed. Edit it in the code instead.`;
} else if (
trimBeforeStatus?.status === "computed" &&
mode === "start"
) {
blocked = `The "trimBefore" prop of ${getLayerLabel(layer)} is computed. Edit it in the code instead.`;
}
if (
fromStatus?.status === "static" &&
typeof fromStatus.codeValue === "number"
) {
sourceFrom = fromStatus.codeValue;
}
if (
durationStatus?.status === "static" &&
typeof durationStatus.codeValue === "number"
) {
sourceDuration = durationStatus.codeValue;
}
if (
trimBeforeStatus?.status === "static" &&
typeof trimBeforeStatus.codeValue === "number"
) {
sourceTrimBefore = trimBeforeStatus.codeValue;
}
} catch (error) {
blocked = getErrorMessage(error);
}
}
const getUpdates = (deltaFrames: number) => {
const childDeltaFrames = deltaFrames * playbackRate;
if (mode === "move") {
return [
{ key: "from", value: sourceFrom + deltaFrames, defaultValue: 0 },
];
}
if (mode === "end") {
return [
{
key: "durationInFrames",
value: Math.max(1, sourceDuration + childDeltaFrames),
defaultValue: null,
},
];
}
return [
{
key: "from",
value: sourceFrom + deltaFrames,
defaultValue: 0,
},
{
key: "durationInFrames",
value: Math.max(1, sourceDuration - childDeltaFrames),
defaultValue: null,
},
{
key: "trimBefore",
value: Math.max(0, sourceTrimBefore + childDeltaFrames),
defaultValue: 0,
},
];
};
const onMove = (move: PointerEvent) => {
const current = dragRef.current;
if (!current) {
return;
}
const deltaFrames = Math.round(
(move.clientX - current.startX) / pxPerFrame,
);
if (deltaFrames === current.deltaFrames) {
return;
}
const next = { ...current, deltaFrames };
dragRef.current = next;
setDrag(deltaFrames === 0 ? null : next);
if (node && blocked === null) {
actions.previewLayerProps(
layer,
Object.fromEntries(
getUpdates(deltaFrames).map(({ key, value }) => [key, value]),
),
);
}
};
const onUp = () => {
window.removeEventListener("pointermove", onMove);
window.removeEventListener("pointerup", onUp);
window.removeEventListener("pointercancel", onUp);
const current = dragRef.current;
dragRef.current = null;
setDrag(null);
if (!current || current.deltaFrames === 0 || !node || !layer.source) {
actions.cancelLayerPreview(layer);
return;
}
if (blocked !== null) {
actions.notifyError(new Error(blocked));
return;
}
void actions.commitLayerProps(
layer,
getUpdates(current.deltaFrames),
getLayerSchema(layer),
);
};
window.addEventListener("pointermove", onMove);
window.addEventListener("pointerup", onUp);
window.addEventListener("pointercancel", onUp);
},
[actions, project, pxPerFrame],
);
// Selecting and dragging keyframes follows the Studio: a click selects on
// release, dragging a selected keyframe moves the whole selection, and
// Shift / Command extend the selection without dragging it.
const keyframedPropsRef = useRef(keyframedProps);
keyframedPropsRef.current = keyframedProps;
const onPointerDownKeyframe = useCallback(
(
event: React.PointerEvent<HTMLButtonElement>,
prop: KeyframedProp,
frame: number,
) => {
if (event.button !== 0 || !host) {
return;
}
event.preventDefault();
event.stopPropagation();
const interaction: CanvasSelectionInteraction = {
shiftKey: event.shiftKey,
toggleKey: event.metaKey || event.ctrlKey,
};
const item = getKeyframeSelectionItem(prop, frame);
const itemKey = getCanvasSelectionItemKey(item);
const selectedKeyframes = getSelectedKeyframes(
host.controller.selection.getSnapshot().selectedItems,
);
const selected = selectedKeyframes.some(
(keyframe) => getCanvasSelectionItemKey(keyframe) === itemKey,
);
const modifier = interaction.shiftKey || interaction.toggleKey;
const dragExistingSelection = selected && !modifier;
const selectOnRelease = !selected && !modifier;
if (modifier) {
actions.selectKeyframes([item], interaction);
}
const keyframesToDrag: KeyframeSelectionItem[] =
dragExistingSelection && selectedKeyframes.length > 0
? selectedKeyframes
: [item];
const targets = keyframesToDrag.flatMap(
(keyframe): CanvasKeyframeDragTarget[] => {
const target = findKeyframedProp(keyframedPropsRef.current, keyframe);
return target
? [
{
nodePathInfo: target.layer.nodePathInfo,
track: target.layer.track,
schema: target.schema,
key: target.key,
propStatus: target.propStatus,
frame: keyframe.frame,
},
]
: [];
},
);
const dragKeys = new Set(keyframesToDrag.map(getCanvasSelectionItemKey));
startCanvasKeyframeDrag({
event,
captureTarget: event.currentTarget,
targets,
pixelsPerFrame: pxPerFrame,
durationInFrames,
overrides: host.controller.overrides,
onDragStart: null,
onDragMove: (delta) => setKeyframeDrag({ keys: dragKeys, delta }),
onDragEnd: ({ changes, delta, dragged, released }) => {
setKeyframeDrag(null);
if (changes.length === 0) {
if (!dragged && released && selectOnRelease) {
actions.selectKeyframes([item], interaction);
}
return;
}
// The selection follows the moved keyframes.
actions.selectKeyframes(
keyframesToDrag.map((keyframe) => ({
...keyframe,
frame: keyframe.frame + delta,
})),
null,
);
void actions.commitKeyframeChanges(changes);
},
});
},
[actions, durationInFrames, host, pxPerFrame],
);
const ticks = useMemo(() => {
const interval = getTickInterval(pxPerFrame, fps);
const result: { frame: number; label: string; major: boolean }[] = [];
for (let frame = 0; frame <= durationInFrames; frame += interval) {
result.push({
frame,
label:
interval >= fps ? formatTimecode(frame, fps).slice(3) : String(frame),
major: true,
});
}
return result;
}, [durationInFrames, fps, pxPerFrame]);
if (!host) {
return null;
}
const contentHeight = layers.reduce(
(height, layer) =>
height +
ROW_HEIGHT +
getVisibleKeyframeRows(layer).length * KEYFRAME_ROW_HEIGHT,
RULER_HEIGHT,
);
return (
<div className="flex h-full min-h-0 flex-col">
<div className="border-border flex h-8 shrink-0 items-center gap-2 border-b px-3 text-xs">
<span className="font-medium">Timeline</span>
<span className="text-muted-foreground">
{layers.length} layer{layers.length === 1 ? "" : "s"}
{selection.selectedItems.length > 0
? ` · ${selection.selectedItems.length} selected`
: ""}
</span>
<span className="flex-1" />
<span className="text-muted-foreground-dim hidden font-mono text-[10px] lg:inline">
Drag a layer to move it · drag its edges to trim · drag keyframes to
retime them · click between keyframes to edit the easing · ⌥ + scroll
to zoom
</span>
<ToolbarButton
size="icon-xs"
label="Zoom out timeline"
onClick={() => setZoom((value) => Math.max(1, value / 1.5))}
disabled={zoom <= 1}
>
<ZoomOutIcon />
</ToolbarButton>
<ToolbarButton
size="icon-xs"
label="Zoom in timeline"
onClick={() => setZoom((value) => Math.min(40, value * 1.5))}
>
<ZoomInIcon />
</ToolbarButton>
</div>
<div
ref={scrollRef}
className="relative min-h-0 flex-1 overflow-auto"
onWheel={(event) => {
if (event.altKey || event.ctrlKey) {
event.preventDefault();
setZoom((value) =>
clamp(value * (event.deltaY < 0 ? 1.15 : 1 / 1.15), 1, 40),
);
}
}}
onPointerDown={(event) => {
const target = event.target as HTMLElement;
if (
event.button === 0 &&
target.closest("[data-track-area]") &&
!target.closest('[role="button"]')
) {
actions.clearSelection();
scrub(event);
}
}}
>
<div
className="relative"
style={{
width: LABEL_WIDTH + timelineWidth,
minWidth: "100%",
height: contentHeight,
}}
>
<div
className="bg-background-panel sticky top-0 z-40 flex"
style={{ height: RULER_HEIGHT }}
>
<div
className="bg-background-panel border-border sticky left-0 z-50 shrink-0 border-r border-b"
style={{ width: LABEL_WIDTH }}
/>
<div
role="slider"
aria-label="Timeline ruler"
aria-valuemin={0}
aria-valuemax={durationInFrames - 1}
aria-valuenow={playback.getSnapshot().frame}
tabIndex={-1}
className="border-border relative flex-1 cursor-col-resize border-b select-none"
style={{ width: timelineWidth }}
onPointerDown={(event) => {
if (event.button !== 0) {
return;
}
const target = event.currentTarget;
target.setPointerCapture(event.pointerId);
scrub(event);
}}
onPointerMove={(event) => {
if (event.currentTarget.hasPointerCapture(event.pointerId)) {
scrub(event);
}
}}
onPointerUp={(event) =>
event.currentTarget.releasePointerCapture(event.pointerId)
}
>
{ticks.map((tick) => (
<div
key={tick.frame}
className="text-muted-foreground-dim absolute bottom-0 flex flex-col items-start font-mono text-[9px]"
style={{ left: tick.frame * pxPerFrame }}
>
<span className="translate-x-1 leading-none">
{tick.label}
</span>
<div className="bg-border mt-0.5 h-1.5 w-px" />
</div>
))}
{inFrame !== null ? (
<InOutHandle
kind="in"
frame={inFrame}
pxPerFrame={pxPerFrame}
onChange={(frame) =>
actions.setInOut(
frame,
outFrame !== null && outFrame <= frame ? null : outFrame,
)
}
frameFromClientX={frameFromClientX}
/>
) : null}
{outFrame !== null ? (
<InOutHandle
kind="out"
frame={outFrame}
pxPerFrame={pxPerFrame}
onChange={(frame) =>
actions.setInOut(
inFrame !== null && inFrame >= frame ? null : inFrame,
frame,
)
}
frameFromClientX={frameFromClientX}
/>
) : null}
</div>
</div>
{layers.length === 0 ? (
<div
className="text-muted-foreground absolute flex items-center text-xs"
style={{ left: LABEL_WIDTH + 12, top: RULER_HEIGHT + 10 }}
>
{composition
? "No layers are mounted at this point in time."
: "Waiting for the preview…"}
</div>
) : null}
{layers.map((layer, index) => {
const layerKey = getCanvasSelectionItemKey(layer.selectionItem);
const hasKeyframeRows = keyframedPropsByLayer.has(layerKey);
return (
<React.Fragment key={layerKey}>
<TrackRow
layer={layer}
index={index}
pxPerFrame={pxPerFrame}
durationInFrames={durationInFrames}
selected={selectedKeys.has(layerKey)}
drag={drag}
reorderDropPosition={
reorderDrag?.targetId === layer.track.sequence.id
? reorderDrag.position
: null
}
keyframeRows={
!hasKeyframeRows
? "none"
: collapsedLayers.has(layerKey)
? "collapsed"
: "expanded"
}
onToggleKeyframeRows={toggleKeyframeRows}
onPointerDownBar={onPointerDownBar}
onDragStartLabel={onDragStartLabel}
onDragOverLabel={onDragOverLabel}
onDropLabel={onDropLabel}
onDragEndLabel={() => setReorderDrag(null)}
/>
{getVisibleKeyframeRows(layer).map((prop) => (
<KeyframeRow
key={prop.key}
prop={prop}
pxPerFrame={pxPerFrame}
durationInFrames={durationInFrames}
selectedKeys={selectedKeys}
keyframeDrag={keyframeDrag}
onPointerDownKeyframe={onPointerDownKeyframe}
/>
))}
</React.Fragment>
);
})}
{inFrame !== null && inFrame > 0 ? (
<div
className="pointer-events-none absolute top-0 z-20 bg-black/45"
style={{
left: LABEL_WIDTH,
width: inFrame * pxPerFrame,
height: contentHeight,
}}
/>
) : null}
{outFrame !== null && outFrame < durationInFrames - 1 ? (
<div
className="pointer-events-none absolute top-0 z-20 bg-black/45"
style={{
left: LABEL_WIDTH + (outFrame + 1) * pxPerFrame,
width: (durationInFrames - outFrame - 1) * pxPerFrame,
height: contentHeight,
}}
/>
) : null}
<Playhead pxPerFrame={pxPerFrame} height={contentHeight} />
</div>
</div>
{state.layout.showTimeline && layers.some((layer) => !layer.source) ? (
<button
type="button"
className="text-muted-foreground-dim hover:text-muted-foreground border-border border-t px-3 py-1 text-left text-[10px]"
onClick={() =>
dispatch({
type: "set-layout",
patch: { showInspector: true, inspectorTab: "inspector" },
})
}
>
Some layers have no source location and cannot be edited here. They
are rendered by dependencies or by code the compiler did not process.
</button>
) : null}
</div>
);
};
const InOutHandle: React.FC<{
readonly kind: "in" | "out";
readonly frame: number;
readonly pxPerFrame: number;
readonly onChange: (frame: number) => void;
readonly frameFromClientX: (clientX: number) => number;
}> = ({ kind, frame, pxPerFrame, onChange, frameFromClientX }) => (
<div
role="slider"
aria-label={kind === "in" ? "In point" : "Out point"}
aria-valuenow={frame}
tabIndex={-1}
className="absolute top-0 z-10 flex h-full w-3 cursor-ew-resize items-end"
style={{
left: kind === "in" ? frame * pxPerFrame : (frame + 1) * pxPerFrame - 12,
justifyContent: kind === "in" ? "flex-start" : "flex-end",
}}
onPointerDown={(event) => {
event.stopPropagation();
event.currentTarget.setPointerCapture(event.pointerId);
}}
onPointerMove={(event) => {
if (event.currentTarget.hasPointerCapture(event.pointerId)) {
onChange(frameFromClientX(event.clientX));
}
}}
onPointerUp={(event) =>
event.currentTarget.releasePointerCapture(event.pointerId)
}
>
<div
className="h-3 w-1.5 rounded-sm bg-amber-400"
style={{ borderRadius: kind === "in" ? "2px 0 0 2px" : "0 2px 2px 0" }}
/>
</div>
);