🎥 Make videos programmatically with React
fix(core): release replaced Sequence children from callback scopes
Alec Wattsaed3bf984b10
diff --git a/packages/browser-studio/e2e/sequence-retention-app.tsx b/packages/browser-studio/e2e/sequence-retention-app.tsxnew file mode 100644index 0000000000..908a62929b--- /dev/null+++ b/packages/browser-studio/e2e/sequence-retention-app.tsx@@ -0,0 +1,69 @@+import {Player} from '@remotion/player';+import React, {useLayoutEffect, useState} from 'react';+import {createRoot} from 'react-dom/client';+import {Sequence} from 'remotion';++declare global {+ interface Window {+ sequenceRetentionOptions: {+ layout: 'none' | 'absolute-fill';+ registration: boolean;+ };+ sequenceRetention: {+ refs: WeakRef<React.FC>[];+ replace: (revision: number) => void;+ flush: () => void;+ unmount: () => void;+ };+ }+}++const refs: WeakRef<React.FC>[] = [];+const makeChild = (revision: number): React.FC => {+ const buffer = new Uint8Array(1024 * 1024);+ buffer[0] = revision;+ const Child = () => <span id="revision">{buffer[0]}</span>;+ refs.push(new WeakRef(Child));+ return Child;+};++const Composition = () => {+ const [state, setState] = useState(() => ({Child: makeChild(0), nonce: 0}));+ useLayoutEffect(() => {+ window.sequenceRetention.replace = (revision) =>+ setState({Child: makeChild(revision), nonce: revision});+ window.sequenceRetention.flush = () =>+ setState((previous) => ({...previous, nonce: previous.nonce + 1}));+ }, []);+ return (+ <Sequence layout={window.sequenceRetentionOptions.layout}>+ <div>+ <state.Child />+ </div>+ </Sequence>+ );+};++const root = createRoot(document.getElementById('root')!);+window.sequenceRetention = {+ refs,+ replace: () => {+ throw new Error('Not mounted');+ },+ flush: () => {+ throw new Error('Not mounted');+ },+ unmount: () => root.unmount(),+};+root.render(+ <Player+ component={Composition}+ onTimelineSequenceChange={+ window.sequenceRetentionOptions.registration ? () => undefined : undefined+ }+ durationInFrames={100}+ fps={30}+ compositionWidth={100}+ compositionHeight={100}+ />,+);diff --git a/packages/browser-studio/e2e/sequence-retention.test.ts b/packages/browser-studio/e2e/sequence-retention.test.tsnew file mode 100644index 0000000000..418e7fe5fd--- /dev/null+++ b/packages/browser-studio/e2e/sequence-retention.test.ts@@ -0,0 +1,119 @@+import fs from 'node:fs/promises';+import os from 'node:os';+import path from 'node:path';+import {expect, test} from '@playwright/test';+import {rspack} from '@rspack/core';++// Use production React: development Fibers can retain debug owners independently+// of Sequence. Compile workspace sources so this tests the proposed core change.+for (const layout of ['none', 'absolute-fill'] as const) {+ for (const registration of [false, true]) {+ test(`Sequence releases replaced children (${layout}, registration=${registration})`, async ({+ page,+ }) => {+ const output = await fs.mkdtemp(+ path.join(os.tmpdir(), 'sequence-retention-'),+ );+ try {+ await new Promise<void>((resolve, reject) => {+ const compiler = rspack({+ context: import.meta.dirname,+ entry: './sequence-retention-app.tsx',+ mode: 'production',+ optimization: {minimize: false},+ output: {path: output, filename: 'app.js'},+ resolve: {+ extensions: ['.tsx', '.ts', '.js'],+ extensionAlias: {'.js': ['.ts', '.tsx', '.js']},+ alias: {+ 'remotion/no-react$': path.resolve(+ import.meta.dirname,+ '../../core/src/no-react.ts',+ ),+ remotion$: path.resolve(+ import.meta.dirname,+ '../../core/src/index.ts',+ ),+ '@remotion/player$': path.resolve(+ import.meta.dirname,+ '../../player/src/index.ts',+ ),+ },+ },+ module: {+ rules: [+ {+ test: /\.tsx?$/,+ use: [+ {+ loader: 'builtin:swc-loader',+ options: {+ jsc: {+ parser: {syntax: 'typescript', tsx: true},+ transform: {react: {runtime: 'automatic'}},+ },+ },+ },+ ],+ },+ ],+ },+ });+ compiler.run((error, stats) => {+ compiler.close(() => undefined);+ if (error || stats?.hasErrors())+ reject(error ?? new Error(stats?.toString()));+ else resolve();+ });+ });+ await page.setContent('<div id="root"></div>');+ await page.evaluate(+ (options) => {+ window.sequenceRetentionOptions = options;+ },+ {layout, registration},+ );+ await page.addScriptTag({+ content: await fs.readFile(path.join(output, 'app.js'), 'utf8'),+ });+ await expect(page.locator('#revision')).toHaveText('0');+ for (let revision = 1; revision <= 5; revision++) {+ await page.evaluate(+ (value) => window.sequenceRetention.replace(value),+ revision,+ );+ await expect(page.locator('#revision')).toHaveText(String(revision));+ }++ // Both the current and alternate React trees must have the final child.+ for (let i = 0; i < 2; i++) {+ await page.evaluate(() => window.sequenceRetention.flush());+ await page.evaluate(+ () =>+ new Promise((resolve) =>+ requestAnimationFrame(() => requestAnimationFrame(resolve)),+ ),+ );+ }++ const cdp = await page.context().newCDPSession(page);+ try {+ await cdp.send('HeapProfiler.collectGarbage');+ await cdp.send('HeapProfiler.collectGarbage');+ expect(+ await page.evaluate(() =>+ window.sequenceRetention.refs.flatMap((ref, index) =>+ ref.deref() ? [index] : [],+ ),+ ),+ ).toEqual([5]);+ } finally {+ await page.evaluate(() => window.sequenceRetention.unmount());+ await cdp.detach();+ }+ } finally {+ await fs.rm(output, {recursive: true, force: true});+ }+ });+ }+}diff --git a/packages/core/src/Sequence.tsx b/packages/core/src/Sequence.tsxindex bb4f5a0012..71e8a777ff 100644--- a/packages/core/src/Sequence.tsx+++ b/packages/core/src/Sequence.tsx@@ -173,6 +173,33 @@ export type SequenceProps = {readonly durationInFrames?: number;} & SequencePropsWithoutDuration;+// These callbacks can survive many renders. Keep their closure scopes separate+// from the render scope, which also captures children in memo factories.+const useSequenceValueGetter = <T,>(value: T) => {+ return useCallback(() => value, [value]);+};++const useSequenceRefGetter = <T,>(ref: React.RefObject<T>) => {+ return useCallback(() => ref.current, [ref]);+};++const useSequenceWrapperRef = (+ ref: React.ForwardedRef<HTMLDivElement>,+ wrapperRef: React.RefObject<HTMLDivElement | null>,+) => {+ return useCallback(+ (node: HTMLDivElement | null) => {+ wrapperRef.current = node;+ if (typeof ref === 'function') {+ ref(node);+ } else if (ref) {+ ref.current = node;+ }+ },+ [ref, wrapperRef],+ );+};+const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<HTMLDivElement,SequenceProps@@ -565,7 +592,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<const registrationStack = controls? (getStackForControls(controls) ?? stack ?? null): (stack ?? null);- const getStack = useCallback(() => registrationStack, [registrationStack]);+ const getStack = useSequenceValueGetter(registrationStack);const registeredFrozenFrame = typeof freeze === 'number' ? freeze : null;const currentFrame =registeredFrozenFrame ??@@ -574,7 +601,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<useLayoutEffect(() => {currentFrameRef.current = currentFrame;}, [currentFrame]);- const getCurrentFrame = useCallback(() => currentFrameRef.current, []);+ const getCurrentFrame = useSequenceRefGetter(currentFrameRef);const registeredTrimBefore = trimBefore === 0 ? null : trimBefore;const parentCumulatedNegativeFrom =parentSequence?.cumulatedNegativeFrom ?? 0;@@ -666,7 +693,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<controlsSupportsEffects,]);- const getSequenceForRegistration = useCallback((): TSequence => {+ const sequenceForRegistration = useMemo((): TSequence => {const trackRegistration = timelineTrack? {timelineTrack: {@@ -804,6 +831,9 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<frozenMediaFrame,singleChildComponent,]);+ const getSequenceForRegistration = useSequenceValueGetter(+ sequenceForRegistration,+ );const registration = useSequenceRegistration({getSequence:env.isStudio || sequenceRegistrationEnabled@@ -867,18 +897,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<style: styleIfThere,});- const sequenceRef = useCallback(- (node: HTMLDivElement | null) => {- wrapperRefForOutline.current = node;-- if (typeof ref === 'function') {- ref(node);- } else if (ref) {- ref.current = node;- }- },- [ref],- );+ const sequenceRef = useSequenceWrapperRef(ref, wrapperRefForOutline);const defaultStyle: React.CSSProperties = useMemo(() => {return {