🎥 Make videos programmatically with React
Merge remote-tracking branch 'origin/main' into codex/sequence-registration-on-commit
Jonny Burgerd7fad635d952
diff --cc packages/core/src/CompositionManagerProvider.tsxindex bc0c7b1a99,2d81a0df3f..6d8f6a2711--- a/packages/core/src/CompositionManagerProvider.tsx+++ b/packages/core/src/CompositionManagerProvider.tsx@@@ -42,30 -47,23 +42,31 @@@ export const CompositionManagerProvidereadonly initialCompositions: AnyComposition[];readonly initialCanvasContent: CanvasContent | null;}) => {- const {isStudio} = useRemotionEnvironment();- const [compositionManagerId] = useState(() => String(Math.random()));- const committedOrderRef = useRef<ReadonlyMap<string, number> | null>(null);- const committedOrderIdsRef = useRef<readonly string[] | null>(null);- const internalOrderRef = useRef(- new Map(- initialCompositions.map((composition, index) => [- getCompositionAndFolderOrderKey({- type: 'composition',- id: composition.id,- }),- index,- ]),- ),+ const committedKeysRef = useRef<ReadonlySet<string>>(new Set());++ const flushSnapshotRef = useRef<(() => void) | null>(null);+ const committedDescriptorsRef = useRef<+ ReadonlyMap<string, AnyComposition | TFolder>+ >(new Map());+ const [registrationError, setRegistrationError] = useState<Error | null>(+ null,+ );+ const [registry] = useState(() =>+ createRegistryStore<{+ compositions: AnyComposition[];+ folders: TFolder[];+ }>({+ compositions: initialCompositions.map((composition, order) => ({+ ...composition,+ order,+ })),+ folders: [],+ }),+ );+ const {compositions, folders} = useSyncExternalStore(+ registry.subscribe,+ registry.getSnapshot,+ registry.getSnapshot,);- const nextInternalOrderRef = useRef(initialCompositions.length);- const [folders, setFolders] = useState<TFolder[]>([]);const [canvasContent, setCanvasContent] = useState<CanvasContent | null>(initialCanvasContent,);@@@ -138,12 -264,16 +139,15 @@@useImperativeHandle(compositionsRef, () => {return {- getCompositions: () => registry.getSnapshot().compositions,- getCompositions: () => currentcompositionsRef.current,++ getCompositions: () => {++ flushSnapshotRef.current?.();++ return registry.getSnapshot().compositions;++ },};- }, []);+ }, [registry]);- const compositionManagerSetters = useMemo((): CompositionManagerSetters => {- return {- registerComposition,- unregisterComposition,- registerFolder,- unregisterFolder,+ const compositionManagerSetters = useMemo(+ (): CompositionManagerSetters => ({setCanvasContent,setCurrentAssetMetadata,onlyRenderComposition,@@@ -168,17 -303,19 +172,20 @@@canvasContent,]);- const providers = (- <CompositionManager.Provider value={compositionManagerContextValue}>- <CompositionSetters.Provider value={compositionManagerSetters}>- {children}- </CompositionSetters.Provider>- </CompositionManager.Provider>- );-- return isStudio ? (- <CompositionManagerOrderMarker managerId={compositionManagerId}>- {providers}- </CompositionManagerOrderMarker>- ) : (- providers+ if (registrationError !== null) {+ throw registrationError;+ }++ return (- <CompositionRegistryProvider onSnapshot={onCommitRegistrations}>++ <CompositionRegistryProvider++ ref={flushSnapshotRef}++ onSnapshot={onCommitRegistrations}++ >+ <CompositionManager.Provider value={compositionManagerContextValue}>+ <CompositionSetters.Provider value={compositionManagerSetters}>+ {children}+ </CompositionSetters.Provider>+ </CompositionManager.Provider>+ </CompositionRegistryProvider>);};diff --cc packages/core/src/CompositionRegistryProvider.tsxindex fb91563207,0000000000..94f04a8998mode 100644,000000..100644--- a/packages/core/src/CompositionRegistryProvider.tsx+++ b/packages/core/src/CompositionRegistryProvider.tsx@@@ -1,217 -1,0 +1,224 @@@+import {++ forwardRef,+ useCallback,+ useEffect,++ useImperativeHandle,+ useLayoutEffect,+ useMemo,+ useRef,+ useState,+} from 'react';+import {+ COMMIT_REGISTRATION_ERROR_EVENT,+ getCompositionAndFolderOrderKey,+ getFolderOrderId,+ isCommitRegistrationObserverInstalled,+ withCommittedMetadata,+ type CommittedMetadata,+ type CommittedCompositionSnapshot,+} from './committed-metadata.js';+import {+ CompositionRegistryFallbackContext,+ type CommittedCompositionEntry,+} from './composition-registry-fallback.js';+import type {AnyComposition} from './CompositionManager.js';+import type {TFolder} from './Folder.js';+import {useRemotionEnvironment} from './use-remotion-environment.js';++const useIsomorphicLayoutEffect =+ typeof window === 'undefined' ? useEffect : useLayoutEffect;+const CompositionRegistryFallbackProvider = withCommittedMetadata(+ CompositionRegistryFallbackContext.Provider,+);++// Every consumer receives a complete committed snapshot. The fallback changes+// how descriptors are captured, rather than exposing a second registration API.- export const CompositionRegistryProvider: React.FC<{- readonly children: React.ReactNode;- readonly onSnapshot: (snapshot: CommittedCompositionSnapshot) => void;- }> = ({children, onSnapshot}) => {++export const CompositionRegistryProvider = forwardRef<++ () => void,++ {++ readonly children: React.ReactNode;++ readonly onSnapshot: (snapshot: CommittedCompositionSnapshot) => void;++ }++>(({children, onSnapshot}, flushSnapshotRef) => {+ const {isStudio} = useRemotionEnvironment();+ const [managerId] = useState(() => String(Math.random()));+ const [useCommitObserver, setUseCommitObserver] = useState(+ () => isStudio && isCommitRegistrationObserverInstalled(),+ );+ const observedCommitRef = useRef(false);+ const observerFailedRef = useRef(false);+ const unmountedRef = useRef(false);+ const onSnapshotRef = useRef(onSnapshot);+ const lastSnapshotRef = useRef<CommittedCompositionSnapshot | null>(null);+ const pendingSnapshotRef = useRef<+ CommittedCompositionSnapshot | (() => CommittedCompositionSnapshot) | null+ >(null);++ const flushSnapshot = useCallback(() => {++ const pending = pendingSnapshotRef.current;++ pendingSnapshotRef.current = null;++ if (pending === null || unmountedRef.current) {++ return;++ }++++ const committed = typeof pending === 'function' ? pending() : pending;++ const previous = lastSnapshotRef.current;++ if (++ previous !== null &&++ (previous.compositions === committed.compositions ||++ (previous.compositions.length === committed.compositions.length &&++ previous.compositions.every(++ (composition, index) =>++ composition === committed.compositions[index],++ ))) &&++ (previous.folders === committed.folders ||++ (previous.folders.length === committed.folders.length &&++ previous.folders.every(++ (folder, index) => folder === committed.folders[index],++ ))) &&++ (previous.orderIds === committed.orderIds ||++ (previous.orderIds.length === committed.orderIds.length &&++ previous.orderIds.every(++ (id, index) => id === committed.orderIds[index],++ )))++ ) {++ return;++ }++++ lastSnapshotRef.current = committed;++ onSnapshotRef.current(committed);++ }, []);++ useImperativeHandle(flushSnapshotRef, () => flushSnapshot, [flushSnapshot]);+ const queueSnapshot = useCallback(+ (+ snapshot:+ | CommittedCompositionSnapshot+ | (() => CommittedCompositionSnapshot),+ ) => {+ const alreadyPending = pendingSnapshotRef.current !== null;+ pendingSnapshotRef.current = snapshot;+ if (alreadyPending) {+ return;+ }+- queueMicrotask(() => {- const pending = pendingSnapshotRef.current;- pendingSnapshotRef.current = null;- if (pending === null || unmountedRef.current) {- return;- }-- const committed = typeof pending === 'function' ? pending() : pending;- const previous = lastSnapshotRef.current;- if (- previous !== null &&- (previous.compositions === committed.compositions ||- (previous.compositions.length === committed.compositions.length &&- previous.compositions.every(- (composition, index) =>- composition === committed.compositions[index],- ))) &&- (previous.folders === committed.folders ||- (previous.folders.length === committed.folders.length &&- previous.folders.every(- (folder, index) => folder === committed.folders[index],- ))) &&- (previous.orderIds === committed.orderIds ||- (previous.orderIds.length === committed.orderIds.length &&- previous.orderIds.every(- (id, index) => id === committed.orderIds[index],- )))- ) {- return;- }-- lastSnapshotRef.current = committed;- onSnapshotRef.current(committed);- });++ queueMicrotask(flushSnapshot);+ },- [],++ [flushSnapshot],+ );+ const onObservedSnapshot = useCallback(+ (snapshot: CommittedCompositionSnapshot) => {+ if (observerFailedRef.current) {+ return;+ }++ observedCommitRef.current = true;+ queueSnapshot(snapshot);+ },+ [queueSnapshot],+ );+ const fallbackRegistry = useMemo(() => {+ const entries = new Map<object, CommittedCompositionEntry>();+ const getSnapshot = (): CommittedCompositionSnapshot => {+ const compositions: AnyComposition[] = [];+ const folders: TFolder[] = [];+ const orderIds: string[] = [];+ for (const entry of entries.values()) {+ if (entry.type === 'composition') {+ compositions.push(entry.value);+ orderIds.push(+ getCompositionAndFolderOrderKey({+ type: 'composition',+ id: entry.value.id,+ }),+ );+ } else {+ folders.push(entry.value);+ orderIds.push(+ getCompositionAndFolderOrderKey({+ type: 'folder',+ id: getFolderOrderId(entry.value),+ }),+ );+ }+ }++ return {compositions, folders, orderIds};+ };++ return {entries, notifyCommit: () => queueSnapshot(getSnapshot)};+ }, [queueSnapshot]);+ useIsomorphicLayoutEffect(() => {+ if (onSnapshotRef.current !== onSnapshot) {+ const previous = lastSnapshotRef.current;+ lastSnapshotRef.current = null;+ if (useCommitObserver && previous !== null) {+ queueSnapshot(previous);+ }+ }++ onSnapshotRef.current = onSnapshot;+ if (!useCommitObserver) {+ fallbackRegistry.notifyCommit();+ }+ }, [fallbackRegistry, onSnapshot, queueSnapshot, useCommitObserver]);+ useIsomorphicLayoutEffect(() => {+ unmountedRef.current = false;+ let unmounted = false;+ const onRegistrationError = () => {+ if (observerFailedRef.current) {+ return;+ }++ observerFailedRef.current = true;+ pendingSnapshotRef.current = null;+ queueMicrotask(() => {+ if (!unmountedRef.current) {+ setUseCommitObserver(false);+ }+ });+ };++ if (isStudio) {+ window.addEventListener(+ COMMIT_REGISTRATION_ERROR_EVENT,+ onRegistrationError,+ );+ if (useCommitObserver) {+ queueMicrotask(() => {+ if (!unmounted && !observedCommitRef.current) {+ onRegistrationError();+ }+ });+ }+ }++ return () => {+ unmounted = true;+ unmountedRef.current = true;+ if (isStudio) {+ window.removeEventListener(+ COMMIT_REGISTRATION_ERROR_EVENT,+ onRegistrationError,+ );+ }+ };+ }, [isStudio, useCommitObserver]);+ const metadata = useMemo<CommittedMetadata | null>(+ () =>+ isStudio+ ? {+ type: 'composition-manager',+ id: managerId,+ onCommit: useCommitObserver ? onObservedSnapshot : null,+ }+ : null,+ [isStudio, managerId, onObservedSnapshot, useCommitObserver],+ );+ return (+ <CompositionRegistryFallbackProvider+ value={useCommitObserver ? null : fallbackRegistry}+ _remotionCommitMetadata={metadata}+ >+ {children}+ </CompositionRegistryFallbackProvider>+ );- };++});diff --cc packages/core/src/test/composition-manager-order.test.tsxindex 5630c5cdfa,4d39709767..2a012eaa2d--- a/packages/core/src/test/composition-manager-order.test.tsx+++ b/packages/core/src/test/composition-manager-order.test.tsx@@@ -1,12 -1,8 +1,12 @@@-import {afterEach, expect, spyOn, test} from 'bun:test';+import {afterEach, expect, test} from 'bun:test';import {act, cleanup, render, waitFor} from '@testing-library/react';-import React, {useContext, useEffect} from 'react';+import React, {useContext} from 'react';+import {+ CommittedMetadataInternals,+ type CommittedCompositionSnapshot,+} from '../committed-metadata.js';import {Composition} from '../Composition.js';- import type {AnyComposition} from '../CompositionManager.js';-import {compositionsRef} from '../CompositionManager.js';++import {compositionsRef, type AnyComposition} from '../CompositionManager.js';import type {CompositionManagerContext} from '../CompositionManagerContext.js';import {CompositionManager} from '../CompositionManagerContext.js';import {CompositionManagerProvider} from '../CompositionManagerProvider.js';@@@ -70,61 -72,26 +70,70 @@@ test('applies committed composition an</RemotionEnvironmentContext.Provider>,);- await waitFor(() => {- expect(context?.compositions).toHaveLength(2);- expect(context?.folders).toHaveLength(1);- });+ // ReactDOM has already initialized without this test's DevTools hook.+ // Deliver the committed descriptors at the observer's manager boundary.+ type Fiber = {+ readonly memoizedProps: unknown;+ readonly child: Fiber | null;+ readonly sibling: Fiber | null;+ };+ const key = Object.keys(container).find((name) =>+ name.startsWith('__reactContainer$'),+ );+ if (key === undefined) {+ throw new Error('React did not attach its root to the container.');+ }- const detail: CommitOrderEventDetail = {- sequenceManagers: [],- compositionManagers: [- {- managerId: '0.5',- compositionAndFolderOrder: [- {type: 'folder', id: 'group'},- {type: 'composition', id: 'inside'},- {type: 'composition', id: 'outside'},- ],- },- ],+ const fiber = Reflect.get(container, key) as {+ readonly stateNode: {readonly current: Fiber};};- act(() => {- window.dispatchEvent(new CustomEvent(COMMIT_ORDER_EVENT, {detail}));+ const pending = [fiber.stateNode.current];+ const compositions: AnyComposition[] = [];+ const folders: TFolder[] = [];+ let onCommit: ((snapshot: CommittedCompositionSnapshot) => void) | null =+ null;+ while (pending.length > 0) {+ const node = pending.pop()!;+ const metadata = CommittedMetadataInternals.getMetadata(+ node.memoizedProps,+ );+ if (metadata?.type === 'composition-manager') {+ onCommit = metadata.onCommit;+ } else if (metadata?.type === 'composition') {+ compositions.push(metadata.value);+ } else if (metadata?.type === 'folder') {+ folders.push(metadata.value);+ }++ if (node.sibling !== null) {+ pending.push(node.sibling);+ }++ if (node.child !== null) {+ pending.push(node.child);+ }+ }++ if (onCommit === null) {+ throw new Error('No committed composition registry boundary found.');+ }++ const publish = onCommit;+ await act(() => {+ publish({+ compositions,+ folders,+ orderIds: ['folder:group', 'composition:inside', 'composition:outside'],+ });++ // Renderer reads must see the snapshot before React flushes the update.++ expect(++ compositionsRef.current++ ?.getCompositions()++ .map((composition) => [composition.id, composition.order]),++ ).toEqual([++ ['inside', 1],++ ['outside', 2],++ ]);});await waitFor(() => {