Skip to content

πŸŽ₯ Make videos programmatically with React

Publish composition and timeline registries from committed snapshots

Jonny Burgerdab5da299ac7
diff --git a/packages/core/src/Composition.tsx b/packages/core/src/Composition.tsx
index 37c3d6b7ce..1c3d3002d7 100644
--- a/packages/core/src/Composition.tsx
+++ b/packages/core/src/Composition.tsx
@@ -1,5 +1,11 @@
import type {ComponentType} from 'react';
-import React, {Suspense, useCallback, useContext, useEffect} from 'react';
+import React, {
+ Suspense,
+ useCallback,
+ useContext,
+ useEffect,
+ useMemo,
+} from 'react';
import {createPortal} from 'react-dom';
import type {z} from 'zod';
import type {AnyZodObject} from './any-zod-type.js';
@@ -10,8 +16,11 @@ import {
import type {Codec} from './codec.js';
import {CompositionRenderErrorContext} from './composition-render-error-context.js';
import {CompositionErrorBoundary} from './CompositionErrorBoundary.js';
-import type {TComposition} from './CompositionManager.js';
-import {CompositionSetters} from './CompositionManagerContext.js';
+import type {AnyComposition, TComposition} from './CompositionManager.js';
+import {
+ CompositionCommitRegistrationContext,
+ CompositionSetters,
+} from './CompositionManagerContext.js';
import {resolveComponentIdentity} from './enable-sequence-stack-traces.js';
import {FolderContext} from './Folder.js';
import {serializeThenDeserializeInStudio} from './input-props-serialization.js';
@@ -146,6 +155,8 @@ const InnerComposition = <
const compManager = useContext(CompositionSetters);
const {registerComposition, unregisterComposition} = compManager;
+ const commitRegistrationEnabled =
+ useContext(CompositionCommitRegistrationContext) === compManager;
const video = useVideo();
@@ -188,7 +199,7 @@ const InnerComposition = <
? resolveComponentIdentity(compProps.component)
: null;
- useEffect(() => {
+ const getCompositionForRegistration = useCallback(() => {
// Ensure it's a URL safe id
if (!id) {
throw new Error('No id for composition passed.');
@@ -196,7 +207,7 @@ const InnerComposition = <
validateCompositionId(id);
validateDefaultAndInputProps(defaultProps, 'defaultProps', id);
- registerComposition<Schema, Props>({
+ return {
durationInFrames: durationInFrames ?? undefined,
fps: fps ?? undefined,
height: height ?? undefined,
@@ -213,11 +224,7 @@ const InnerComposition = <
schema: schema ?? null,
calculateMetadata: compProps.calculateMetadata ?? null,
stack,
- } as TComposition<Schema, Props>);
-
- return () => {
- unregisterComposition(id);
- };
+ } as TComposition<Schema, Props>;
}, [
durationInFrames,
fps,
@@ -232,6 +239,25 @@ const InnerComposition = <
schema,
compProps.calculateMetadata,
stack,
+ ]);
+ const registration = useMemo(
+ () =>
+ commitRegistrationEnabled
+ ? (getCompositionForRegistration() as unknown as AnyComposition)
+ : null,
+ [commitRegistrationEnabled, getCompositionForRegistration],
+ );
+ useEffect(() => {
+ if (commitRegistrationEnabled) {
+ return;
+ }
+
+ registerComposition<Schema, Props>(getCompositionForRegistration());
+ return () => unregisterComposition(id);
+ }, [
+ commitRegistrationEnabled,
+ getCompositionForRegistration,
+ id,
registerComposition,
unregisterComposition,
]);
@@ -250,6 +276,14 @@ const InnerComposition = <
const onClear = useCallback(() => {
clearError();
}, [clearError]);
+ const wrapRegistration = (content: React.ReactNode) =>
+ environment.isStudio ? (
+ <CompositionOrderMarker compositionId={id} registration={registration}>
+ {content}
+ </CompositionOrderMarker>
+ ) : (
+ content
+ );
if (
environment.isStudio &&
@@ -263,23 +297,25 @@ const InnerComposition = <
(resolved.type !== 'success' &&
resolved.type !== 'success-and-refreshing')
) {
- return null;
+ return wrapRegistration(null);
}
- return createPortal(
- <CanUseRemotionHooksProvider>
- <CompositionErrorBoundary onError={onError} onClear={onClear}>
- <Suspense fallback={<Loading />}>
- <Comp
- {
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- ...((resolved.result.props ?? {}) as any)
- }
- />
- </Suspense>
- </CompositionErrorBoundary>
- </CanUseRemotionHooksProvider>,
- portalNode(),
+ return wrapRegistration(
+ createPortal(
+ <CanUseRemotionHooksProvider>
+ <CompositionErrorBoundary onError={onError} onClear={onClear}>
+ <Suspense fallback={<Loading />}>
+ <Comp
+ {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ ...((resolved.result.props ?? {}) as any)
+ }
+ />
+ </Suspense>
+ </CompositionErrorBoundary>
+ </CanUseRemotionHooksProvider>,
+ portalNode(),
+ ),
);
}
@@ -295,25 +331,27 @@ const InnerComposition = <
(resolved.type !== 'success' &&
resolved.type !== 'success-and-refreshing')
) {
- return null;
+ return wrapRegistration(null);
}
- return createPortal(
- <CanUseRemotionHooksProvider>
- <Suspense fallback={<Fallback />}>
- <Comp
- {
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- ...((resolved.result.props ?? {}) as any)
- }
- />
- </Suspense>
- </CanUseRemotionHooksProvider>,
- portalNode(),
+ return wrapRegistration(
+ createPortal(
+ <CanUseRemotionHooksProvider>
+ <Suspense fallback={<Fallback />}>
+ <Comp
+ {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ ...((resolved.result.props ?? {}) as any)
+ }
+ />
+ </Suspense>
+ </CanUseRemotionHooksProvider>,
+ portalNode(),
+ ),
);
}
- return null;
+ return wrapRegistration(null);
};
/*
@@ -327,19 +365,11 @@ export const Composition = <
props: CompositionProps<Schema, Props>,
) => {
const {onlyRenderComposition} = useContext(CompositionSetters);
- const environment = useRemotionEnvironment();
if (onlyRenderComposition && onlyRenderComposition !== props.id) {
return null;
}
// @ts-expect-error
- const composition = <InnerComposition {...props} />;
- return environment.isStudio ? (
- <CompositionOrderMarker compositionId={props.id}>
- {composition}
- </CompositionOrderMarker>
- ) : (
- composition
- );
+ return <InnerComposition {...props} />;
};
diff --git a/packages/core/src/CompositionManagerContext.tsx b/packages/core/src/CompositionManagerContext.tsx
index ebce566abb..2e79aed46f 100644
--- a/packages/core/src/CompositionManagerContext.tsx
+++ b/packages/core/src/CompositionManagerContext.tsx
@@ -87,6 +87,11 @@ export const CompositionManager = createContext<CompositionManagerContext>({
canvasContent: null,
});
+// Bind commit registration to these setters so custom providers keep using
+// their own registration lifecycle, even inside a managed Studio tree.
+export const CompositionCommitRegistrationContext =
+ createContext<CompositionManagerSetters | null>(null);
+
export const CompositionSetters = createContext<CompositionManagerSetters>({
registerComposition: () => undefined,
unregisterComposition: () => undefined,
diff --git a/packages/core/src/CompositionManagerProvider.tsx b/packages/core/src/CompositionManagerProvider.tsx
index 33ebc69951..4755233325 100644
--- a/packages/core/src/CompositionManagerProvider.tsx
+++ b/packages/core/src/CompositionManagerProvider.tsx
@@ -18,18 +18,27 @@ import type {
} from './CompositionManagerContext';
import {
CompositionManager,
+ CompositionCommitRegistrationContext,
CompositionSetters,
} from './CompositionManagerContext';
import type {BaseMetadata} from './CompositionManagerContext.js';
import type {TFolder} from './Folder';
import {
+ createRegistryStore,
+ reconcileRegistryEntries,
+} from './registry-store.js';
+import {
+ COMMIT_REGISTRATION_ERROR_EVENT,
CompositionManagerOrderMarker,
getCompositionAndFolderOrderKey,
getFolderOrderId,
+ isCommitRegistrationObserverAvailable,
COMMIT_ORDER_EVENT,
type CommitOrderEventDetail,
+ type CommittedCompositionSnapshot,
} from './sequence-order-marker.js';
import {useRemotionEnvironment} from './use-remotion-environment.js';
+import {useSyncExternalStore} from './use-sync-external-store.js';
const useIsomorphicLayoutEffect =
typeof window === 'undefined' ? useEffect : useLayoutEffect;
@@ -49,6 +58,24 @@ export const CompositionManagerProvider = ({
}) => {
const {isStudio} = useRemotionEnvironment();
const [compositionManagerId] = useState(() => String(Math.random()));
+ const [commitRegistrationEnabled, setCommitRegistrationEnabled] = useState(
+ () => isStudio && isCommitRegistrationObserverAvailable(),
+ );
+ const pendingRegistrationsRef = useRef<CommittedCompositionSnapshot | null>(
+ null,
+ );
+ const lastRegistrationsRef = useRef<CommittedCompositionSnapshot | null>(
+ null,
+ );
+ const committedKeysRef = useRef<ReadonlySet<string>>(new Set());
+ const committedDescriptorsRef = useRef<
+ ReadonlyMap<string, AnyComposition | TFolder>
+ >(new Map());
+ const observerFailedRef = useRef(false);
+ const unmountedRef = useRef(false);
+ const [registrationError, setRegistrationError] = useState<Error | null>(
+ null,
+ );
const committedOrderRef = useRef<ReadonlyMap<string, number> | null>(null);
const committedOrderIdsRef = useRef<readonly string[] | null>(null);
const internalOrderRef = useRef(
@@ -63,27 +90,49 @@ export const CompositionManagerProvider = ({
),
);
const nextInternalOrderRef = useRef(initialCompositions.length);
- const [folders, setFolders] = useState<TFolder[]>([]);
+ 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 [canvasContent, setCanvasContent] = useState<CanvasContent | null>(
initialCanvasContent,
);
const [currentAssetMetadata, setCurrentAssetMetadata] =
useState<AssetPreviewMetadata | null>(null);
- const [compositions, setCompositions] = useState<AnyComposition[]>(() =>
- initialCompositions.map((composition, order) => ({...composition, order})),
- );
-
- // CompositionManagerProvider state
- const currentcompositionsRef = useRef<AnyComposition[]>(compositions);
- useIsomorphicLayoutEffect(() => {
- currentcompositionsRef.current = compositions;
- }, [compositions]);
-
const updateCompositions = useCallback(
(updateComps: (comp: AnyComposition[]) => AnyComposition[]) => {
- setCompositions(updateComps);
+ registry.setSnapshot((previous) => {
+ const next = updateComps(previous.compositions);
+ return next === previous.compositions
+ ? previous
+ : {...previous, compositions: next};
+ });
},
- [],
+ [registry],
+ );
+ const setFolders = useCallback(
+ (update: (folders: TFolder[]) => TFolder[]) => {
+ registry.setSnapshot((previous) => {
+ const next = update(previous.folders);
+ return next === previous.folders
+ ? previous
+ : {...previous, folders: next};
+ });
+ },
+ [registry],
);
const registerComposition = useCallback(
@@ -115,14 +164,17 @@ export const CompositionManagerProvider = ({
[updateCompositions],
);
- const unregisterComposition = useCallback((id: string) => {
- internalOrderRef.current.delete(
- getCompositionAndFolderOrderKey({type: 'composition', id}),
- );
- setCompositions((comps) => {
- return comps.filter((c) => c.id !== id);
- });
- }, []);
+ const unregisterComposition = useCallback(
+ (id: string) => {
+ internalOrderRef.current.delete(
+ getCompositionAndFolderOrderKey({type: 'composition', id}),
+ );
+ updateCompositions((comps) => {
+ return comps.filter((c) => c.id !== id);
+ });
+ },
+ [updateCompositions],
+ );
const registerFolder = useCallback(
(name: string, parent: string | null, stack: string | null) => {
@@ -144,7 +196,7 @@ export const CompositionManagerProvider = ({
];
});
},
- [],
+ [setFolders],
);
const unregisterFolder = useCallback(
@@ -161,7 +213,105 @@ export const CompositionManagerProvider = ({
);
});
},
- [],
+ [setFolders],
+ );
+
+ const onCommitRegistrations = useCallback(
+ (snapshot: CommittedCompositionSnapshot) => {
+ if (observerFailedRef.current || unmountedRef.current) {
+ return;
+ }
+
+ const previous =
+ pendingRegistrationsRef.current ?? lastRegistrationsRef.current;
+ if (
+ previous?.compositions === snapshot.compositions &&
+ previous.folders === snapshot.folders &&
+ previous.orderIds === snapshot.orderIds
+ ) {
+ return;
+ }
+
+ const alreadyPending = pendingRegistrationsRef.current !== null;
+ pendingRegistrationsRef.current = snapshot;
+ if (alreadyPending) {
+ return;
+ }
+
+ queueMicrotask(() => {
+ const pending = pendingRegistrationsRef.current;
+ pendingRegistrationsRef.current = null;
+ if (
+ pending === null ||
+ observerFailedRef.current ||
+ unmountedRef.current
+ ) {
+ return;
+ }
+
+ const previousKeys = committedKeysRef.current;
+ const previousDescriptors = committedDescriptorsRef.current;
+ const existingIds = new Set(
+ registry
+ .getSnapshot()
+ .compositions.map((composition) => composition.id),
+ );
+ const descriptors = new Map<string, AnyComposition | TFolder>();
+ for (const composition of pending.compositions) {
+ const key = `composition:${composition.id}`;
+ if (
+ descriptors.has(key) ||
+ (!previousKeys.has(key) && existingIds.has(composition.id))
+ ) {
+ setRegistrationError(
+ new Error(
+ `Multiple composition with id ${composition.id} are registered.`,
+ ),
+ );
+ return;
+ }
+
+ descriptors.set(key, composition);
+ }
+
+ for (const folder of pending.folders) {
+ descriptors.set(`folder:${getFolderOrderId(folder)}`, folder);
+ }
+
+ const nextKeys = new Set(descriptors.keys());
+ const order = new Map(pending.orderIds.map((id, index) => [id, index]));
+ lastRegistrationsRef.current = pending;
+ committedKeysRef.current = nextKeys;
+ committedDescriptorsRef.current = descriptors;
+ registry.setSnapshot((current) => {
+ const nextCompositions = reconcileRegistryEntries({
+ current: current.compositions,
+ entries: pending.compositions,
+ previousDescriptors,
+ previousKeys,
+ nextKeys,
+ getKey: (composition) => `composition:${composition.id}`,
+ order,
+ orderProperty: 'order',
+ });
+ const nextFolders = reconcileRegistryEntries({
+ current: current.folders,
+ entries: pending.folders,
+ previousDescriptors,
+ previousKeys,
+ nextKeys,
+ getKey: (folder) => `folder:${getFolderOrderId(folder)}`,
+ order,
+ orderProperty: 'order',
+ });
+ return nextCompositions === current.compositions &&
+ nextFolders === current.folders
+ ? current
+ : {compositions: nextCompositions, folders: nextFolders};
+ });
+ });
+ },
+ [registry],
);
useIsomorphicLayoutEffect(() => {
@@ -170,6 +320,34 @@ export const CompositionManagerProvider = ({
}
let unmounted = false;
+ unmountedRef.current = false;
+ const onRegistrationError = () => {
+ if (observerFailedRef.current) {
+ return;
+ }
+
+ observerFailedRef.current = true;
+ pendingRegistrationsRef.current = null;
+ queueMicrotask(() => {
+ if (unmounted) {
+ return;
+ }
+
+ const previousKeys = committedKeysRef.current;
+ committedKeysRef.current = new Set();
+ committedDescriptorsRef.current = new Map();
+ registry.setSnapshot((current) => ({
+ compositions: current.compositions.filter(
+ (composition) => !previousKeys.has(`composition:${composition.id}`),
+ ),
+ folders: current.folders.filter(
+ (folder) => !previousKeys.has(`folder:${getFolderOrderId(folder)}`),
+ ),
+ }));
+ setCommitRegistrationEnabled(false);
+ });
+ };
+
const onCommitOrder = (event: Event) => {
const {detail} = event as CustomEvent<CommitOrderEventDetail>;
const managerOrder = detail.compositionManagers.find(
@@ -194,6 +372,10 @@ export const CompositionManagerProvider = ({
const order = new Map(orderIds.map((id, index) => [id, index]));
committedOrderIdsRef.current = orderIds;
committedOrderRef.current = order;
+ if (commitRegistrationEnabled) {
+ return;
+ }
+
queueMicrotask(() => {
if (unmounted) {
return;
@@ -255,17 +437,35 @@ export const CompositionManagerProvider = ({
};
window.addEventListener(COMMIT_ORDER_EVENT, onCommitOrder);
+ window.addEventListener(
+ COMMIT_REGISTRATION_ERROR_EVENT,
+ onRegistrationError,
+ );
+
return () => {
unmounted = true;
+ unmountedRef.current = true;
+ pendingRegistrationsRef.current = null;
window.removeEventListener(COMMIT_ORDER_EVENT, onCommitOrder);
+ window.removeEventListener(
+ COMMIT_REGISTRATION_ERROR_EVENT,
+ onRegistrationError,
+ );
};
- }, [compositionManagerId, isStudio, updateCompositions]);
+ }, [
+ compositionManagerId,
+ isStudio,
+ updateCompositions,
+ setFolders,
+ registry,
+ commitRegistrationEnabled,
+ ]);
useImperativeHandle(compositionsRef, () => {
return {
- getCompositions: () => currentcompositionsRef.current,
+ getCompositions: () => registry.getSnapshot().compositions,
};
- }, []);
+ }, [registry]);
const compositionManagerSetters = useMemo((): CompositionManagerSetters => {
return {
@@ -305,13 +505,26 @@ export const CompositionManagerProvider = ({
const providers = (
<CompositionManager.Provider value={compositionManagerContextValue}>
<CompositionSetters.Provider value={compositionManagerSetters}>
- {children}
+ <CompositionCommitRegistrationContext.Provider
+ value={commitRegistrationEnabled ? compositionManagerSetters : null}
+ >
+ {children}
+ </CompositionCommitRegistrationContext.Provider>
</CompositionSetters.Provider>
</CompositionManager.Provider>
);
+ if (registrationError !== null) {
+ throw registrationError;
+ }
+
return isStudio ? (
- <CompositionManagerOrderMarker managerId={compositionManagerId}>
+ <CompositionManagerOrderMarker
+ managerId={compositionManagerId}
+ onCommitRegistrations={
+ commitRegistrationEnabled ? onCommitRegistrations : null
+ }
+ >
{providers}
</CompositionManagerOrderMarker>
) : (
diff --git a/packages/core/src/Folder.tsx b/packages/core/src/Folder.tsx
index 577d45e7e7..2dc65e609f 100644
--- a/packages/core/src/Folder.tsx
+++ b/packages/core/src/Folder.tsx
@@ -1,6 +1,9 @@
import type {FC, ReactNode} from 'react';
import {createContext, useContext, useEffect, useMemo} from 'react';
-import {CompositionSetters} from './CompositionManagerContext.js';
+import {
+ CompositionCommitRegistrationContext,
+ CompositionSetters,
+} from './CompositionManagerContext.js';
import {FolderOrderMarker, getFolderOrderId} from './sequence-order-marker.js';
import {truthy} from './truthy.js';
import {useRemotionEnvironment} from './use-remotion-environment.js';
@@ -33,8 +36,11 @@ export const Folder: FC<{
}> = (props) => {
const {name, children} = props;
const parent = useContext(FolderContext);
- const {registerFolder, unregisterFolder} = useContext(CompositionSetters);
+ const compManager = useContext(CompositionSetters);
+ const {registerFolder, unregisterFolder} = compManager;
const environment = useRemotionEnvironment();
+ const commitRegistrationEnabled =
+ useContext(CompositionCommitRegistrationContext) === compManager;
const stack =
(props as {readonly _remotionInternalStack?: string})
._remotionInternalStack ?? null;
@@ -52,14 +58,26 @@ export const Folder: FC<{
parentName,
};
}, [name, parentName]);
+ const registration = useMemo<TFolder | null>(
+ () =>
+ commitRegistrationEnabled
+ ? {name, parent: parentName, order: null, stack}
+ : null,
+ [commitRegistrationEnabled, name, parentName, stack],
+ );
useEffect(() => {
+ if (commitRegistrationEnabled) {
+ return;
+ }
+
registerFolder(name, parentName, stack);
return () => {
unregisterFolder(name, parentName);
};
}, [
+ commitRegistrationEnabled,
name,
parent.folderName,
parentName,
@@ -72,7 +90,10 @@ export const Folder: FC<{
<FolderContext.Provider value={value}>{children}</FolderContext.Provider>
);
return environment.isStudio ? (
- <FolderOrderMarker folderId={getFolderOrderId({name, parent: parentName})}>
+ <FolderOrderMarker
+ folderId={getFolderOrderId({name, parent: parentName})}
+ registration={registration}
+ >
{folder}
</FolderOrderMarker>
) : (
diff --git a/packages/core/src/SequenceManager.tsx b/packages/core/src/SequenceManager.tsx
index 395c41cc12..16f568c23e 100644
--- a/packages/core/src/SequenceManager.tsx
+++ b/packages/core/src/SequenceManager.tsx
@@ -1,5 +1,11 @@
import React, {useCallback, useContext, useMemo, useRef, useState} from 'react';
import type {TSequence} from './CompositionManager.js';
+import {
+ areRegistryEntriesEqual,
+ createRegistryStore,
+ reconcileRegistryEntries,
+ type RegistryStore,
+} from './registry-store.js';
import {
COMMIT_ORDER_EVENT,
COMMIT_REGISTRATION_ERROR_EVENT,
@@ -25,24 +31,6 @@ import type {VideoConfigValues} from './video-config.js';
const useIsomorphicLayoutEffect =
typeof window === 'undefined' ? React.useEffect : React.useLayoutEffect;
-const areSequenceRegistrationsEqual = (
- previous: TSequence,
- next: TSequence,
-) => {
- const keys = Object.keys(previous);
- return (
- keys.length === Object.keys(next).length &&
- keys.every(
- (key) =>
- Object.prototype.hasOwnProperty.call(next, key) &&
- Object.is(
- previous[key as keyof TSequence],
- next[key as keyof TSequence],
- ),
- )
- );
-};
-
export type SequenceManagerContext = {
registerSequence: (seq: TSequence) => void;
updateSequence: ((seq: TSequence) => void) | null;
@@ -80,6 +68,11 @@ export const SequenceManagerActionsContext =
});
export const SequenceManager = React.createContext(defaultSequenceManager);
+export const SequenceRegistryContext = React.createContext<RegistryStore<
+ TSequence[]
+> | null>(null);
+const EmptySequenceManagerContext = React.createContext(defaultSequenceManager);
+const subscribeToNoRegistry = () => () => undefined;
export const SequenceCommitRegistrationContext = React.createContext(false);
const NativeSequenceManagerProvider = SequenceManager.Provider;
const SequenceManagerProviderWithActions: React.FC<
@@ -96,9 +89,11 @@ const SequenceManagerProviderWithActions: React.FC<
return (
<SequenceManagerActionsContext.Provider value={actions}>
<NativeSequenceManagerProvider value={value}>
- <SequenceCommitRegistrationContext.Provider value={false}>
- {children}
- </SequenceCommitRegistrationContext.Provider>
+ <SequenceRegistryContext.Provider value={null}>
+ <SequenceCommitRegistrationContext.Provider value={false}>
+ {children}
+ </SequenceCommitRegistrationContext.Provider>
+ </SequenceRegistryContext.Provider>
</NativeSequenceManagerProvider>
</SequenceManagerActionsContext.Provider>
);
@@ -111,7 +106,41 @@ Object.defineProperty(SequenceManager, 'Provider', {
});
export const useSequenceManagerSequences = (): TSequence[] => {
- return useContext(SequenceManager).sequences;
+ const registry = useContext(SequenceRegistryContext);
+ const legacy = useContext(
+ registry === null ? SequenceManager : EmptySequenceManagerContext,
+ );
+ const getSnapshot = useCallback(
+ () => registry?.getSnapshot() ?? legacy.sequences,
+ [legacy.sequences, registry],
+ );
+ return useSyncExternalStore(
+ registry?.subscribe ?? subscribeToNoRegistry,
+ getSnapshot,
+ getSnapshot,
+ );
+};
+
+// Keep the internal legacy context reactive without rendering the manager
+// or requiring imperative registry subscribers to wait for this React update.
+const SequenceRegistryProvider: React.FC<{
+ readonly registry: RegistryStore<TSequence[]>;
+ readonly actions: SequenceManagerActions;
+ readonly children: React.ReactNode;
+}> = ({registry, actions, children}) => {
+ const sequences = useSyncExternalStore(
+ registry.subscribe,
+ registry.getSnapshot,
+ registry.getSnapshot,
+ );
+ const value = useMemo(() => ({...actions, sequences}), [actions, sequences]);
+ return (
+ <SequenceManager.Provider value={value}>
+ <SequenceRegistryContext.Provider value={registry}>
+ {children}
+ </SequenceRegistryContext.Provider>
+ </SequenceManager.Provider>
+ );
};
export const SequenceManagerRefContext =
@@ -467,11 +496,16 @@ export const SequenceManagerProvider: React.FC<{
const registrationUnmountedRef = useRef(false);
const committedOrderRef = useRef<ReadonlyMap<string, number> | null>(null);
const committedOrderIdsRef = useRef<readonly string[] | null>(null);
- const [sequences, setSequences] = useState<TSequence[]>([]);
- const sequencesRef = useRef(sequences);
- useIsomorphicLayoutEffect(() => {
- sequencesRef.current = sequences;
- }, [sequences]);
+ const [registry] = useState(() => createRegistryStore<TSequence[]>([]));
+ const setSequences = registry.setSnapshot;
+ const sequencesRef = useMemo<SequenceManagerRef>(
+ () => ({
+ get current() {
+ return registry.getSnapshot();
+ },
+ }),
+ [registry],
+ );
const [dragOverrideState, setDragOverrideState] = useState(() => ({
overrides: {} as DragOverrides,
fromKeys: new Set<string>(),
@@ -854,45 +888,21 @@ export const SequenceManagerProvider: React.FC<{
);
lastCommittedSequencesRef.current = pending;
committedRegistrationIdsRef.current = nextIds;
- setSequences((current) => {
- const previousById = new Map(
- current.map((sequence) => [sequence.id, sequence]),
- );
- const next = pending.sequences.map((sequence) => {
- const previous = previousById.get(sequence.id);
- const timelineOrder = order.get(sequence.id) ?? null;
- if (
- previous &&
- previousDescriptors.get(sequence.id) === sequence &&
- previous.timelineOrder === timelineOrder
- ) {
- return previous;
- }
-
- const registeredSequence = {
- ...sequence,
- timelineOrder,
- };
- return previous &&
- areSequenceRegistrationsEqual(previous, registeredSequence)
- ? previous
- : registeredSequence;
- });
- // Custom imperative registrations have their own lifecycle.
- next.push(
- ...current.filter(
- (sequence) =>
- !previousIds.has(sequence.id) && !nextIds.has(sequence.id),
- ),
- );
- return next.length === current.length &&
- next.every((sequence, index) => sequence === current[index])
- ? current
- : next;
- });
+ setSequences((current) =>
+ reconcileRegistryEntries({
+ current,
+ entries: pending.sequences,
+ previousDescriptors,
+ previousKeys: previousIds,
+ nextKeys: nextIds,
+ getKey: (sequence) => sequence.id,
+ order,
+ orderProperty: 'timelineOrder',
+ }),
+ );
});
},
- [],
+ [setSequences],
);
useIsomorphicLayoutEffect(() => {
@@ -990,52 +1000,60 @@ export const SequenceManagerProvider: React.FC<{
onRegistrationError,
);
};
- }, [shouldObserveCommits, sequenceManagerId]);
+ }, [shouldObserveCommits, sequenceManagerId, setSequences]);
+
+ const registerSequence = useCallback(
+ (seq: TSequence) => {
+ setSequences((seqs) => {
+ return [
+ ...seqs,
+ {
+ ...seq,
+ timelineOrder: committedOrderRef.current?.get(seq.id) ?? null,
+ },
+ ];
+ });
+ },
+ [setSequences],
+ );
+ const updateSequence = useCallback(
+ (seq: TSequence) => {
+ setSequences((seqs) => {
+ const index = seqs.findIndex((item) => item.id === seq.id);
+ if (index === -1) {
+ return seqs;
+ }
- const registerSequence = useCallback((seq: TSequence) => {
- setSequences((seqs) => {
- return [
- ...seqs,
- {
+ const updatedSequence = {
...seq,
timelineOrder: committedOrderRef.current?.get(seq.id) ?? null,
- },
- ];
- });
- }, []);
- const updateSequence = useCallback((seq: TSequence) => {
- setSequences((seqs) => {
- const index = seqs.findIndex((item) => item.id === seq.id);
- if (index === -1) {
- return seqs;
- }
-
- const updatedSequence = {
- ...seq,
- timelineOrder: committedOrderRef.current?.get(seq.id) ?? null,
- };
- if (areSequenceRegistrationsEqual(seqs[index], updatedSequence)) {
- return seqs;
- }
+ };
+ if (areRegistryEntriesEqual(seqs[index], updatedSequence)) {
+ return seqs;
+ }
- const next = [...seqs];
- next[index] = updatedSequence;
- return next;
- });
- }, []);
+ const next = [...seqs];
+ next[index] = updatedSequence;
+ return next;
+ });
+ },
+ [setSequences],
+ );
- const unregisterSequence = useCallback((seq: string) => {
- setSequences((seqs) => seqs.filter((s) => s.id !== seq));
- }, []);
+ const unregisterSequence = useCallback(
+ (seq: string) => {
+ setSequences((seqs) => seqs.filter((s) => s.id !== seq));
+ },
+ [setSequences],
+ );
- const sequenceContext: SequenceManagerContext = useMemo(() => {
+ const actions = useMemo<SequenceManagerActions>(() => {
return {
registerSequence,
- sequences,
updateSequence,
unregisterSequence,
};
- }, [registerSequence, sequences, unregisterSequence, updateSequence]);
+ }, [registerSequence, unregisterSequence, updateSequence]);
const dragOverridesSubscription = useMemo<
Omit<DragOverridesSubscription, 'manager'>
>(
@@ -1108,7 +1126,7 @@ export const SequenceManagerProvider: React.FC<{
const providers = (
<SequenceManagerRefContext.Provider value={sequencesRef}>
- <SequenceManager.Provider value={sequenceContext}>
+ <SequenceRegistryProvider registry={registry} actions={actions}>
<SequenceCommitRegistrationContext.Provider
value={commitRegistrationEnabled}
>
@@ -1133,7 +1151,7 @@ export const SequenceManagerProvider: React.FC<{
</VisualModePropStatusesContext.Provider>
</VisualModePropStatusesRefContext.Provider>
</SequenceCommitRegistrationContext.Provider>
- </SequenceManager.Provider>
+ </SequenceRegistryProvider>
</SequenceManagerRefContext.Provider>
);
diff --git a/packages/core/src/internals.ts b/packages/core/src/internals.ts
index 54399be367..0fedeba92e 100644
--- a/packages/core/src/internals.ts
+++ b/packages/core/src/internals.ts
@@ -196,6 +196,7 @@ import {
SequenceManager,
SequenceManagerProvider,
SequenceManagerRefContext,
+ SequenceRegistryContext,
useActiveFromDragOverrideKeys,
useSequenceManagerSequences,
SequenceRegistrationContext,
@@ -365,6 +366,7 @@ export const Internals = {
SequenceManager,
SequenceManagerProvider,
SequenceManagerRefContext,
+ SequenceRegistryContext,
useActiveFromDragOverrideKeys,
useSequenceManagerSequences,
SequenceRegistrationContext,
diff --git a/packages/core/src/registry-store.ts b/packages/core/src/registry-store.ts
new file mode 100644
index 0000000000..b5b72eef72
--- /dev/null
+++ b/packages/core/src/registry-store.ts
@@ -0,0 +1,103 @@
+export type RegistryStore<TSnapshot> = {
+ readonly getSnapshot: () => TSnapshot;
+ readonly subscribe: (listener: () => void) => () => void;
+ readonly setSnapshot: (update: (previous: TSnapshot) => TSnapshot) => void;
+};
+
+export const areRegistryEntriesEqual = <T extends object>(
+ previous: T,
+ next: T,
+) => {
+ const keys = Object.keys(previous);
+ return (
+ keys.length === Object.keys(next).length &&
+ keys.every(
+ (key) =>
+ Object.prototype.hasOwnProperty.call(next, key) &&
+ Object.is(Reflect.get(previous, key), Reflect.get(next, key)),
+ )
+ );
+};
+
+export const reconcileRegistryEntries = <T extends object>({
+ current,
+ entries,
+ previousDescriptors,
+ previousKeys,
+ nextKeys,
+ getKey,
+ order,
+ orderProperty,
+}: {
+ readonly current: T[];
+ readonly entries: readonly T[];
+ readonly previousDescriptors: ReadonlyMap<string, unknown>;
+ readonly previousKeys: ReadonlySet<string>;
+ readonly nextKeys: ReadonlySet<string>;
+ readonly getKey: (entry: T) => string;
+ readonly order: ReadonlyMap<string, number>;
+ readonly orderProperty: keyof T;
+}): T[] => {
+ const previousByKey = new Map(current.map((entry) => [getKey(entry), entry]));
+ const next = entries.map((entry) => {
+ const key = getKey(entry);
+ const previous = previousByKey.get(key);
+ const nextOrder = order.get(key) ?? null;
+ if (
+ previous &&
+ previousDescriptors.get(key) === entry &&
+ previous[orderProperty] === nextOrder
+ ) {
+ return previous;
+ }
+
+ const registered = {...entry, [orderProperty]: nextOrder};
+ return previous && areRegistryEntriesEqual(previous, registered)
+ ? previous
+ : registered;
+ });
+ // Preserve imperative registrations, including their committed order.
+ for (const entry of current) {
+ const key = getKey(entry);
+ if (!previousKeys.has(key) && !nextKeys.has(key)) {
+ const nextOrder = order.get(key) ?? entry[orderProperty];
+ next.push(
+ entry[orderProperty] === nextOrder
+ ? entry
+ : {...entry, [orderProperty]: nextOrder},
+ );
+ }
+ }
+
+ return next.length === current.length &&
+ next.every((entry, index) => entry === current[index])
+ ? current
+ : next;
+};
+
+export const createRegistryStore = <TSnapshot>(
+ initialSnapshot: TSnapshot,
+): RegistryStore<TSnapshot> => {
+ let snapshot = initialSnapshot;
+ const listeners = new Set<() => void>();
+ return {
+ getSnapshot: () => snapshot,
+ subscribe: (listener) => {
+ listeners.add(listener);
+ return () => {
+ listeners.delete(listener);
+ };
+ },
+ setSnapshot: (update) => {
+ const next = update(snapshot);
+ if (next === snapshot) {
+ return;
+ }
+
+ snapshot = next;
+ for (const listener of [...listeners]) {
+ listener();
+ }
+ },
+ };
+};
diff --git a/packages/core/src/sequence-order-marker.tsx b/packages/core/src/sequence-order-marker.tsx
index 629a08a7cf..b603c799f9 100644
--- a/packages/core/src/sequence-order-marker.tsx
+++ b/packages/core/src/sequence-order-marker.tsx
@@ -1,5 +1,6 @@
import type React from 'react';
-import type {TSequence} from './CompositionManager.js';
+import type {AnyComposition, TSequence} from './CompositionManager.js';
+import type {TFolder} from './Folder.js';
export const SEQUENCE_ORDER_MARKER = Symbol.for(
'remotion.sequence-order-marker',
@@ -70,6 +71,12 @@ export type CommittedSequenceSnapshot = {
readonly sequenceIds: readonly string[];
};
+export type CommittedCompositionSnapshot = {
+ readonly compositions: readonly AnyComposition[];
+ readonly folders: readonly TFolder[];
+ readonly orderIds: readonly string[];
+};
+
export const SequenceOrderMarker: React.FC<{
readonly children: React.ReactNode;
readonly sequenceId: string;
@@ -103,6 +110,7 @@ Object.defineProperty(
export const CompositionOrderMarker: React.FC<{
readonly children: React.ReactNode;
readonly compositionId: string;
+ readonly registration: AnyComposition | null;
}> = ({children}) => children;
Object.defineProperty(CompositionOrderMarker, COMPOSITION_ORDER_MARKER, {
@@ -112,6 +120,7 @@ Object.defineProperty(CompositionOrderMarker, COMPOSITION_ORDER_MARKER, {
export const FolderOrderMarker: React.FC<{
readonly children: React.ReactNode;
readonly folderId: string;
+ readonly registration: TFolder | null;
}> = ({children}) => children;
Object.defineProperty(FolderOrderMarker, FOLDER_ORDER_MARKER, {
@@ -121,6 +130,9 @@ Object.defineProperty(FolderOrderMarker, FOLDER_ORDER_MARKER, {
export const CompositionManagerOrderMarker: React.FC<{
readonly children: React.ReactNode;
readonly managerId: string;
+ readonly onCommitRegistrations:
+ | ((snapshot: CommittedCompositionSnapshot) => void)
+ | null;
}> = ({children}) => children;
Object.defineProperty(
diff --git a/packages/core/src/use-lazy-component.ts b/packages/core/src/use-lazy-component.ts
index 1c732430a6..0eeaf68d91 100644
--- a/packages/core/src/use-lazy-component.ts
+++ b/packages/core/src/use-lazy-component.ts
@@ -3,8 +3,13 @@ import type {
ComponentType,
ExoticComponent,
} from 'react';
-import React, {useMemo, useRef} from 'react';
+import React, {useEffect, useLayoutEffect, useMemo} from 'react';
import type {CompProps} from './Composition.js';
+import {createRegistryStore} from './registry-store.js';
+import {useSyncExternalStore} from './use-sync-external-store.js';
+
+const useIsomorphicLayoutEffect =
+ typeof window === 'undefined' ? useEffect : useLayoutEffect;
type LazyExoticComponent<T extends ComponentType<any>> = ExoticComponent<
ComponentPropsWithRef<T>
@@ -22,7 +27,7 @@ export const useLazyComponent = <Props>({
componentName: string;
noSuspense: boolean;
}): LazyExoticComponent<ComponentType<Props>> | ComponentType<Props> => {
- // Why a ref + stable wrapper instead of returning compProps.component directly?
+ // Why a store + stable wrapper instead of returning compProps.component directly?
//
// When a user edits their component and saves, React Fast Refresh re-executes
// the module, giving compProps.component a new function reference.
@@ -31,20 +36,46 @@ export const useLazyComponent = <Props>({
// rendered `<Comp />` where Comp had a different identity, so React unmounted
// the old tree and mounted a fresh one β€” losing all component state.
//
- // To fix this, we store the latest component in a ref (updated every render)
- // and return a stable Wrapper from useMemo (created once). React sees the same
- // Wrapper component across Fast Refresh updates, preserves the tree and state,
- // while the ref ensures the Wrapper always delegates to the latest code.
+ // A stable Wrapper preserves the tree across Fast Refresh updates. Publish its
+ // implementation on commit so an abandoned render cannot change the component
+ // exposed by an already registered composition. The subscription updates mounted
+ // wrappers even when the registration's component identity stays the same.
//
// To reproduce: use packages/example/src/NewVideo.tsx, edit Component
// (e.g. change volume={1} to volume={2}) and save. Without this fix,
// Component would fully remount instead of fast-refreshing in place.
- const componentRef = useRef<ComponentType<Props> | null>(null);
-
- if ('component' in compProps) {
- componentRef.current = compProps.component as ComponentType<Props>;
+ const componentFromProps =
+ 'component' in compProps
+ ? (compProps.component as ComponentType<Props> | undefined)
+ : null;
+ if (
+ componentFromProps === undefined &&
+ typeof document !== 'undefined' &&
+ !noSuspense
+ ) {
+ throw new Error(
+ `A value of \`undefined\` was passed to the \`component\` prop. Check the value you are passing to the <${componentName}/> component.`,
+ );
}
+ const lazyComponentFromProps =
+ 'lazyComponent' in compProps ? compProps.lazyComponent : null;
+ const componentStore = useMemo(
+ () =>
+ createRegistryStore<ComponentType<Props> | null>(
+ componentFromProps ?? null,
+ ),
+ // A new lazy loader replaces the wrapper too. Component edits only update
+ // the existing store on commit, preserving the wrapper identity.
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ [lazyComponentFromProps],
+ );
+ useIsomorphicLayoutEffect(() => {
+ if (componentFromProps !== null && componentFromProps !== undefined) {
+ componentStore.setSnapshot(() => componentFromProps);
+ }
+ }, [componentFromProps, componentStore]);
+
const lazy = useMemo(() => {
if ('component' in compProps) {
// In SSR, suspense is not yet supported, we cannot use React.lazy
@@ -54,14 +85,12 @@ export const useLazyComponent = <Props>({
>;
}
- if (typeof compProps.component === 'undefined') {
- throw new Error(
- `A value of \`undefined\` was passed to the \`component\` prop. Check the value you are passing to the <${componentName}/> component.`,
- );
- }
-
const Wrapper = (props: Props) => {
- const Comp = componentRef.current!;
+ const Comp = useSyncExternalStore(
+ componentStore.subscribe,
+ componentStore.getSnapshot,
+ componentStore.getSnapshot,
+ )!;
return React.createElement(
Comp as React.ComponentType<{}>,
props as {},
@@ -93,10 +122,9 @@ export const useLazyComponent = <Props>({
// Very important to leave the dependencies as they are, or instead
// the player will remount on every frame.
// For the 'component' case, we intentionally do NOT depend on
- // compProps.component β€” the stable wrapper reads from componentRef instead.
+ // compProps.component β€” the stable wrapper subscribes to componentStore instead.
- // @ts-expect-error
// eslint-disable-next-line react-hooks/exhaustive-deps
- }, [compProps.lazyComponent]);
+ }, [lazyComponentFromProps, componentStore]);
return lazy;
};
diff --git a/packages/player/src/Player.tsx b/packages/player/src/Player.tsx
index e07b2b9a92..a1806e2eef 100644
--- a/packages/player/src/Player.tsx
+++ b/packages/player/src/Player.tsx
@@ -124,11 +124,20 @@ export const componentOrNullIfLazy = <Props,>(
const TimelineSequenceObserverComponent: React.FC<{
readonly onTimelineSequenceChange: TimelineSequenceObserver;
}> = ({onTimelineSequenceChange}) => {
- const sequences = Internals.useSequenceManagerSequences();
+ const registry = React.useContext(Internals.SequenceRegistryContext);
- useEffect(() => {
- onTimelineSequenceChange(sequences);
- }, [onTimelineSequenceChange, sequences]);
+ useLayoutEffect(() => {
+ if (registry === null) {
+ throw new Error(
+ 'Timeline sequence observer requires a sequence registry',
+ );
+ }
+
+ const publish = () => onTimelineSequenceChange(registry.getSnapshot());
+ const unsubscribe = registry.subscribe(publish);
+ publish();
+ return unsubscribe;
+ }, [onTimelineSequenceChange, registry]);
return null;
};
diff --git a/packages/sdk/src/install-fiber-sequence-order-observer.ts b/packages/sdk/src/install-fiber-sequence-order-observer.ts
index 18418f42d7..b70852198e 100644
--- a/packages/sdk/src/install-fiber-sequence-order-observer.ts
+++ b/packages/sdk/src/install-fiber-sequence-order-observer.ts
@@ -1,5 +1,5 @@
import type {RefObject} from 'react';
-import type {TSequence} from 'remotion';
+import type {AnyComposition, TSequence} from 'remotion';
import {Internals} from 'remotion';
type Fiber = {
@@ -45,6 +45,24 @@ type CommittedSequenceRegistration = {
readonly sequenceIds: readonly string[];
};
+type FolderRegistration = {
+ readonly name: string;
+ readonly parent: string | null;
+ readonly order: number | null;
+ readonly stack: string | null;
+};
+
+type CommittedCompositionSnapshot = {
+ readonly compositions: readonly AnyComposition[];
+ readonly folders: readonly FolderRegistration[];
+ readonly orderIds: readonly string[];
+};
+
+type CommittedCompositionRegistration = {
+ readonly onCommit: (snapshot: CommittedCompositionSnapshot) => void;
+ readonly snapshot: CommittedCompositionSnapshot;
+};
+
// Compare while traversing, and allocate only after the first changed entry.
const createCommitSnapshotCollector = <T>(previous: readonly T[] | null) => {
let count = 0;
@@ -99,7 +117,17 @@ export const collectCommitOrderFromFiber = (
string,
CommittedSequenceRegistration
> | null = null,
+ compositionRegistry: {
+ readonly registrations: Map<string, CommittedCompositionRegistration>;
+ readonly previous: ReadonlyMap<
+ string,
+ CommittedCompositionRegistration
+ > | null;
+ } | null = null,
) => {
+ const compositionRegistrations = compositionRegistry?.registrations ?? null;
+ const previousCompositionRegistrations =
+ compositionRegistry?.previous ?? null;
const outlineNodesByRef = new Map<
RefObject<Element | null>,
(Element | Text)[]
@@ -121,7 +149,22 @@ export const collectCommitOrderFromFiber = (
>();
const compositionsAndFoldersByManager = new Map<
string,
- CompositionAndFolderOrderItem[]
+ {
+ readonly order: CompositionAndFolderOrderItem[];
+ readonly registration: {
+ readonly onCommit: CommittedCompositionRegistration['onCommit'];
+ readonly previous: CommittedCompositionRegistration | null;
+ readonly compositions: ReturnType<
+ typeof createCommitSnapshotCollector<AnyComposition>
+ >;
+ readonly folders: ReturnType<
+ typeof createCommitSnapshotCollector<FolderRegistration>
+ >;
+ readonly orderIds: ReturnType<
+ typeof createCommitSnapshotCollector<string>
+ >;
+ } | null;
+ }
>();
const visit = (
@@ -189,7 +232,33 @@ export const collectCommitOrderFromFiber = (
compositionManagerId !== null &&
!compositionsAndFoldersByManager.has(compositionManagerId)
) {
- compositionsAndFoldersByManager.set(compositionManagerId, []);
+ const previous =
+ previousCompositionRegistrations?.get(compositionManagerId) ?? null;
+ const props = fiber.memoizedProps;
+ const onCommit =
+ typeof props === 'object' && props !== null
+ ? Reflect.get(props, 'onCommitRegistrations')
+ : null;
+ compositionsAndFoldersByManager.set(compositionManagerId, {
+ order: [],
+ registration:
+ compositionRegistrations !== null && typeof onCommit === 'function'
+ ? {
+ onCommit:
+ onCommit as CommittedCompositionRegistration['onCommit'],
+ previous,
+ compositions: createCommitSnapshotCollector(
+ previous?.snapshot.compositions ?? null,
+ ),
+ folders: createCommitSnapshotCollector(
+ previous?.snapshot.folders ?? null,
+ ),
+ orderIds: createCommitSnapshotCollector(
+ previous?.snapshot.orderIds ?? null,
+ ),
+ }
+ : null,
+ });
}
if (hasFiberMarker(fiber, Internals.CommitOrderInternals.sequenceMarker)) {
@@ -234,9 +303,21 @@ export const collectCommitOrderFromFiber = (
) {
const id = getStringProp(fiber.memoizedProps, 'compositionId');
if (id !== null) {
- compositionsAndFoldersByManager
- .get(compositionManagerId)
- ?.push({type: 'composition', id});
+ const manager =
+ compositionsAndFoldersByManager.get(compositionManagerId);
+ manager?.order.push({type: 'composition', id});
+ manager?.registration?.orderIds.push(`composition:${id}`);
+ const registration =
+ typeof fiber.memoizedProps === 'object' &&
+ fiber.memoizedProps !== null
+ ? (Reflect.get(
+ fiber.memoizedProps,
+ 'registration',
+ ) as AnyComposition | null)
+ : null;
+ if (registration) {
+ manager?.registration?.compositions.push(registration);
+ }
}
}
@@ -246,9 +327,21 @@ export const collectCommitOrderFromFiber = (
) {
const id = getStringProp(fiber.memoizedProps, 'folderId');
if (id !== null) {
- compositionsAndFoldersByManager
- .get(compositionManagerId)
- ?.push({type: 'folder', id});
+ const manager =
+ compositionsAndFoldersByManager.get(compositionManagerId);
+ manager?.order.push({type: 'folder', id});
+ manager?.registration?.orderIds.push(`folder:${id}`);
+ const registration =
+ typeof fiber.memoizedProps === 'object' &&
+ fiber.memoizedProps !== null
+ ? (Reflect.get(
+ fiber.memoizedProps,
+ 'registration',
+ ) as FolderRegistration | null)
+ : null;
+ if (registration) {
+ manager?.registration?.folders.push(registration);
+ }
}
}
@@ -306,15 +399,37 @@ export const collectCommitOrderFromFiber = (
},
);
+ const compositionManagers = [...compositionsAndFoldersByManager].map(
+ ([managerId, manager]) => {
+ const {registration} = manager;
+ if (registration !== null && compositionRegistrations !== null) {
+ const compositions = registration.compositions.getSnapshot();
+ const folders = registration.folders.getSnapshot();
+ const orderIds = registration.orderIds.getSnapshot();
+ const {previous} = registration;
+ compositionRegistrations.set(
+ managerId,
+ previous !== null &&
+ previous.onCommit === registration.onCommit &&
+ previous.snapshot.compositions === compositions &&
+ previous.snapshot.folders === folders &&
+ previous.snapshot.orderIds === orderIds
+ ? previous
+ : {
+ onCommit: registration.onCommit,
+ snapshot: {compositions, folders, orderIds},
+ },
+ );
+ }
+
+ return {managerId, compositionAndFolderOrder: manager.order};
+ },
+ );
+
return {
outlineCount: outlineNodesByRef.size,
sequenceManagers,
- compositionManagers: [...compositionsAndFoldersByManager].map(
- ([managerId, compositionAndFolderOrder]) => ({
- managerId,
- compositionAndFolderOrder,
- }),
- ),
+ compositionManagers,
};
};
@@ -335,18 +450,33 @@ export const installFiberCommitOrderObserver = (
FiberRoot,
Map<string, CommittedSequenceRegistration>
>();
+ const compositionRegistrationsByRoot = new WeakMap<
+ FiberRoot,
+ Map<string, CommittedCompositionRegistration>
+ >();
hook.onCommitFiberRoot = function (...args) {
try {
const [, root] = args;
const registrations = new Map<string, CommittedSequenceRegistration>();
const previousRegistrations = registrationsByRoot.get(root);
+ const compositionRegistrations = new Map<
+ string,
+ CommittedCompositionRegistration
+ >();
+ const previousCompositionRegistrations =
+ compositionRegistrationsByRoot.get(root);
const order = collectCommitOrderFromFiber(
root,
registrations,
previousRegistrations ?? null,
+ {
+ registrations: compositionRegistrations,
+ previous: previousCompositionRegistrations ?? null,
+ },
);
registrationsByRoot.set(root, registrations);
+ compositionRegistrationsByRoot.set(root, compositionRegistrations);
for (const [managerId, registration] of registrations) {
if (registration !== previousRegistrations?.get(managerId)) {
registration.onCommit(
@@ -364,6 +494,27 @@ export const installFiberCommitOrderObserver = (
}
}
+ for (const [managerId, registration] of compositionRegistrations) {
+ if (registration !== previousCompositionRegistrations?.get(managerId)) {
+ registration.onCommit(registration.snapshot);
+ }
+ }
+
+ if (previousCompositionRegistrations) {
+ for (const [
+ managerId,
+ registration,
+ ] of previousCompositionRegistrations) {
+ if (!compositionRegistrations.has(managerId)) {
+ registration.onCommit({
+ compositions: [],
+ folders: [],
+ orderIds: [],
+ });
+ }
+ }
+ }
+
if (
order.outlineCount > 0 ||
order.sequenceManagers.length > 0 ||