Skip to content

🎥 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.tsx
index bc0c7b1a99,2d81a0df3f..6d8f6a2711
--- a/packages/core/src/CompositionManagerProvider.tsx
+++ b/packages/core/src/CompositionManagerProvider.tsx
@@@ -42,30 -47,23 +42,31 @@@ export const CompositionManagerProvide
readonly 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.tsx
index fb91563207,0000000000..94f04a8998
mode 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.tsx
index 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(() => {