Skip to content

🎥 Make videos programmatically with React

46.0 KB
Raw Blame
import {afterEach, expect, test} from 'bun:test';
import {cleanup, fireEvent, render, waitFor} from '@testing-library/react';
import React, {useCallback, useMemo, useState} from 'react';
import {AbsoluteFill} from '../AbsoluteFill.js';
import {
	AnimatedImage,
	animatedImageSchema,
} from '../animated-image/AnimatedImage.js';
import type {
	SequenceControls,
	SequenceRegistrationControls,
	TSequence,
} from '../CompositionManager.js';
import type {
	EffectDefinition,
	EffectDescriptor,
} from '../effects/effect-types.js';
import {Img, imgSchema} from '../Img.js';
import {Interactive} from '../Interactive.js';
import {Internals} from '../internals.js';
import {Loading} from '../loading-indicator.js';
import type {OverrideIdToNodePaths} from '../sequence-node-path.js';
import {OverrideIdsToNodePathsGettersContext} from '../sequence-node-path.js';
import {Sequence} from '../Sequence.js';
import type {SequencePropsSubscriptionKey} from '../SequenceManager.js';
import {
	SequenceManagerActionsContext,
	SequenceManagerProvider,
	SequenceManagerRefContext,
	useSequenceManagerSequences,
	VisualModeBatchSettersContext,
	VisualModePropStatusesContext,
	VisualModePropStatusesRefContext,
	VisualModePropStatusesSubscriptionContext,
	VisualModeSettersContext,
} from '../SequenceManager.js';
import {Series} from '../series/index.js';
import {useCurrentFrame} from '../use-current-frame.js';
import type {BasicMediaInTimelineReturnType} from '../use-media-in-timeline.js';
import type {DragOverrides, PropStatuses} from '../use-schema.js';
import {
	ObserveSequenceRegistrations,
	WrapSequenceContext,
} from './wrap-sequence-context.js';

afterEach(cleanup);

type SequenceTestWrapperProps = {
	readonly children: React.ReactNode;
	readonly onRegisterSequence: (sequence: TSequence) => void;
	readonly rerenderOnRegister?: boolean;
	readonly compositionDurationInFrames?: number;
	readonly currentFrame?: number;
	readonly readOnlyStudio?: boolean;
};

type VisualModeOverrides = {
	readonly overrideIdToNodePathMappings: OverrideIdToNodePaths;
	readonly propStatuses: PropStatuses;
	readonly dragOverrides: DragOverrides;
};

const ApplyVisualModeOverrides: React.FC<{
	readonly overrides: VisualModeOverrides | null;
}> = ({overrides}) => {
	const sequences = useSequenceManagerSequences();
	const setters = React.useContext(VisualModeBatchSettersContext);
	React.useLayoutEffect(() => {
		if (overrides === null) return;
		if (setters === null)
			throw new Error('Visual mode setters have not mounted');
		const nodePaths = new Map<string, SequencePropsSubscriptionKey>();
		for (const nodePath of Object.values(
			overrides.overrideIdToNodePathMappings,
		)) {
			nodePaths.set(
				Internals.makeSequencePropsSubscriptionKey(nodePath),
				nodePath,
			);
		}

		for (const sequence of sequences) {
			const nodePath =
				sequence.controls === null
					? null
					: overrides.overrideIdToNodePathMappings[
							sequence.controls.overrideId
						];
			if (nodePath)
				nodePaths.set(
					Internals.makeSequencePropsSubscriptionKey(nodePath),
					nodePath,
				);
		}

		setters.setDragOverridesBatch(
			[...nodePaths].flatMap(([subscriptionKey, nodePath]) =>
				Object.entries(overrides.dragOverrides[subscriptionKey] ?? {}).map(
					([key, value]) => ({nodePath, key, value}),
				),
			),
		);
	}, [overrides, sequences, setters]);
	return null;
};

const makeEffect = (): EffectDescriptor<unknown> => {
	const definition: EffectDefinition<unknown> = {
		type: 'test-effect',
		label: 'Test effect',
		documentationLink: null,
		backend: '2d',
		calculateKey: () => 'test-effect',
		setup: () => ({}),
		apply: () => undefined,
		cleanup: () => undefined,
		schema: {},
		validateParams: () => undefined,
	};

	return {
		definition,
		effectKey: 'test-effect',
		params: {},
		memoized: false,
	};
};

const SequenceTestWrapperWithVisualModeOverrides: React.FC<
	SequenceTestWrapperProps & {
		readonly visualModeOverrides: VisualModeOverrides | null;
	}
> = ({
	children,
	onRegisterSequence,
	rerenderOnRegister = false,
	visualModeOverrides,
	compositionDurationInFrames,
	currentFrame,
	readOnlyStudio = false,
}) => {
	const [, setTick] = useState(0);

	const registerSequence = useCallback(
		(sequence: TSequence) => {
			onRegisterSequence(sequence);
			if (rerenderOnRegister) {
				setTick((t) => t + 1);
			}
		},
		[onRegisterSequence, rerenderOnRegister],
	);

	const visualPropStatuses = useMemo(
		() => ({
			propStatuses: visualModeOverrides?.propStatuses ?? {},
		}),
		[visualModeOverrides],
	);

	const visualPropStatusesSubscription = useMemo(
		() => ({
			subscribe: () => () => undefined,
			getSnapshot: (key: string | null) =>
				key === null ? null : (visualModeOverrides?.propStatuses[key] ?? null),
		}),
		[visualModeOverrides],
	);

	const overrideIdToNodePathContext = useMemo(
		() => ({
			overrideIdToNodePathMappings:
				visualModeOverrides?.overrideIdToNodePathMappings ?? {},
		}),
		[visualModeOverrides],
	);

	const visualSetters = useMemo(
		() => ({
			setDragOverrides: () => undefined,
			clearDragOverrides: () => undefined,
			setEffectDragOverrides: () => undefined,
			clearEffectDragOverrides: () => undefined,
			remapPropStatuses: () => undefined,
			setPropStatuses: () => undefined,
		}),
		[],
	);

	return (
		<WrapSequenceContext
			compositionDurationInFrames={compositionDurationInFrames}
			currentFrame={currentFrame}
		>
			<Internals.RemotionEnvironmentContext
				value={{
					isRendering: false,
					isClientSideRendering: false,
					isPlayer: false,
					isStudio: true,
					isReadOnlyStudio: readOnlyStudio,
				}}
			>
				<OverrideIdsToNodePathsGettersContext.Provider
					value={overrideIdToNodePathContext}
				>
					<SequenceManagerProvider>
						<ApplyVisualModeOverrides overrides={visualModeOverrides} />
						<ObserveSequenceRegistrations
							onRegisterSequence={registerSequence}
						/>
						<VisualModePropStatusesSubscriptionContext.Provider
							value={visualPropStatusesSubscription}
						>
							<VisualModePropStatusesContext.Provider
								value={visualPropStatuses}
							>
								<VisualModeSettersContext.Provider value={visualSetters}>
									{children}
								</VisualModeSettersContext.Provider>
							</VisualModePropStatusesContext.Provider>
						</VisualModePropStatusesSubscriptionContext.Provider>
					</SequenceManagerProvider>
				</OverrideIdsToNodePathsGettersContext.Provider>
			</Internals.RemotionEnvironmentContext>
		</WrapSequenceContext>
	);
};

const SequenceTestWrapper: React.FC<SequenceTestWrapperProps> = ({
	children,
	onRegisterSequence,
	rerenderOnRegister = false,
	compositionDurationInFrames,
	currentFrame,
	readOnlyStudio,
}) => {
	return (
		<SequenceTestWrapperWithVisualModeOverrides
			onRegisterSequence={onRegisterSequence}
			rerenderOnRegister={rerenderOnRegister}
			visualModeOverrides={null}
			compositionDurationInFrames={compositionDurationInFrames}
			currentFrame={currentFrame}
			readOnlyStudio={readOnlyStudio}
		>
			{children}
		</SequenceTestWrapperWithVisualModeOverrides>
	);
};

const makeMediaInTimelineData = ({
	startMediaFrom,
	playbackRate = 1,
}: {
	startMediaFrom: number;
	playbackRate?: number;
}): BasicMediaInTimelineReturnType =>
	({
		duration: 100,
		muted: false,
		finalDisplayName: 'video.mp4',
		startMediaFrom,
		src: 'video.mp4',
		playbackRate,
	}) as unknown as BasicMediaInTimelineReturnType;

test('Sequence calls registerSequence exactly once on mount', () => {
	let registerCalls = 0;

	render(
		<SequenceTestWrapper
			rerenderOnRegister
			onRegisterSequence={() => {
				registerCalls++;
			}}
		>
			<Sequence>hi</Sequence>
		</SequenceTestWrapper>,
	);

	expect(registerCalls).toBe(1);
});

test('Sequence timing changes update its registration without changing order', async () => {
	let getSequences = (): TSequence[] => {
		throw new Error('Sequence manager has not mounted');
	};

	const CaptureSequences = () => {
		const sequencesRef = React.useContext(SequenceManagerRefContext);
		getSequences = () => sequencesRef.current;
		return null;
	};

	const renderSequences = (firstDuration: number) => (
		<WrapSequenceContext>
			<Internals.RemotionEnvironmentContext
				value={{
					isRendering: false,
					isClientSideRendering: false,
					isPlayer: false,
					isStudio: true,
					isReadOnlyStudio: false,
				}}
			>
				<SequenceManagerProvider>
					<CaptureSequences />
					<Sequence name="First" durationInFrames={firstDuration} />
					<Sequence name="Second" durationInFrames={20} />
				</SequenceManagerProvider>
			</Internals.RemotionEnvironmentContext>
		</WrapSequenceContext>
	);

	const rendered = render(renderSequences(10));
	await waitFor(() => {
		expect(getSequences()).toHaveLength(2);
	});
	const initialIds = getSequences().map((sequence) => sequence.id);

	rendered.rerender(renderSequences(15));
	await waitFor(() => {
		expect(getSequences()[0]?.duration).toBe(15);
	});
	expect(getSequences().map((sequence) => sequence.displayName)).toEqual([
		'First',
		'Second',
	]);
	expect(getSequences().map((sequence) => sequence.id)).toEqual(initialIds);
});

test('Interactive runtime values update mounted consumers without re-registering the sequence', () => {
	const registeredSequences: TSequence[] = [];
	const onRegisterSequence = (sequence: TSequence) => {
		registeredSequences.push(sequence);
	};

	const renderInteractiveDiv = (opacity: number, color: string) => (
		<SequenceTestWrapper onRegisterSequence={onRegisterSequence}>
			<Interactive.Div style={{color, opacity}}>Hello</Interactive.Div>
		</SequenceTestWrapper>
	);
	const producer = render(renderInteractiveDiv(0.25, 'red'));
	const controls = registeredSequences.find(
		(sequence) => sequence.displayName === '<Interactive.Div>',
	)?.controls;
	if (!controls) {
		throw new Error('Expected Interactive.Div controls');
	}

	let consumerRenders = 0;
	const RuntimeOpacity: React.FC<{
		readonly controls: SequenceRegistrationControls;
	}> = ({controls: consumerControls}) => {
		consumerRenders++;
		const opacity = React.useSyncExternalStore(
			consumerControls.runtimeValues.subscribe,
			() => consumerControls.runtimeValues.getSnapshot()['style.opacity'],
		);

		return <output>{String(opacity)}</output>;
	};

	const consumer = render(<RuntimeOpacity controls={controls} />);

	expect(consumer.getByText('0.25')).toBeTruthy();
	expect(consumerRenders).toBe(1);
	expect(registeredSequences).toHaveLength(1);

	producer.rerender(renderInteractiveDiv(0.75, 'red'));
	expect(consumer.getByText('0.75')).toBeTruthy();
	expect(consumerRenders).toBe(2);
	expect(registeredSequences).toHaveLength(1);

	producer.rerender(renderInteractiveDiv(0.75, 'blue'));
	expect(consumer.getByText('0.75')).toBeTruthy();
	expect(consumerRenders).toBe(2);
	expect(registeredSequences).toHaveLength(1);
});

test('Interactive controls capture the video config from the surrounding sequence', () => {
	const registeredSequences: TSequence[] = [];
	const SequenceChild: React.FC = () => {
		return <Interactive.Div>Hello</Interactive.Div>;
	};

	render(
		<SequenceTestWrapper
			compositionDurationInFrames={120}
			currentFrame={30}
			onRegisterSequence={(sequence) => registeredSequences.push(sequence)}
		>
			<Sequence from={30} durationInFrames={60}>
				<SequenceChild />
			</Sequence>
		</SequenceTestWrapper>,
	);

	const interactiveSequence = registeredSequences.find(
		(sequence) => sequence.displayName === '<Interactive.Div>',
	);
	expect(interactiveSequence?.controls?.videoConfigValues).toMatchObject({
		durationInFrames: 60,
		fps: 30,
	});
});

test('Interactive runtime values are published only after a render commits', () => {
	const registeredSequences: TSequence[] = [];
	const onRegisterSequence = (sequence: TSequence) => {
		registeredSequences.push(sequence);
	};

	const never = new Promise<never>(() => undefined);
	const Suspend: React.FC<{readonly active: boolean}> = ({active}) => {
		if (active) {
			throw never;
		}

		return null;
	};

	const renderInteractiveDiv = (opacity: number, suspend: boolean) => (
		<React.Suspense fallback={<span>Suspended</span>}>
			<SequenceTestWrapper onRegisterSequence={onRegisterSequence}>
				<Interactive.Div style={{opacity}}>
					<Suspend active={suspend} />
				</Interactive.Div>
			</SequenceTestWrapper>
		</React.Suspense>
	);
	const producer = render(renderInteractiveDiv(0.25, false));
	const controls = registeredSequences.find(
		(sequence) => sequence.displayName === '<Interactive.Div>',
	)?.controls;
	if (!controls) {
		throw new Error('Expected Interactive.Div controls');
	}

	producer.rerender(renderInteractiveDiv(0.75, true));

	expect(producer.getByText('Suspended')).toBeTruthy();
	expect(controls.runtimeValues.getSnapshot()['style.opacity']).toBe(0.25);
});

test('Sequence registers its documentation link', () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Sequence _remotionInternalDocumentationLink="https://www.remotion.dev/docs/img">
				hi
			</Sequence>
		</SequenceTestWrapper>,
	);

	expect(registeredSequences[0]?.documentationLink).toBe(
		'https://www.remotion.dev/docs/img',
	);
});

test('Sequence registers its wrapper element for Studio outlines', () => {
	const registeredSequences: TSequence[] = [];
	const ref = React.createRef<HTMLDivElement>();

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Sequence ref={ref}>hi</Sequence>
		</SequenceTestWrapper>,
	);

	expect(registeredSequences[0]?.refForOutline?.current?.tagName).toBe('DIV');
	expect(registeredSequences[0]?.refForOutline?.current).toBe(ref.current);
});

test('Sequence ignores outlineRef and outlines its wrapper', () => {
	const registeredSequences: TSequence[] = [];
	const outlineRef = React.createRef<HTMLDivElement>();
	const wrapperRef = React.createRef<HTMLDivElement>();

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Sequence ref={wrapperRef} outlineRef={outlineRef}>
				<div ref={outlineRef}>hi</div>
			</Sequence>
		</SequenceTestWrapper>,
	);

	expect(registeredSequences[0]?.refForOutline?.current?.tagName).toBe('DIV');
	expect(registeredSequences[0]?.refForOutline?.current).toBe(
		wrapperRef.current,
	);
});

test('Sequence layout="none" ignores outlineRef and registers automatic outlines', () => {
	const registeredSequences: TSequence[] = [];
	const outlineRef = React.createRef<HTMLDivElement>();

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Sequence layout="none" outlineRef={outlineRef}>
				<div ref={outlineRef}>hi</div>
			</Sequence>
		</SequenceTestWrapper>,
	);

	expect(outlineRef.current).toBeInstanceOf(HTMLDivElement);
	expect(
		Internals.SequenceOutlineInternals.getNodes(
			registeredSequences[0].refForOutline!,
		),
	).toEqual([]);
});

test('Series inherits Sequence controls', () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Series from={5} freeze={2}>
				<Series.Sequence durationInFrames={10}>First</Series.Sequence>
			</Series>
		</SequenceTestWrapper>,
	);

	const series = registeredSequences.find(
		(sequence) =>
			sequence.controls?.componentIdentity === 'dev.remotion.remotion.Series',
	);

	expect(series?.controls?.schema).toHaveProperty('from');
	expect(series?.controls?.schema).toHaveProperty('freeze');
	expect(series?.controls?.schema).toHaveProperty('durationInFrames');
	expect(series?.isInsideSeries).toBe(false);
});

test('Series.Sequence registers with its own visual controls', () => {
	const registeredSequences: TSequence[] = [];
	const firstStack = 'Error\n    at FirstSeriesSequence';
	const secondStack = 'Error\n    at SecondSeriesSequence';
	const ConnectedComposition: React.FC = () => null;

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Series>
				<Series.Sequence
					durationInFrames={10}
					premountFor={30}
					{...({
						_remotionInternalStack: firstStack,
					} as {readonly _remotionInternalStack: string})}
				>
					<ConnectedComposition />
				</Series.Sequence>
				<Series.Sequence
					durationInFrames={20}
					{...({
						_remotionInternalStack: secondStack,
					} as {readonly _remotionInternalStack: string})}
				>
					Second
				</Series.Sequence>
			</Series>
		</SequenceTestWrapper>,
	);

	const seriesSequences = registeredSequences.filter(
		(sequence) => sequence.displayName === '<Series.Sequence>',
	);

	expect(seriesSequences).toHaveLength(2);
	for (const sequence of seriesSequences) {
		expect(sequence.controls?.componentIdentity).toBe(
			'dev.remotion.remotion.Series.Sequence',
		);
		expect(sequence.isInsideSeries).toBe(true);
	}

	expect(
		seriesSequences.map(
			(sequence) =>
				sequence.controls?.runtimeValues.getSnapshot().durationInFrames,
		),
	).toEqual([10, 20]);
	expect(seriesSequences.map((sequence) => sequence.getStack())).toEqual([
		firstStack,
		secondStack,
	]);
	expect(seriesSequences[0]?.singleChildComponent).toBe(ConnectedComposition);
});

test('Interactive.withSchema preserves source stacks through controls without consuming a public stack prop', () => {
	const registeredSequences: TSequence[] = [];
	const sourceStack = 'Error\n    at UserAuthoredComponent';
	const received = {
		stack: null as string | null,
		internalStack: false,
	};

	type PublicProps = {readonly stack: string};
	const Inner: React.FC<
		PublicProps & {readonly controls: SequenceControls | undefined}
	> = (props) => {
		received.stack = props.stack;
		received.internalStack = '_remotionInternalStack' in props;
		return <Sequence controls={props.controls} name="<Component>" />;
	};

	const Component = Interactive.withSchema({
		Component: Inner,
		componentName: '<Component>',
		componentIdentity: 'com.example.Component',
		schema: {},
		supportsEffects: false,
	});

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Component
				stack="application-stack"
				{...({
					_remotionInternalStack: sourceStack,
				} as {readonly _remotionInternalStack: string})}
			/>
		</SequenceTestWrapper>,
	);

	expect(received.stack).toBe('application-stack');
	expect(received.internalStack).toBe(false);
	expect(registeredSequences).toHaveLength(1);
	expect(registeredSequences[0]?.getStack()).toBe(sourceStack);
	expect(registeredSequences[0]?.controls?.componentIdentity).toBe(
		'com.example.Component',
	);
});

test('read-only Studio registers visual controls without applying overrides', () => {
	const registeredSequences: TSequence[] = [];
	const nodePath = {
		absolutePath: '/src/Composition.tsx',
		nodePath: ['body', 0],
		sequenceKeys: [],
		effectKeys: [],
		videoConfigValues: null,
	};
	const subscriptionKey = Internals.makeSequencePropsSubscriptionKey(nodePath);

	render(
		<SequenceTestWrapperWithVisualModeOverrides
			readOnlyStudio
			onRegisterSequence={(registeredSequence) => {
				registeredSequences.push(registeredSequence);
			}}
			visualModeOverrides={{
				overrideIdToNodePathMappings: new Proxy(
					{},
					{get: () => nodePath},
				) as OverrideIdToNodePaths,
				propStatuses: {},
				dragOverrides: {
					[subscriptionKey]: {
						durationInFrames: Internals.makeStaticDragOverride(20),
					},
				},
			}}
		>
			<Interactive.Div durationInFrames={10}>Hello</Interactive.Div>
		</SequenceTestWrapperWithVisualModeOverrides>,
	);

	const sequence = registeredSequences.findLast(
		(item) => item.displayName === '<Interactive.Div>',
	);
	expect(sequence?.controls).not.toBe(null);
	expect(sequence?.controls?.componentIdentity).toBe(
		'dev.remotion.remotion.Interactive.Div',
	);
	expect(sequence?.duration).toBe(10);
});

test('Series.Sequence timing overrides cascade to later sequences', async () => {
	const registeredSequences: TSequence[] = [];
	const onRegisterSequence = (sequence: TSequence) => {
		registeredSequences.push(sequence);
	};

	const renderSeries = ({
		overrideIdToNodePathMappings,
		propStatuses,
		dragOverrides,
	}: {
		overrideIdToNodePathMappings: OverrideIdToNodePaths;
		propStatuses: PropStatuses;
		dragOverrides: DragOverrides;
	}) => (
		<SequenceTestWrapperWithVisualModeOverrides
			onRegisterSequence={onRegisterSequence}
			visualModeOverrides={{
				overrideIdToNodePathMappings,
				propStatuses,
				dragOverrides,
			}}
		>
			<Series>
				<Series.Sequence name="First" durationInFrames={10} trimBefore={2}>
					First
				</Series.Sequence>
				<Series.Sequence name="Second" durationInFrames={20}>
					Second
				</Series.Sequence>
			</Series>
		</SequenceTestWrapperWithVisualModeOverrides>
	);

	const rendered = render(
		renderSeries({
			overrideIdToNodePathMappings: {},
			propStatuses: {},
			dragOverrides: {},
		}),
	);
	const firstSequence = registeredSequences.find(
		(sequence) => sequence.displayName === 'First',
	);
	if (!firstSequence?.controls) {
		throw new Error('Expected the first Series.Sequence to be interactive');
	}

	const firstSequenceControls = firstSequence.controls;

	const nodePath = {
		absolutePath: '/src/Composition.tsx',
		nodePath: ['body', 0],
		sequenceKeys: [],
		effectKeys: [],
		videoConfigValues: null,
	};
	const subscriptionKey = Internals.makeSequencePropsSubscriptionKey(nodePath);
	const makeTimingOverride = ({
		durationInFrames,
		trimBefore,
	}: {
		durationInFrames: number;
		trimBefore: number;
	}) => ({
		overrideIdToNodePathMappings: {
			[firstSequenceControls.overrideId]: nodePath,
		},
		propStatuses: {
			[subscriptionKey]: {
				durationDependentKeyframes: null,
				canUpdate: true as const,
				props: {
					durationInFrames: {
						status: 'static' as const,
						keyframeDisplayOffsetAdjustment: null,
						codeValue: 10,
					},
					trimBefore: {
						status: 'static' as const,
						keyframeDisplayOffsetAdjustment: null,
						codeValue: 2,
					},
				},
				effects: [],
			},
		},
		dragOverrides: {
			[subscriptionKey]: {
				durationInFrames: Internals.makeStaticDragOverride(durationInFrames),
				trimBefore: Internals.makeStaticDragOverride(trimBefore),
			},
		},
	});

	registeredSequences.length = 0;
	rendered.rerender(
		renderSeries(makeTimingOverride({durationInFrames: 7, trimBefore: 5})),
	);
	await waitFor(() => {
		const first = registeredSequences.find(
			(sequence) => sequence.displayName === 'First',
		);
		expect(first?.duration).toBe(7);
		expect(first?.trimBefore).toBe(5);
		expect(
			registeredSequences.find((sequence) => sequence.displayName === 'Second')
				?.from,
		).toBe(7);
	});

	registeredSequences.length = 0;
	rendered.rerender(
		renderSeries(makeTimingOverride({durationInFrames: 18, trimBefore: 7})),
	);
	await waitFor(() => {
		const first = registeredSequences.find(
			(sequence) => sequence.displayName === 'First',
		);
		expect(first?.duration).toBe(18);
		expect(first?.trimBefore).toBe(7);
		expect(
			registeredSequences.find((sequence) => sequence.displayName === 'Second')
				?.from,
		).toBe(18);
	});
});

test('Img registers its documentation link for default labels', () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Img src="test.png" />
		</SequenceTestWrapper>,
	);

	expect(registeredSequences[0]?.documentationLink).toBe(
		'https://www.remotion.dev/docs/img',
	);
});

test('Named Img components keep the default documentation link', () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Img src="test.png" name="Intro" />
		</SequenceTestWrapper>,
	);

	expect(registeredSequences[0]?.documentationLink).toBe(
		'https://www.remotion.dev/docs/img',
	);
});

test('Img exposes non-keyframable premounting schema fields', () => {
	expect(imgSchema.premountFor.keyframable).toBe(false);
	expect(imgSchema.postmountFor.keyframable).toBe(false);
});

test('Img hides the image while premounted and postmounted', () => {
	const premounted = render(
		<SequenceTestWrapper currentFrame={0} onRegisterSequence={() => undefined}>
			<Img
				src="test.png"
				from={10}
				durationInFrames={20}
				premountFor={10}
				style={{opacity: 0.5}}
			/>
		</SequenceTestWrapper>,
	);
	const premountedStyle = premounted.container
		.querySelector('img')
		?.getAttribute('style');
	expect(premountedStyle).toContain('display: none');
	expect(premountedStyle).toContain('pointer-events: none');
	expect(premountedStyle).toContain('opacity: 0.5');
	premounted.unmount();

	const postmounted = render(
		<SequenceTestWrapper currentFrame={35} onRegisterSequence={() => undefined}>
			<Img src="test.png" from={10} durationInFrames={20} postmountFor={10} />
		</SequenceTestWrapper>,
	);
	const postmountedStyle = postmounted.container
		.querySelector('img')
		?.getAttribute('style');
	expect(postmountedStyle).toContain('display: none');
	expect(postmountedStyle).toContain('pointer-events: none');
});

test('Img allows overriding the premount and postmount styles', () => {
	const premounted = render(
		<SequenceTestWrapper currentFrame={0} onRegisterSequence={() => undefined}>
			<Img
				src="test.png"
				from={10}
				durationInFrames={20}
				premountFor={10}
				styleWhilePremounted={{display: 'block', opacity: 0.25}}
			/>
		</SequenceTestWrapper>,
	);
	const premountedStyle = premounted.container
		.querySelector('img')
		?.getAttribute('style');
	expect(premountedStyle).toContain('display: block');
	expect(premountedStyle).toContain('opacity: 0.25');
	premounted.unmount();

	const postmounted = render(
		<SequenceTestWrapper currentFrame={35} onRegisterSequence={() => undefined}>
			<Img
				src="test.png"
				from={10}
				durationInFrames={20}
				postmountFor={10}
				styleWhilePostmounted={{display: 'block', opacity: 0.75}}
			/>
		</SequenceTestWrapper>,
	);
	const postmountedStyle = postmounted.container
		.querySelector('img')
		?.getAttribute('style');
	expect(postmountedStyle).toContain('display: block');
	expect(postmountedStyle).toContain('opacity: 0.75');
});

test('Img registers premount and postmount ranges once', async () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Img
				src="test.png"
				from={10}
				durationInFrames={20}
				premountFor={10}
				postmountFor={5}
			/>
		</SequenceTestWrapper>,
	);

	await waitFor(() => {
		expect(registeredSequences).toHaveLength(1);
	});
	expect(registeredSequences[0].premountDisplay).toBe(10);
	expect(registeredSequences[0].postmountDisplay).toBe(5);
});

test('Img with effects delegates premounting to one CanvasImage owner', async () => {
	const registeredSequences: TSequence[] = [];

	const rendered = render(
		<SequenceTestWrapper
			currentFrame={0}
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Img
				src="test.png"
				width={100}
				height={50}
				effects={[makeEffect()]}
				from={10}
				durationInFrames={20}
				premountFor={10}
				postmountFor={5}
			/>
		</SequenceTestWrapper>,
	);

	await waitFor(() => {
		expect(registeredSequences).toHaveLength(1);
	});
	expect(registeredSequences[0].premountDisplay).toBe(10);
	expect(registeredSequences[0].postmountDisplay).toBe(5);
	expect(registeredSequences[0].documentationLink).toBe(
		'https://www.remotion.dev/docs/img',
	);
	expect(
		rendered.container.querySelector('canvas')?.getAttribute('style'),
	).toContain('display: none');
});

test('AnimatedImage registers an automatic Studio outline', () => {
	const registeredSequences: TSequence[] = [];
	const ref = React.createRef<HTMLCanvasElement>();

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<AnimatedImage ref={ref} onError={() => undefined} src="test.gif" />
		</SequenceTestWrapper>,
	);

	expect(ref.current).toBeInstanceOf(HTMLCanvasElement);
	expect(
		Internals.SequenceOutlineInternals.getNodes(
			registeredSequences[0].refForOutline!,
		),
	).toEqual([]);
});

test('AnimatedImage exposes non-keyframable premounting schema fields', () => {
	expect(animatedImageSchema.premountFor.keyframable).toBe(false);
	expect(animatedImageSchema.postmountFor.keyframable).toBe(false);
});

test('AnimatedImage applies crop props to its canvas', () => {
	const {container} = render(
		<SequenceTestWrapper onRegisterSequence={() => undefined}>
			<AnimatedImage
				cropBottom={0.4}
				cropLeft={0.1}
				cropRight={0.2}
				cropTop={0.3}
				onError={() => undefined}
				src="test.gif"
			/>
		</SequenceTestWrapper>,
	);

	const canvas = container.querySelector('canvas');
	expect(canvas?.style.clipPath).toBe('inset(30% 20% 40% 10%)');
});

test('AnimatedImage hides the canvas while premounted and postmounted', () => {
	const premounted = render(
		<SequenceTestWrapper currentFrame={0} onRegisterSequence={() => undefined}>
			<AnimatedImage
				src="test.gif"
				from={10}
				durationInFrames={20}
				premountFor={10}
				style={{opacity: 0.5}}
				onError={() => undefined}
			/>
		</SequenceTestWrapper>,
	);
	const premountedStyle = premounted.container
		.querySelector('canvas')
		?.getAttribute('style');
	expect(premountedStyle).toContain('display: none');
	expect(premountedStyle).toContain('pointer-events: none');
	expect(premountedStyle).toContain('opacity: 0.5');
	premounted.unmount();

	const postmounted = render(
		<SequenceTestWrapper currentFrame={35} onRegisterSequence={() => undefined}>
			<AnimatedImage
				src="test.gif"
				from={10}
				durationInFrames={20}
				postmountFor={10}
				onError={() => undefined}
			/>
		</SequenceTestWrapper>,
	);
	const postmountedStyle = postmounted.container
		.querySelector('canvas')
		?.getAttribute('style');
	expect(postmountedStyle).toContain('display: none');
	expect(postmountedStyle).toContain('pointer-events: none');
});

test('AnimatedImage allows overriding the premount and postmount styles', () => {
	const premounted = render(
		<SequenceTestWrapper currentFrame={0} onRegisterSequence={() => undefined}>
			<AnimatedImage
				src="test.gif"
				from={10}
				durationInFrames={20}
				premountFor={10}
				styleWhilePremounted={{display: 'block', opacity: 0.25}}
				onError={() => undefined}
			/>
		</SequenceTestWrapper>,
	);
	const premountedStyle = premounted.container
		.querySelector('canvas')
		?.getAttribute('style');
	expect(premountedStyle).toContain('display: block');
	expect(premountedStyle).toContain('opacity: 0.25');
	premounted.unmount();

	const postmounted = render(
		<SequenceTestWrapper currentFrame={35} onRegisterSequence={() => undefined}>
			<AnimatedImage
				src="test.gif"
				from={10}
				durationInFrames={20}
				postmountFor={10}
				styleWhilePostmounted={{display: 'block', opacity: 0.75}}
				onError={() => undefined}
			/>
		</SequenceTestWrapper>,
	);
	const postmountedStyle = postmounted.container
		.querySelector('canvas')
		?.getAttribute('style');
	expect(postmountedStyle).toContain('display: block');
	expect(postmountedStyle).toContain('opacity: 0.75');
});

test('AnimatedImage registers premount and postmount ranges once', async () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<AnimatedImage
				src="test.gif"
				from={10}
				durationInFrames={20}
				premountFor={10}
				postmountFor={5}
				onError={() => undefined}
			/>
		</SequenceTestWrapper>,
	);

	await waitFor(() => {
		expect(registeredSequences).toHaveLength(1);
	});
	expect(registeredSequences[0].premountDisplay).toBe(10);
	expect(registeredSequences[0].postmountDisplay).toBe(5);
});

test('AnimatedImage remains visible with a negative offset', () => {
	const {container} = render(
		<SequenceTestWrapper
			compositionDurationInFrames={100}
			currentFrame={75}
			onRegisterSequence={() => undefined}
		>
			<AnimatedImage from={-100} onError={() => undefined} src="test.gif" />
		</SequenceTestWrapper>,
	);

	expect(container.querySelector('canvas')).not.toBeNull();
});

test('AnimatedImage forwards data and aria attributes to its canvas', () => {
	const {container} = render(
		<SequenceTestWrapper onRegisterSequence={() => undefined}>
			<AnimatedImage
				aria-label="Animated image preview"
				data-testid="animated-image-canvas"
				onError={() => undefined}
				src="test.gif"
			/>
		</SequenceTestWrapper>,
	);

	const canvas = container.querySelector('canvas');

	expect(canvas?.getAttribute('aria-label')).toBe('Animated image preview');
	expect(canvas?.getAttribute('data-testid')).toBe('animated-image-canvas');
});

test('Video media registration accounts for its own negative from', () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Sequence
				layout="none"
				from={-10}
				durationInFrames={50}
				_remotionInternalIsMedia={{
					type: 'video',
					data: makeMediaInTimelineData({startMediaFrom: 5}),
				}}
			/>
		</SequenceTestWrapper>,
	);

	const videoSequence = registeredSequences.find(
		(sequence) => sequence.type === 'video',
	);

	expect(videoSequence?.startMediaFrom).toBe(15);
	expect(videoSequence?.mediaFrameAtSequenceZero).toBe(5);
});

test('Video media registration keeps trimBefore at sequence frame zero', () => {
	const registeredSequences: TSequence[] = [];
	const onRegisterSequence = (sequence: TSequence) => {
		registeredSequences.push(sequence);
	};

	const {rerender} = render(
		<SequenceTestWrapper onRegisterSequence={onRegisterSequence}>
			<Sequence
				layout="none"
				from={31}
				durationInFrames={47}
				_remotionInternalIsMedia={{
					type: 'video',
					data: makeMediaInTimelineData({startMediaFrom: 31}),
				}}
			/>
		</SequenceTestWrapper>,
	);

	const videoSequence = registeredSequences.find(
		(sequence) => sequence.type === 'video',
	);

	expect(videoSequence?.from).toBe(31);
	expect(videoSequence?.duration).toBe(47);
	expect(videoSequence?.mediaFrameAtSequenceZero).toBe(31);

	rerender(
		<SequenceTestWrapper onRegisterSequence={onRegisterSequence}>
			<Sequence
				layout="none"
				from={31}
				durationInFrames={47}
				_remotionInternalIsMedia={{
					type: 'video',
					data: makeMediaInTimelineData({startMediaFrom: 41}),
				}}
			/>
		</SequenceTestWrapper>,
	);

	const updatedVideoSequence = registeredSequences.at(-1);
	if (updatedVideoSequence?.type !== 'video') {
		throw new Error('Expected an updated video sequence');
	}

	expect(updatedVideoSequence.mediaFrameAtSequenceZero).toBe(41);
});

test('Video media registration accounts for Sequence trimBefore', () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Sequence
				layout="none"
				trimBefore={10}
				durationInFrames={50}
				_remotionInternalIsMedia={{
					type: 'video',
					data: makeMediaInTimelineData({startMediaFrom: 5}),
				}}
			/>
		</SequenceTestWrapper>,
	);

	const videoSequence = registeredSequences.find(
		(sequence) => sequence.type === 'video',
	);

	expect(videoSequence?.startMediaFrom).toBe(15);
	expect(videoSequence?.mediaFrameAtSequenceZero).toBe(5);
});

test('Video media registration stores frozen media frame', () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Sequence
				layout="none"
				durationInFrames={50}
				freeze={12}
				_remotionInternalIsMedia={{
					type: 'video',
					data: makeMediaInTimelineData({
						startMediaFrom: 5,
						playbackRate: 2,
					}),
				}}
			/>
		</SequenceTestWrapper>,
	);

	const videoSequence = registeredSequences.find(
		(sequence) => sequence.type === 'video',
	);

	expect(videoSequence?.frozenFrame).toBe(12);
	expect(videoSequence?.mediaFrameAtSequenceZero).toBe(5);
	expect(videoSequence?.frozenMediaFrame).toBe(29);
});

test('Video media registration keeps frozen frame sequence-local for negative from', () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Sequence
				layout="none"
				from={-10}
				durationInFrames={50}
				freeze={12}
				_remotionInternalIsMedia={{
					type: 'video',
					data: makeMediaInTimelineData({startMediaFrom: 5}),
				}}
			/>
		</SequenceTestWrapper>,
	);

	const videoSequence = registeredSequences.find(
		(sequence) => sequence.type === 'video',
	);

	expect(videoSequence?.startMediaFrom).toBe(15);
	expect(videoSequence?.mediaFrameAtSequenceZero).toBe(5);
	expect(videoSequence?.frozenFrame).toBe(12);
	expect(videoSequence?.frozenMediaFrame).toBe(17);
});

test('Img registers an automatic outline for its image element', () => {
	const registeredSequences: TSequence[] = [];

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Img src="test.png" />
		</SequenceTestWrapper>,
	);

	expect(
		Internals.SequenceOutlineInternals.getNodes(
			registeredSequences[0].refForOutline!,
		),
	).toEqual([]);
});

test('Interactive elements register automatic Studio outlines', () => {
	const registeredSequences: TSequence[] = [];
	const divRef = React.createRef<HTMLDivElement>();
	const rectRef = React.createRef<SVGRectElement>();
	const documentationLink = 'https://www.remotion.dev/docs/interactive';

	render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Interactive.Div
				ref={divRef}
				cropBottom={0.4}
				cropLeft={0.1}
				cropRight={0.2}
				cropTop={0.3}
			>
				Hello
			</Interactive.Div>
			<Interactive.Span>World</Interactive.Span>
			<Interactive.Svg viewBox="0 0 100 100">
				<Interactive.Circle />
				<Interactive.Ellipse />
				<Interactive.G />
				<Interactive.Line />
				<Interactive.Path />
				<Interactive.Rect
					ref={rectRef}
					cropLeft={0.25}
					height={100}
					width={100}
				/>
				<Interactive.Text x={50} y={50}>
					Label
				</Interactive.Text>
			</Interactive.Svg>
		</SequenceTestWrapper>,
	);

	expect(
		registeredSequences.map((sequence) => sequence.displayName).sort(),
	).toEqual([
		'<Interactive.Circle>',
		'<Interactive.Div>',
		'<Interactive.Ellipse>',
		'<Interactive.G>',
		'<Interactive.Line>',
		'<Interactive.Path>',
		'<Interactive.Rect>',
		'<Interactive.Span>',
		'<Interactive.Svg>',
		'<Interactive.Text>',
	]);

	const getByName = (displayName: string) =>
		registeredSequences.find(
			(sequence) => sequence.displayName === displayName,
		);

	for (const displayName of [
		'<Interactive.Div>',
		'<Interactive.Span>',
		'<Interactive.Svg>',
		'<Interactive.Rect>',
		'<Interactive.Text>',
	]) {
		expect(
			Internals.SequenceOutlineInternals.getNodes(
				getByName(displayName)!.refForOutline!,
			),
		).toEqual([]);
	}

	expect(getByName('<Interactive.Div>')?.documentationLink).toBe(
		documentationLink,
	);
	expect(getByName('<Interactive.Rect>')?.documentationLink).toBe(
		documentationLink,
	);
	expect(divRef.current?.tagName).toBe('DIV');
	expect(getByName('<Interactive.Div>')?.controls).not.toBe(null);
	expect(divRef.current?.style.clipPath).toBe('inset(30% 20% 40% 10%)');
	expect(divRef.current?.getAttributeNames()).not.toContain('cropleft');
	expect(rectRef.current?.style.clipPath).toBe('inset(0% 0% 0% 25%)');

	for (const sequence of registeredSequences) {
		for (const cropField of [
			'cropLeft',
			'cropRight',
			'cropTop',
			'cropBottom',
		]) {
			expect(sequence.controls?.schema).toHaveProperty(cropField);
		}
	}

	for (const displayName of [
		'<Interactive.Div>',
		'<Interactive.Span>',
		'<Interactive.Text>',
	]) {
		expect(getByName(displayName)?.controls?.schema).toHaveProperty([
			'style.fontSize',
		]);
		expect(getByName(displayName)?.controls?.schema).toHaveProperty('children');
	}

	for (const displayName of [
		'<Interactive.Circle>',
		'<Interactive.Ellipse>',
		'<Interactive.G>',
		'<Interactive.Line>',
		'<Interactive.Path>',
		'<Interactive.Rect>',
		'<Interactive.Svg>',
	]) {
		expect(getByName(displayName)?.controls?.schema).not.toHaveProperty([
			'style.fontSize',
		]);
		expect(getByName(displayName)?.controls?.schema).not.toHaveProperty(
			'children',
		);
		expect(getByName(displayName)?.controls?.schema).toHaveProperty('stroke');
		expect(getByName(displayName)?.controls?.schema).toHaveProperty(
			'strokeWidth',
		);
	}

	for (const displayName of [
		'<Interactive.Circle>',
		'<Interactive.Ellipse>',
		'<Interactive.G>',
		'<Interactive.Line>',
		'<Interactive.Path>',
		'<Interactive.Rect>',
		'<Interactive.Svg>',
		'<Interactive.Text>',
	]) {
		expect(getByName(displayName)?.controls?.schema).toHaveProperty('color');
	}

	for (const displayName of [
		'<Interactive.Circle>',
		'<Interactive.Ellipse>',
		'<Interactive.G>',
		'<Interactive.Path>',
		'<Interactive.Rect>',
		'<Interactive.Svg>',
		'<Interactive.Text>',
	]) {
		expect(getByName(displayName)?.controls?.schema).toHaveProperty('fill');
	}

	expect(getByName('<Interactive.Line>')?.controls?.schema).not.toHaveProperty(
		'fill',
	);
});

test('AbsoluteFill is an interactive sequence while preserving its div contract', () => {
	const registeredSequences: TSequence[] = [];
	const divRef = React.createRef<HTMLDivElement>();
	let clickCount = 0;

	const {container} = render(
		<SequenceTestWrapper
			currentFrame={4}
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<AbsoluteFill
				ref={divRef}
				id="interactive-fill"
				from={4}
				durationInFrames={12}
				style={{backgroundColor: 'red'}}
				onClick={() => {
					clickCount++;
				}}
			>
				Hello
			</AbsoluteFill>
		</SequenceTestWrapper>,
	);

	const element = container.querySelector<HTMLDivElement>('#interactive-fill');
	if (!element) {
		throw new Error('Expected AbsoluteFill to render its div');
	}

	fireEvent.click(element);

	expect(container.querySelectorAll('#interactive-fill')).toHaveLength(1);
	expect(divRef.current).toBe(element);
	expect(clickCount).toBe(1);
	expect(registeredSequences).toHaveLength(1);
	expect(registeredSequences[0]).toMatchObject({
		displayName: '<AbsoluteFill>',
		documentationLink: 'https://www.remotion.dev/docs/absolute-fill',
		from: 4,
		duration: 12,
		showInTimeline: true,
	});
	expect(
		Internals.SequenceOutlineInternals.getNodes(
			registeredSequences[0].refForOutline!,
		),
	).toEqual([]);
	expect(registeredSequences[0]?.controls?.componentIdentity).toBe(
		'dev.remotion.remotion.AbsoluteFill',
	);
	expect(registeredSequences[0]?.controls?.schema).toHaveProperty([
		'style.backgroundColor',
	]);
	expect(registeredSequences[0]?.controls?.schema).toHaveProperty('children');
});

test('Loading indicator does not register an interactive sequence', () => {
	const registeredSequences: TSequence[] = [];

	const {container, getByText} = render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Loading />
		</SequenceTestWrapper>,
	);

	expect(getByText('Resolving <Suspense>...')).toBeTruthy();
	expect(getByText('Resolving <Suspense>...').style.color).toBe(
		'rgba(255, 255, 255, 0.8)',
	);
	const loadingIndicator = container.querySelector<HTMLDivElement>(
		'#remotion-comp-loading',
	);
	expect(loadingIndicator).toBeTruthy();
	expect(loadingIndicator?.style.backgroundColor).toBe('#1f2428');
	expect(loadingIndicator?.style.animation).toBe('');
	const loadingContent = container.querySelector<HTMLDivElement>(
		'#remotion-comp-loading-content',
	);
	expect(loadingContent?.style.animation).toBe('anim 2s');
	expect(registeredSequences).toHaveLength(0);
});

test('Loading indicator compensates for the canvas scale', () => {
	const {container} = render(
		<SequenceTestWrapper onRegisterSequence={() => undefined}>
			<Internals.CurrentScaleContext.Provider value={{type: 'scale', scale: 2}}>
				<Loading />
			</Internals.CurrentScaleContext.Provider>
		</SequenceTestWrapper>,
	);

	const loadingLabel = container.querySelector<HTMLParagraphElement>(
		'#remotion-comp-loading-content p',
	);
	const loadingIcon = container.querySelector<SVGElement>(
		'#remotion-comp-loading-content svg',
	);
	expect(loadingLabel?.style.fontSize).toBe('7px');
	expect(loadingIcon?.getAttribute('width')).toBe('20');
	expect(loadingIcon?.getAttribute('height')).toBe('20');
});

test('Interactive elements inherit trimBefore from Sequence', () => {
	const Frame = () => {
		const frame = useCurrentFrame();
		return <span>{'frame' + frame}</span>;
	};

	const registeredSequences: TSequence[] = [];
	const {queryByText} = render(
		<SequenceTestWrapper
			onRegisterSequence={(sequence) => {
				registeredSequences.push(sequence);
			}}
		>
			<Interactive.Div trimBefore={7}>
				<Frame />
			</Interactive.Div>
		</SequenceTestWrapper>,
	);

	expect(queryByText('frame7')).not.toBe(null);
	expect(registeredSequences[0]?.displayName).toBe('<Interactive.Div>');
});

test('Imperative sequence refs update without rerendering ref-only consumers', async () => {
	const nodePath = {
		absolutePath: 'test.tsx',
		nodePath: ['root'],
		sequenceKeys: [],
		effectKeys: [],
		videoConfigValues: null,
	};
	let renders = 0;
	let sequencesRef: React.ContextType<typeof SequenceManagerRefContext> | null =
		null;
	let propStatusesRef: React.ContextType<
		typeof VisualModePropStatusesRefContext
	> | null = null;

	const RefOnlyConsumer = React.memo(() => {
		renders++;
		sequencesRef = React.useContext(SequenceManagerRefContext);
		propStatusesRef = React.useContext(VisualModePropStatusesRefContext);
		return null;
	});

	const Mutator = () => {
		const {registerSequence} = React.useContext(SequenceManagerActionsContext);
		const {setPropStatuses} = React.useContext(VisualModeSettersContext);

		React.useEffect(() => {
			registerSequence({id: 'imperative-sequence'} as TSequence);
			setPropStatuses(nodePath, () => ({
				durationDependentKeyframes: null,
				canUpdate: true,
				props: {},
				effects: [],
			}));
		}, [registerSequence, setPropStatuses]);

		return null;
	};

	render(
		<SequenceManagerProvider>
			<RefOnlyConsumer />
			<Mutator />
		</SequenceManagerProvider>,
	);

	await waitFor(() => {
		expect(sequencesRef?.current).toHaveLength(1);
		expect(Object.keys(propStatusesRef?.current ?? {})).toHaveLength(1);
	});
	expect(renders).toBe(1);
});