Skip to content

🎥 Make videos programmatically with React

`@remotion/studio`: Clamp right-edge media resizing to asset duration

JonnyBurger3ba202f282a1
diff --git a/packages/studio/src/components/Timeline/TimelineSequence.tsx b/packages/studio/src/components/Timeline/TimelineSequence.tsx
index c5e86cd277..dd86c3c845 100644
--- a/packages/studio/src/components/Timeline/TimelineSequence.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequence.tsx
@@ -66,6 +66,7 @@ import {
import {TimelineSequenceFrame} from './TimelineSequenceFrame';
import {
canResizeTimelineSequenceDuration,
+ getTimelineSequenceMediaDurationDragLimits,
isCascadingSequence,
isTimelineSequenceDurationDraggable,
isTimelineSequenceLeftEdgeDraggable,
@@ -497,7 +498,6 @@ const TimelineSequenceInner: React.FC<{
const durationCanResize = Boolean(
isStudioInteractivityEnabled() &&
canResizeTimelineSequenceDuration({
- sequence: s,
status: propStatusesForOverride?.durationInFrames,
}),
);
@@ -898,6 +898,32 @@ const TimelineSequenceInner: React.FC<{
const endsAtContainerBoundary =
Math.ceil(s.from + displayDurationInFrames) >=
Math.ceil(Math.min(parentEnd, video.durationInFrames));
+ const hasImplicitMediaDuration =
+ (s.type === 'audio' || s.type === 'video') &&
+ propStatusesForOverride?.durationInFrames?.status === 'static' &&
+ propStatusesForOverride.durationInFrames.codeValue === undefined;
+ const durationInFramesCodeValue =
+ propStatusesForOverride?.durationInFrames?.status === 'static'
+ ? propStatusesForOverride.durationInFrames.codeValue
+ : null;
+ const explicitDurationInFrames =
+ typeof durationInFramesCodeValue === 'number' &&
+ Number.isFinite(durationInFramesCodeValue)
+ ? durationInFramesCodeValue
+ : null;
+ const isMedia = s.type === 'audio' || s.type === 'video';
+ const mediaDurationDragLimits = isMedia
+ ? getTimelineSequenceMediaDurationDragLimits({
+ cascadedStart,
+ displayDurationInFrames: s.duration,
+ displayStart: s.from,
+ effectiveMaxMediaDuration,
+ explicitDurationInFrames,
+ hasImplicitDuration: hasImplicitMediaDuration,
+ naturalMediaDuration,
+ timelineDurationInFrames: video.durationInFrames,
+ })
+ : null;
const showRightBorderRadius =
visibleLayout?.rightEdgeVisible === true &&
@@ -943,7 +969,8 @@ const TimelineSequenceInner: React.FC<{
isTimelineSequenceDurationDraggable(s) &&
nodePath !== null &&
validatedLocation !== null &&
- durationCanResize;
+ durationCanResize &&
+ (!isMedia || mediaDurationDragLimits !== null);
const showLeftEdgeDragHandle =
isTimelineSequenceLeftEdgeDraggable(s) &&
nodePath !== null &&
@@ -1004,6 +1031,7 @@ const TimelineSequenceInner: React.FC<{
validatedLocation ? (
<TimelineSequenceRightEdgeDragHandle
nodePathInfo={nodePathInfo}
+ mediaDurationDragLimits={mediaDurationDragLimits}
windowWidth={windowWidth}
timelineDurationInFrames={video.durationInFrames ?? 1}
onDragEnd={dragAwareDoubleClick.endPointerGesture}
diff --git a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
index 1bb64c8986..aa6b272b26 100644
--- a/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
+++ b/packages/studio/src/components/Timeline/TimelineSequenceRightEdgeDragHandle.tsx
@@ -50,6 +50,61 @@ const HANDLE_OUTSET = 8;
const timelineSequenceEdgeDragThresholdPx = 4;
export const timelineSequenceFromDragSnapThresholdPx = 10;
+export type TimelineSequenceMediaDurationDragLimits = {
+ readonly initialDuration: number;
+ readonly maximumDuration: number;
+};
+
+export const getTimelineSequenceMediaDurationDragLimits = ({
+ cascadedStart,
+ displayDurationInFrames,
+ displayStart,
+ effectiveMaxMediaDuration,
+ explicitDurationInFrames,
+ hasImplicitDuration,
+ naturalMediaDuration,
+ timelineDurationInFrames,
+}: {
+ readonly cascadedStart: number;
+ readonly displayDurationInFrames: number;
+ readonly displayStart: number;
+ readonly effectiveMaxMediaDuration: number | null;
+ readonly explicitDurationInFrames: number | null;
+ readonly hasImplicitDuration: boolean;
+ readonly naturalMediaDuration: number | null;
+ readonly timelineDurationInFrames: number;
+}): TimelineSequenceMediaDurationDragLimits | null => {
+ if (
+ naturalMediaDuration === null ||
+ !Number.isFinite(naturalMediaDuration) ||
+ naturalMediaDuration <= 0
+ ) {
+ return null;
+ }
+
+ return {
+ initialDuration:
+ explicitDurationInFrames ??
+ Math.ceil(
+ displayStart +
+ Math.max(
+ 0,
+ Math.min(
+ displayDurationInFrames,
+ timelineDurationInFrames - displayStart,
+ effectiveMaxMediaDuration ?? Infinity,
+ ),
+ ) -
+ cascadedStart,
+ ),
+ maximumDuration:
+ // Keeping duration omitted represents the media's natural end. An
+ // explicit duration is only useful once its edge is before that end.
+ Math.ceil(displayStart + naturalMediaDuration - cascadedStart) -
+ (hasImplicitDuration ? 1 : 0),
+ };
+};
+
const getTimelineSequenceEdgeSelectionInteraction = ({
button,
selected,
@@ -95,6 +150,7 @@ export type TimelineSequenceDurationDragTarget = {
readonly maximumDuration: number;
readonly minimumDuration: number;
readonly nodePath: SequencePropsSubscriptionKey;
+ readonly onlyCommitDurationWithinMaximum: boolean;
readonly schema: InteractivitySchema;
};
@@ -349,21 +405,11 @@ export const isTimelineSequenceDurationDraggable = (sequence: TSequence) => {
};
export const canResizeTimelineSequenceDuration = ({
- sequence,
status,
}: {
- readonly sequence: TSequence;
readonly status: CanUpdateSequencePropStatus | undefined;
}) => {
- if (status?.status !== 'static') {
- return false;
- }
-
- if (sequence.type === 'audio' || sequence.type === 'video') {
- return status.codeValue !== undefined;
- }
-
- return true;
+ return status?.status === 'static';
};
export const isTimelineSequenceLeftEdgeDraggable = (sequence: TSequence) => {
@@ -423,6 +469,32 @@ export const getTimelineSequenceDurationDragValue = ({
Math.max(minimumDuration, initialDuration + deltaFrames),
);
+const getTimelineSequenceDurationDragValueForTarget = ({
+ target,
+ deltaFrames,
+}: {
+ readonly target: TimelineSequenceDurationDragTarget;
+ readonly deltaFrames: number;
+}) => {
+ const unclampedValue = Math.max(
+ target.minimumDuration,
+ target.initialDuration + deltaFrames,
+ );
+ if (
+ target.onlyCommitDurationWithinMaximum &&
+ unclampedValue > target.maximumDuration
+ ) {
+ return null;
+ }
+
+ return getTimelineSequenceDurationDragValue({
+ initialDuration: target.initialDuration,
+ deltaFrames,
+ maximumDuration: target.maximumDuration,
+ minimumDuration: target.minimumDuration,
+ });
+};
+
export const getTimelineSequenceLeftEdgeDragDelta = ({
initialDuration,
initialTrimBefore,
@@ -538,12 +610,13 @@ export const getTimelineSequenceDurationDragChanges = ({
readonly deltaFrames: number;
}): SaveSequencePropChange[] => {
return targets.flatMap((target) => {
- const nextValue = getTimelineSequenceDurationDragValue({
- initialDuration: target.initialDuration,
+ const nextValue = getTimelineSequenceDurationDragValueForTarget({
+ target,
deltaFrames,
- maximumDuration: target.maximumDuration,
- minimumDuration: target.minimumDuration,
});
+ if (nextValue === null) {
+ return [];
+ }
if (nextValue === target.initialDuration) {
return [];
@@ -732,6 +805,7 @@ const findSequenceTrack = ({
export const getTimelineSequenceDurationDragTargets = ({
draggedNodePathInfo,
+ draggedSequenceMediaDurationDragLimits,
selectedItems,
sequences,
overrideIdsToNodePaths,
@@ -739,6 +813,7 @@ export const getTimelineSequenceDurationDragTargets = ({
timelineDurationInFrames,
}: {
readonly draggedNodePathInfo: SequenceNodePathInfo;
+ readonly draggedSequenceMediaDurationDragLimits: TimelineSequenceMediaDurationDragLimits | null;
readonly selectedItems: readonly TimelineSelection[];
readonly sequences: TSequence[];
readonly overrideIdsToNodePaths: OverrideIdToNodePaths;
@@ -792,7 +867,6 @@ export const getTimelineSequenceDurationDragTargets = ({
)?.durationInFrames;
if (
!canResizeTimelineSequenceDuration({
- sequence: originalSequence,
status: durationStatus,
})
) {
@@ -806,20 +880,55 @@ export const getTimelineSequenceDurationDragTargets = ({
const key = stringifySequenceSubscriptionKey(nodePath);
if (!targets.has(key)) {
+ const isMedia =
+ originalSequence.type === 'audio' || originalSequence.type === 'video';
+ const hasImplicitMediaDuration =
+ isMedia &&
+ durationStatus?.status === 'static' &&
+ durationStatus.codeValue === undefined;
+ const isDraggedSequence =
+ getTimelineSequenceSelectionKey(nodePathInfo) === draggedSelectionKey;
+ const mediaDurationDragLimits = isMedia
+ ? isDraggedSequence
+ ? draggedSequenceMediaDurationDragLimits
+ : hasImplicitMediaDuration
+ ? null
+ : {
+ initialDuration: originalSequence.duration,
+ maximumDuration: originalSequence.duration,
+ }
+ : null;
+ if (isMedia && mediaDurationDragLimits === null) {
+ return null;
+ }
+
const minimumDuration = Math.max(
1 - originalSequence.from,
getMinimumSequenceDuration({sequence: originalSequence, sequences}),
);
+ const initialDuration =
+ mediaDurationDragLimits?.initialDuration ?? originalSequence.duration;
+ const constrainedMaximumDuration = Math.min(
+ mediaDurationDragLimits?.maximumDuration ?? Infinity,
+ timelineDurationInFrames - track.cascadedStart,
+ );
+ if (isMedia && constrainedMaximumDuration < minimumDuration) {
+ return null;
+ }
+
+ const maximumDuration = isMedia
+ ? constrainedMaximumDuration
+ : Math.max(minimumDuration, constrainedMaximumDuration);
+
targets.set(key, {
fileName: nodePath.absolutePath,
- initialDuration: originalSequence.duration,
- maximumDuration: Math.max(
- minimumDuration,
- timelineDurationInFrames - track.cascadedStart,
- ),
+ initialDuration,
+ maximumDuration,
// A negative start needs enough duration to retain one visible frame.
minimumDuration,
nodePath,
+ onlyCommitDurationWithinMaximum:
+ hasImplicitMediaDuration || initialDuration > maximumDuration,
schema: controls.schema,
});
}
@@ -1741,6 +1850,7 @@ export const useTimelineSequenceFromDrag = ({
const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
readonly nodePathInfo: SequenceNodePathInfo;
+ readonly mediaDurationDragLimits: TimelineSequenceMediaDurationDragLimits | null;
readonly windowWidth: number;
readonly timelineDurationInFrames: number;
readonly onDragEnd: (wasDragged: boolean) => void;
@@ -1748,6 +1858,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
readonly selected: boolean;
}> = ({
nodePathInfo,
+ mediaDurationDragLimits,
windowWidth,
timelineDurationInFrames,
onDragEnd,
@@ -1781,6 +1892,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
// Keep latest props/setters available to window listeners installed once at pointerdown.
const latestRef = useRef({
nodePathInfo,
+ mediaDurationDragLimits,
setPropStatuses,
setDragOverrides,
clearDragOverrides,
@@ -1791,6 +1903,7 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
});
latestRef.current = {
nodePathInfo,
+ mediaDurationDragLimits,
setPropStatuses,
setDragOverrides,
clearDragOverrides,
@@ -1896,12 +2009,15 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
const {
nodePathInfo: latestNodePathInfo,
+ mediaDurationDragLimits: latestMediaDurationDragLimits,
overrideIdToNodePathMappings: latestOverrideIdsToNodePaths,
} = latestRef.current;
const {selectedItems: latestSelectedItems} = currentSelection.current;
const targets = canCalculateDelta
? (getTimelineSequenceDurationDragTargets({
draggedNodePathInfo: latestNodePathInfo,
+ draggedSequenceMediaDurationDragLimits:
+ latestMediaDurationDragLimits,
selectedItems: latestSelectedItems,
sequences: sequencesRef.current,
overrideIdsToNodePaths: latestOverrideIdsToNodePaths,
@@ -1944,17 +2060,24 @@ const TimelineSequenceRightEdgeDragHandleInner: React.FC<{
}
for (const target of dragState.targets) {
+ const committableValue =
+ getTimelineSequenceDurationDragValueForTarget({
+ target,
+ deltaFrames,
+ });
+ const previewValue =
+ committableValue ??
+ getTimelineSequenceDurationDragValue({
+ initialDuration: target.initialDuration,
+ deltaFrames,
+ maximumDuration: target.initialDuration,
+ minimumDuration: target.minimumDuration,
+ });
+
latestRef.current.setDragOverrides(
target.nodePath,
'durationInFrames',
- Internals.makeStaticDragOverride(
- getTimelineSequenceDurationDragValue({
- initialDuration: target.initialDuration,
- deltaFrames,
- maximumDuration: target.maximumDuration,
- minimumDuration: target.minimumDuration,
- }),
- ),
+ Internals.makeStaticDragOverride(previewValue),
);
}
};
diff --git a/packages/studio/src/test/timeline-selection.test.ts b/packages/studio/src/test/timeline-selection.test.ts
index 34ac3f09e2..adc76f262d 100644
--- a/packages/studio/src/test/timeline-selection.test.ts
+++ b/packages/studio/src/test/timeline-selection.test.ts
@@ -133,6 +133,7 @@ import {
getTimelineSequenceDurationDragChanges,
getTimelineSequenceDurationDragTargets,
getTimelineSequenceDurationDragValue,
+ getTimelineSequenceMediaDurationDragLimits,
getTimelineSequenceFromDragChanges,
getTimelineSequenceFromDragDelta,
getTimelineSequenceFromDragKeyframeMoves,
@@ -1791,6 +1792,7 @@ test('Timeline duration drag applies the same delta to selected sequences', () =
];
const targets = getTimelineSequenceDurationDragTargets({
draggedNodePathInfo: firstNodePathInfo,
+ draggedSequenceMediaDurationDragLimits: null,
selectedItems: [
{type: 'sequence', nodePathInfo: firstNodePathInfo},
{type: 'sequence', nodePathInfo: secondNodePathInfo},
@@ -1828,6 +1830,7 @@ test('Timeline duration drag uses the declared duration for negative from values
const nodePathInfo = makeNodePathInfo(['body', 0], []);
const targets = getTimelineSequenceDurationDragTargets({
draggedNodePathInfo: nodePathInfo,
+ draggedSequenceMediaDurationDragLimits: null,
selectedItems: [{type: 'sequence', nodePathInfo}],
sequences: [
makeTimelineSequence({
@@ -1859,6 +1862,7 @@ test('Timeline duration drag clamps to the composition end', () => {
const nodePathInfo = makeNodePathInfo(['body', 0], []);
const targets = getTimelineSequenceDurationDragTargets({
draggedNodePathInfo: nodePathInfo,
+ draggedSequenceMediaDurationDragLimits: null,
selectedItems: [{type: 'sequence', nodePathInfo}],
sequences: [
makeTimelineSequence({
@@ -1897,6 +1901,10 @@ test('Timeline duration drag supports interactive video clips', () => {
expect(
getTimelineSequenceDurationDragTargets({
draggedNodePathInfo: nodePathInfo,
+ draggedSequenceMediaDurationDragLimits: {
+ initialDuration: 78,
+ maximumDuration: 1000,
+ },
selectedItems: [{type: 'sequence', nodePathInfo}],
sequences: [video],
overrideIdsToNodePaths: {
@@ -1914,26 +1922,127 @@ test('Timeline duration drag supports interactive video clips', () => {
maximumDuration: 1000,
minimumDuration: 1,
nodePath: nodePathInfo.sequenceSubscriptionKey,
+ onlyCommitDurationWithinMaximum: false,
schema: Internals.baseSchema,
},
]);
});
-test('Timeline duration drag rejects media without an explicit duration', () => {
+test('Media duration drag limits account for a negative from', () => {
+ const common = {
+ cascadedStart: -192,
+ displayDurationInFrames: 108,
+ displayStart: 0,
+ explicitDurationInFrames: 300,
+ hasImplicitDuration: false,
+ naturalMediaDuration: 33,
+ timelineDurationInFrames: 1000,
+ };
+
+ expect(
+ getTimelineSequenceMediaDurationDragLimits({
+ ...common,
+ // <Video> keeps displaying its last frame.
+ effectiveMaxMediaDuration: null,
+ }),
+ ).toEqual({initialDuration: 300, maximumDuration: 225});
+ expect(
+ getTimelineSequenceMediaDurationDragLimits({
+ ...common,
+ // Audio and OffthreadVideo stop at the asset end.
+ effectiveMaxMediaDuration: 33,
+ }),
+ ).toEqual({initialDuration: 300, maximumDuration: 225});
+});
+
+test('Timeline duration drag clamps explicit audio and video to the asset end', () => {
+ for (const type of ['audio', 'video'] as const) {
+ const nodePathInfo = makeNodePathInfo(['body', type], []);
+ const nodePath = nodePathInfo.sequenceSubscriptionKey;
+ const targets = getTimelineSequenceDurationDragTargets({
+ draggedNodePathInfo: nodePathInfo,
+ draggedSequenceMediaDurationDragLimits: {
+ initialDuration: 200,
+ maximumDuration: 225,
+ },
+ selectedItems: [{type: 'sequence', nodePathInfo}],
+ sequences: [
+ makeTimelineSequence({
+ schema: Internals.baseSchema,
+ type,
+ duration: 200,
+ from: -192,
+ }),
+ ],
+ overrideIdsToNodePaths: {override: nodePath},
+ propStatuses: makeDurationPropStatuses([nodePath]),
+ timelineDurationInFrames: 1000,
+ });
+
+ expect(targets?.[0].maximumDuration).toBe(225);
+ expect(
+ getTimelineSequenceDurationDragChanges({
+ targets: targets ?? [],
+ deltaFrames: 100,
+ })[0].value,
+ ).toBe(225);
+ }
+});
+
+test('An overlong explicit Video is only saved once it reaches the asset end', () => {
const nodePathInfo = makeNodePathInfo(['body', 0], []);
- const audio = makeTimelineSequence({
- schema: Internals.baseSchema,
- type: 'audio',
- duration: 78,
- });
const nodePath = nodePathInfo.sequenceSubscriptionKey;
+ const targets = getTimelineSequenceDurationDragTargets({
+ draggedNodePathInfo: nodePathInfo,
+ draggedSequenceMediaDurationDragLimits: {
+ initialDuration: 300,
+ maximumDuration: 225,
+ },
+ selectedItems: [{type: 'sequence', nodePathInfo}],
+ sequences: [
+ makeTimelineSequence({
+ schema: Internals.baseSchema,
+ type: 'video',
+ duration: 300,
+ from: -192,
+ }),
+ ],
+ overrideIdsToNodePaths: {override: nodePath},
+ propStatuses: makeDurationPropStatuses([nodePath]),
+ timelineDurationInFrames: 1000,
+ });
- expect(isTimelineSequenceDurationDraggable(audio)).toBe(true);
expect(
- getTimelineSequenceDurationDragTargets({
+ getTimelineSequenceDurationDragChanges({
+ targets: targets ?? [],
+ deltaFrames: -74,
+ }),
+ ).toEqual([]);
+ expect(
+ getTimelineSequenceDurationDragChanges({
+ targets: targets ?? [],
+ deltaFrames: -75,
+ })[0].value,
+ ).toBe(225);
+});
+
+test('Timeline duration drag trims audio and video without an explicit duration', () => {
+ for (const type of ['audio', 'video'] as const) {
+ const nodePathInfo = makeNodePathInfo(['body', type], []);
+ const media = makeTimelineSequence({
+ schema: Internals.baseSchema,
+ type,
+ duration: Infinity,
+ });
+ const nodePath = nodePathInfo.sequenceSubscriptionKey;
+ const targets = getTimelineSequenceDurationDragTargets({
draggedNodePathInfo: nodePathInfo,
+ draggedSequenceMediaDurationDragLimits: {
+ initialDuration: 78,
+ maximumDuration: 77,
+ },
selectedItems: [{type: 'sequence', nodePathInfo}],
- sequences: [audio],
+ sequences: [media],
overrideIdsToNodePaths: {
override: nodePath,
},
@@ -1951,10 +2060,118 @@ test('Timeline duration drag rejects media without an explicit duration', () =>
},
},
timelineDurationInFrames: 1000,
+ });
+
+ expect(isTimelineSequenceDurationDraggable(media)).toBe(true);
+ expect(targets?.[0].initialDuration).toBe(78);
+ expect(targets?.[0].maximumDuration).toBe(77);
+ expect(
+ getTimelineSequenceDurationDragChanges({
+ targets: targets ?? [],
+ deltaFrames: 10,
+ }),
+ ).toEqual([]);
+ expect(
+ getTimelineSequenceDurationDragChanges({
+ targets: targets ?? [],
+ deltaFrames: -10,
+ }),
+ ).toEqual([
+ {
+ fileName: nodePath.absolutePath,
+ nodePath,
+ fieldKey: 'durationInFrames',
+ value: 68,
+ defaultValue: null,
+ schema: Internals.baseSchema,
+ },
+ ]);
+ }
+});
+
+test('Timeline duration drag waits for an effective implicit media duration', () => {
+ const nodePathInfo = makeNodePathInfo(['body', 0], []);
+ const nodePath = nodePathInfo.sequenceSubscriptionKey;
+ expect(
+ getTimelineSequenceDurationDragTargets({
+ draggedNodePathInfo: nodePathInfo,
+ draggedSequenceMediaDurationDragLimits: null,
+ selectedItems: [{type: 'sequence', nodePathInfo}],
+ sequences: [
+ makeTimelineSequence({
+ schema: Internals.baseSchema,
+ type: 'video',
+ duration: Infinity,
+ }),
+ ],
+ overrideIdsToNodePaths: {override: nodePath},
+ propStatuses: {
+ [Internals.makeSequencePropsSubscriptionKey(nodePath)]: {
+ canUpdate: true,
+ props: {
+ durationInFrames: {
+ status: 'static',
+ keyframeDisplayOffsetAdjustment: null,
+ codeValue: undefined,
+ },
+ },
+ effects: [],
+ },
+ },
+ timelineDurationInFrames: 1000,
}),
).toBe(null);
});
+test('Implicit Video duration is only inserted below the media end', () => {
+ const nodePathInfo = makeNodePathInfo(['body', 0], []);
+ const nodePath = nodePathInfo.sequenceSubscriptionKey;
+ const targets = getTimelineSequenceDurationDragTargets({
+ draggedNodePathInfo: nodePathInfo,
+ draggedSequenceMediaDurationDragLimits: {
+ // <Video> holds its last frame and can therefore reach the composition end.
+ initialDuration: 300,
+ maximumDuration: 99,
+ },
+ selectedItems: [{type: 'sequence', nodePathInfo}],
+ sequences: [
+ makeTimelineSequence({
+ schema: Internals.baseSchema,
+ type: 'video',
+ duration: Infinity,
+ }),
+ ],
+ overrideIdsToNodePaths: {override: nodePath},
+ propStatuses: {
+ [Internals.makeSequencePropsSubscriptionKey(nodePath)]: {
+ canUpdate: true,
+ props: {
+ durationInFrames: {
+ status: 'static',
+ keyframeDisplayOffsetAdjustment: null,
+ codeValue: undefined,
+ },
+ },
+ effects: [],
+ },
+ },
+ timelineDurationInFrames: 300,
+ });
+
+ expect(
+ getTimelineSequenceDurationDragChanges({
+ targets: targets ?? [],
+ deltaFrames: -200,
+ }),
+ ).toEqual([]);
+ expect(
+ getTimelineSequenceDurationDragChanges({
+ targets: targets ?? [],
+ deltaFrames: -201,
+ })[0].value,
+ ).toBe(99);
+});
+
test('Timeline duration drag supports interactive cascading sequence rows', () => {
const baseSequence = makeTimelineSequence({
schema: Internals.baseSchema,
@@ -2052,6 +2269,7 @@ test('TransitionSeries.Sequence resize clamps to adjacent transition durations',
const selectedItems = [{type: 'sequence' as const, nodePathInfo}];
const durationTargets = getTimelineSequenceDurationDragTargets({
draggedNodePathInfo: nodePathInfo,
+ draggedSequenceMediaDurationDragLimits: null,
selectedItems,
sequences,
overrideIdsToNodePaths,
@@ -2108,6 +2326,7 @@ test('Timeline duration drag is blocked if one selected sequence cannot update d
expect(
getTimelineSequenceDurationDragTargets({
draggedNodePathInfo: firstNodePathInfo,
+ draggedSequenceMediaDurationDragLimits: null,
selectedItems: [
{type: 'sequence', nodePathInfo: firstNodePathInfo},
{type: 'sequence', nodePathInfo: secondNodePathInfo},
@@ -2170,6 +2389,7 @@ test('Timeline duration drag is blocked if one selected sequence duration is key
expect(
getTimelineSequenceDurationDragTargets({
draggedNodePathInfo: firstNodePathInfo,
+ draggedSequenceMediaDurationDragLimits: null,
selectedItems: [
{type: 'sequence', nodePathInfo: firstNodePathInfo},
{type: 'sequence', nodePathInfo: secondNodePathInfo},
@@ -2206,6 +2426,7 @@ test('Timeline duration drag ignores selection if dragged sequence is not select
const thirdNodePathInfo = makeNodePathInfo(['body', 2], []);
const targets = getTimelineSequenceDurationDragTargets({
draggedNodePathInfo: firstNodePathInfo,
+ draggedSequenceMediaDurationDragLimits: null,
selectedItems: [
{type: 'sequence', nodePathInfo: secondNodePathInfo},
{type: 'sequence', nodePathInfo: thirdNodePathInfo},