Skip to content

🎥 Make videos programmatically with React

Remove internal registry compatibility adapters

Jonny Burger26901d3b1bb8
diff --git a/packages/core/src/SequenceManager.tsx b/packages/core/src/SequenceManager.tsx
index ba9d639681..ad9f7cb938 100644
--- a/packages/core/src/SequenceManager.tsx
+++ b/packages/core/src/SequenceManager.tsx
@@ -32,11 +32,10 @@ import type {VideoConfigValues} from './video-config.js';
const useIsomorphicLayoutEffect =
typeof window === 'undefined' ? React.useEffect : React.useLayoutEffect;
-export type SequenceManagerContext = {
+type SequenceManagerActions = {
registerSequence: (seq: TSequence) => void;
- updateSequence: ((seq: TSequence) => void) | null;
+ updateSequence: (seq: TSequence) => void;
unregisterSequence: (id: string) => void;
- sequences: TSequence[];
};
export type SequenceManagerRef = {
@@ -45,38 +44,28 @@ export type SequenceManagerRef = {
export type SequenceNodePath = Array<string | number>;
-const defaultSequenceManager: SequenceManagerContext = {
+const defaultSequenceManagerActions: SequenceManagerActions = {
registerSequence: () => {
- throw new Error('SequenceManagerContext not initialized');
+ throw new Error('SequenceManagerActionsContext not initialized');
+ },
+ updateSequence: () => {
+ throw new Error('SequenceManagerActionsContext not initialized');
},
- updateSequence: null,
unregisterSequence: () => {
- throw new Error('SequenceManagerContext not initialized');
+ throw new Error('SequenceManagerActionsContext not initialized');
},
- sequences: [],
};
-type SequenceManagerActions = Pick<
- SequenceManagerContext,
- 'registerSequence' | 'updateSequence' | 'unregisterSequence'
->;
-
-export const SequenceManagerActionsContext =
- React.createContext<SequenceManagerActions>({
- registerSequence: defaultSequenceManager.registerSequence,
- updateSequence: defaultSequenceManager.updateSequence,
- unregisterSequence: defaultSequenceManager.unregisterSequence,
- });
+export const SequenceManagerActionsContext = React.createContext(
+ defaultSequenceManagerActions,
+);
-export const SequenceManager = React.createContext(defaultSequenceManager);
export const SequenceRegistryContext = React.createContext<RegistryStore<
TSequence[]
> | null>(null);
-const SequenceManagerInitialSequencesContext = React.createContext<TSequence[]>(
- [],
-);
const subscribeToNoRegistry = () => () => undefined;
-const getEmptySequences = () => defaultSequenceManager.sequences;
+const emptySequences: TSequence[] = [];
+const getEmptySequences = () => emptySequences;
export const SequenceCommitRegistrationContext = React.createContext(false);
export const SequenceRegistryScopeContext = React.createContext<{
readonly commitRegistrationRequested: boolean;
@@ -86,7 +75,6 @@ export const SequenceRegistryScopeContext = React.createContext<{
sequenceIds: readonly string[],
) => void;
} | null>(null);
-const NativeSequenceManagerProvider = SequenceManager.Provider;
export const useSequenceManagerSequences = (): TSequence[] => {
const registry = useContext(SequenceRegistryContext);
return useSyncExternalStore(
@@ -307,7 +295,6 @@ export const VisualModeDragOverridesContext =
},
});
-/* eslint-disable react-hooks/rules-of-hooks */
export const useDragOverridesForNodePath = (
nodePath: SequencePropsSubscriptionKey | null,
): Record<string, DragOverrideValue> => {
@@ -315,12 +302,6 @@ export const useDragOverridesForNodePath = (
const manager = useContext(SequenceManagerActionsContext);
const scopedSubscription =
subscription?.manager === manager ? subscription : null;
- // Legacy providers only supply VisualModeDragOverridesContext. Its presence is
- // fixed for the lifetime of a mounted tree.
- const legacy =
- scopedSubscription === null
- ? useContext(VisualModeDragOverridesContext)
- : null;
const key =
nodePath === null ? null : makeSequencePropsSubscriptionKey(nodePath);
const subscribe = useCallback(
@@ -332,10 +313,7 @@ export const useDragOverridesForNodePath = (
() => scopedSubscription?.getSnapshot(key) ?? emptyDragOverrides,
[key, scopedSubscription],
);
- const overrides = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
- return legacy !== null && nodePath !== null
- ? legacy.getDragOverrides(nodePath)
- : overrides;
+ return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
};
export const useActiveFromDragOverrideKeys = (): ReadonlySet<string> => {
@@ -346,18 +324,11 @@ export const useActiveFromDragOverrideKeys = (): ReadonlySet<string> => {
export const useEffectDragOverridesForNodePath = (
nodePath: SequencePropsSubscriptionKey | null,
- effectCount: number,
): Record<string, Record<string, DragOverrideValue>> => {
const subscription = useContext(VisualModeDragOverridesSubscriptionContext);
const manager = useContext(SequenceManagerActionsContext);
const scopedSubscription =
subscription?.manager === manager ? subscription : null;
- // Legacy providers only supply VisualModeDragOverridesContext. Its presence is
- // fixed for the lifetime of a mounted tree.
- const legacy =
- scopedSubscription === null
- ? useContext(VisualModeDragOverridesContext)
- : null;
const key =
nodePath === null ? null : makeSequencePropsSubscriptionKey(nodePath);
const subscribe = useCallback(
@@ -370,22 +341,8 @@ export const useEffectDragOverridesForNodePath = (
scopedSubscription?.getEffectSnapshot(key) ?? emptyEffectDragOverrides,
[key, scopedSubscription],
);
- const overrides = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
- if (legacy !== null && nodePath !== null) {
- const legacyOverrides: Record<
- string,
- Record<string, DragOverrideValue>
- > = {};
- for (let index = 0; index < effectCount; index++) {
- legacyOverrides[index] = legacy.getEffectDragOverrides(nodePath, index);
- }
-
- return legacyOverrides;
- }
-
- return overrides;
+ return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
};
-/* eslint-enable react-hooks/rules-of-hooks */
export const VisualModeSettersContext = React.createContext<VisualModeSetters>({
setDragOverrides: () => {
@@ -456,8 +413,7 @@ 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 initialSequences = useContext(SequenceManagerInitialSequencesContext);
- const [registry] = useState(() => createRegistryStore(initialSequences));
+ const [registry] = useState(() => createRegistryStore<TSequence[]>([]));
const setSequences = registry.setSnapshot;
const sequencesRef = useMemo<SequenceManagerRef>(
() => ({
@@ -1076,16 +1032,6 @@ export const SequenceManagerProvider: React.FC<{
unregisterSequence,
};
}, [registerSequence, unregisterSequence, updateSequence]);
- // Keep imperative internal reads available without subscribing a provider.
- const sequenceManagerContext = useMemo<SequenceManagerContext>(
- () => ({
- ...actions,
- get sequences() {
- return registry.getSnapshot();
- },
- }),
- [actions, registry],
- );
const dragOverridesSubscription = useMemo<
Omit<DragOverridesSubscription, 'manager'>
>(
@@ -1178,92 +1124,39 @@ export const SequenceManagerProvider: React.FC<{
_remotionCommitMetadata={metadata}
>
<SequenceRegistryScopeContext.Provider value={registryScope}>
- <NativeSequenceManagerProvider value={sequenceManagerContext}>
- <SequenceManagerActionsContext.Provider value={actions}>
- <SequenceRegistryContext.Provider value={registry}>
- <SequenceCommitRegistrationContext.Provider
- value={commitRegistrationEnabled}
+ <SequenceManagerActionsContext.Provider value={actions}>
+ <SequenceRegistryContext.Provider value={registry}>
+ <SequenceCommitRegistrationContext.Provider
+ value={commitRegistrationEnabled}
+ >
+ <VisualModePropStatusesRefContext.Provider
+ value={propStatusesRef}
>
- <VisualModePropStatusesRefContext.Provider
- value={propStatusesRef}
+ <VisualModePropStatusesContext.Provider
+ value={propStatusesContext}
>
- <VisualModePropStatusesContext.Provider
- value={propStatusesContext}
+ <SequenceManagerScopeProviders
+ dragOverridesSubscription={dragOverridesSubscription}
+ fromKeys={dragOverrideState.fromKeys}
>
- <SequenceManagerScopeProviders
- dragOverridesSubscription={dragOverridesSubscription}
- fromKeys={dragOverrideState.fromKeys}
+ <VisualModeDragOverridesContext.Provider
+ value={dragOverridesContext}
>
- <VisualModeDragOverridesContext.Provider
- value={dragOverridesContext}
- >
- <VisualModeSettersContext.Provider
- value={settersContext}
+ <VisualModeSettersContext.Provider value={settersContext}>
+ <VisualModeBatchSettersContext.Provider
+ value={batchSettersContext}
>
- <VisualModeBatchSettersContext.Provider
- value={batchSettersContext}
- >
- {children}
- </VisualModeBatchSettersContext.Provider>
- </VisualModeSettersContext.Provider>
- </VisualModeDragOverridesContext.Provider>
- </SequenceManagerScopeProviders>
- </VisualModePropStatusesContext.Provider>
- </VisualModePropStatusesRefContext.Provider>
- </SequenceCommitRegistrationContext.Provider>
- </SequenceRegistryContext.Provider>
- </SequenceManagerActionsContext.Provider>
- </NativeSequenceManagerProvider>
+ {children}
+ </VisualModeBatchSettersContext.Provider>
+ </VisualModeSettersContext.Provider>
+ </VisualModeDragOverridesContext.Provider>
+ </SequenceManagerScopeProviders>
+ </VisualModePropStatusesContext.Provider>
+ </VisualModePropStatusesRefContext.Provider>
+ </SequenceCommitRegistrationContext.Provider>
+ </SequenceRegistryContext.Provider>
+ </SequenceManagerActionsContext.Provider>
</SequenceRegistryScopeContext.Provider>
</SequenceManagerRefProvider>
);
};
-
-const SequenceManagerProviderWithActions: React.FC<
- React.ProviderProps<SequenceManagerContext>
-> = ({value, children}) => {
- const [useCommittedManager] = useState(isCommitRegistrationObserverInstalled);
- const [registry] = useState(() => createRegistryStore(value.sequences));
- useIsomorphicLayoutEffect(() => {
- if (!useCommittedManager) {
- registry.setSnapshot(() => value.sequences);
- }
- }, [registry, useCommittedManager, value.sequences]);
- const actions = useMemo<SequenceManagerActions>(
- () => ({
- registerSequence: value.registerSequence,
- updateSequence: value.updateSequence,
- unregisterSequence: value.unregisterSequence,
- }),
- [value.registerSequence, value.updateSequence, value.unregisterSequence],
- );
- if (useCommittedManager) {
- return (
- <SequenceManagerInitialSequencesContext.Provider value={value.sequences}>
- <SequenceRegistrationContext.Provider value>
- <SequenceManagerProvider>{children}</SequenceManagerProvider>
- </SequenceRegistrationContext.Provider>
- </SequenceManagerInitialSequencesContext.Provider>
- );
- }
-
- return (
- <SequenceManagerActionsContext.Provider value={actions}>
- <NativeSequenceManagerProvider value={value}>
- <SequenceRegistryContext.Provider value={registry}>
- <SequenceRegistryScopeContext.Provider value={null}>
- <SequenceCommitRegistrationContext.Provider value={false}>
- {children}
- </SequenceCommitRegistrationContext.Provider>
- </SequenceRegistryScopeContext.Provider>
- </SequenceRegistryContext.Provider>
- </NativeSequenceManagerProvider>
- </SequenceManagerActionsContext.Provider>
- );
-};
-
-// Internal providers use a committed manager when observation is available.
-// Keep the supplied effect lifecycle only when observation is unavailable.
-Object.defineProperty(SequenceManager, 'Provider', {
- value: SequenceManagerProviderWithActions,
-});
diff --git a/packages/core/src/committed-metadata.ts b/packages/core/src/committed-metadata.ts
index 14fd890753..67a2a1e677 100644
--- a/packages/core/src/committed-metadata.ts
+++ b/packages/core/src/committed-metadata.ts
@@ -46,10 +46,6 @@ export type CommitOrderEventDetail = {
readonly managerId: string;
readonly sequenceIds: readonly string[];
}[];
- readonly compositionManagers: readonly {
- readonly managerId: string;
- readonly compositionAndFolderOrder: readonly CompositionAndFolderOrderItem[];
- }[];
};
export const getFolderOrderId = ({
diff --git a/packages/core/src/effects/use-memoized-effects.ts b/packages/core/src/effects/use-memoized-effects.ts
index eb3c4eb071..d74fb41291 100644
--- a/packages/core/src/effects/use-memoized-effects.ts
+++ b/packages/core/src/effects/use-memoized-effects.ts
@@ -245,10 +245,7 @@ export const useMemoizedEffects = ({
const nodePath = overrideId
? (overrideIdToNodePathMappings[overrideId] ?? null)
: null;
- const effectDragOverrides = useEffectDragOverridesForNodePath(
- nodePath,
- effects.length,
- );
+ const effectDragOverrides = useEffectDragOverridesForNodePath(nodePath);
const resolved = effects.map((descriptor, index) => {
if (nodePath === null) {
diff --git a/packages/core/src/internals.ts b/packages/core/src/internals.ts
index c82c433ce2..534469f2d6 100644
--- a/packages/core/src/internals.ts
+++ b/packages/core/src/internals.ts
@@ -200,7 +200,6 @@ import type {CannotUpdateSequenceReason} from './SequenceManager.js';
import {
DisableSequenceRegistrationProvider,
makeSequencePropsSubscriptionKey,
- SequenceManager,
SequenceManagerProvider,
SequenceManagerRefContext,
SequenceRegistrationContext,
@@ -378,7 +377,6 @@ export const Internals = {
VisualModeBatchSettersContext,
VisualModeDragOverridesContext,
VisualModeSettersContext,
- SequenceManager,
SequenceManagerProvider,
SequenceManagerRefContext,
SequenceRegistryContext,
diff --git a/packages/core/src/test/canvas-image.test.tsx b/packages/core/src/test/canvas-image.test.tsx
index 2ee04006b6..b03b605311 100644
--- a/packages/core/src/test/canvas-image.test.tsx
+++ b/packages/core/src/test/canvas-image.test.tsx
@@ -12,9 +12,11 @@ import type {
import {Internals} from '../internals.js';
import type {SequenceContextType} from '../SequenceContext.js';
import {SequenceContext} from '../SequenceContext.js';
-import type {SequenceManagerContext} from '../SequenceManager.js';
-import {SequenceManager} from '../SequenceManager.js';
-import {WrapSequenceContext} from './wrap-sequence-context.js';
+import {SequenceManagerProvider} from '../SequenceManager.js';
+import {
+ ObserveSequenceRegistrations,
+ WrapSequenceContext,
+} from './wrap-sequence-context.js';
type DrawImageCall = {
readonly canvas: HTMLCanvasElement;
@@ -172,29 +174,15 @@ const SequenceRegistrationWrapper: React.FC<{
readonly children: React.ReactNode;
readonly onRegisterSequence: (sequence: TSequence) => void;
}> = ({children, onRegisterSequence}) => {
- const registerSequence = React.useCallback(
- (sequence: TSequence) => {
- onRegisterSequence(sequence);
- },
- [onRegisterSequence],
- );
- const unregisterSequence = React.useCallback(() => undefined, []);
- const sequenceManagerContext: SequenceManagerContext = React.useMemo(
- () => ({
- registerSequence,
- unregisterSequence,
- updateSequence: registerSequence,
- sequences: [],
- }),
- [registerSequence, unregisterSequence],
- );
-
return (
<WrapSequenceContext>
<Internals.RemotionEnvironmentContext value={studioEnv}>
- <SequenceManager.Provider value={sequenceManagerContext}>
+ <SequenceManagerProvider>
+ <ObserveSequenceRegistrations
+ onRegisterSequence={onRegisterSequence}
+ />
{children}
- </SequenceManager.Provider>
+ </SequenceManagerProvider>
</Internals.RemotionEnvironmentContext>
</WrapSequenceContext>
);
diff --git a/packages/core/src/test/html-in-canvas.test.tsx b/packages/core/src/test/html-in-canvas.test.tsx
index 4e1b127799..3bc5a7be41 100644
--- a/packages/core/src/test/html-in-canvas.test.tsx
+++ b/packages/core/src/test/html-in-canvas.test.tsx
@@ -1,19 +1,20 @@
import {afterEach, expect, test} from 'bun:test';
import {cleanup, render, waitFor} from '@testing-library/react';
-import React, {useCallback, useMemo} from 'react';
+import React, {useMemo} from 'react';
import type {TSequence} from '../CompositionManager.js';
import type {DelayRenderScope} from '../delay-render.js';
import type {HtmlInCanvasOnPaintParams} from '../HtmlInCanvas.js';
import {HtmlInCanvas, htmlInCanvasSchema} from '../HtmlInCanvas.js';
import {Internals} from '../internals.js';
-import type {SequenceManagerContext} from '../SequenceManager.js';
import {
- SequenceManager,
- VisualModeDragOverridesContext,
+ SequenceManagerProvider,
VisualModePropStatusesContext,
VisualModeSettersContext,
} from '../SequenceManager.js';
-import {WrapSequenceContext} from './wrap-sequence-context.js';
+import {
+ ObserveSequenceRegistrations,
+ WrapSequenceContext,
+} from './wrap-sequence-context.js';
const stub2dContext = () => {
return {
@@ -146,24 +147,6 @@ const SequenceTestWrapper: React.FC<{
compositionDurationInFrames,
currentFrame,
}) => {
- const registerSequence = useCallback(
- (sequence: TSequence) => {
- onRegisterSequence(sequence);
- },
- [onRegisterSequence],
- );
-
- const unregisterSequence = useCallback(() => undefined, []);
-
- const sequenceManagerContext: SequenceManagerContext = useMemo(() => {
- return {
- registerSequence,
- sequences: [],
- updateSequence: registerSequence,
- unregisterSequence,
- };
- }, [registerSequence, unregisterSequence]);
-
const visualPropStatuses = useMemo(
() => ({
propStatuses: {},
@@ -171,18 +154,6 @@ const SequenceTestWrapper: React.FC<{
[],
);
- const visualDragOverrides = useMemo(
- () => ({
- getDragOverrides: () => {
- throw new Error('VisualModeDragOverridesContext not initialized');
- },
- getEffectDragOverrides: () => {
- throw new Error('VisualModeDragOverridesContext not initialized');
- },
- }),
- [],
- );
-
const visualSetters = useMemo(
() => ({
clearDragOverrides: () => undefined,
@@ -209,17 +180,16 @@ const SequenceTestWrapper: React.FC<{
isStudio: true,
}}
>
- <SequenceManager.Provider value={sequenceManagerContext}>
+ <SequenceManagerProvider>
+ <ObserveSequenceRegistrations
+ onRegisterSequence={onRegisterSequence}
+ />
<VisualModePropStatusesContext.Provider value={visualPropStatuses}>
- <VisualModeDragOverridesContext.Provider
- value={visualDragOverrides}
- >
- <VisualModeSettersContext.Provider value={visualSetters}>
- {children}
- </VisualModeSettersContext.Provider>
- </VisualModeDragOverridesContext.Provider>
+ <VisualModeSettersContext.Provider value={visualSetters}>
+ {children}
+ </VisualModeSettersContext.Provider>
</VisualModePropStatusesContext.Provider>
- </SequenceManager.Provider>
+ </SequenceManagerProvider>
</Internals.RemotionEnvironmentContext>
</WrapSequenceContext>
);
diff --git a/packages/core/src/test/sequence-register-once.test.tsx b/packages/core/src/test/sequence-register-once.test.tsx
index dcfb739448..a13ab2de2a 100644
--- a/packages/core/src/test/sequence-register-once.test.tsx
+++ b/packages/core/src/test/sequence-register-once.test.tsx
@@ -22,15 +22,13 @@ 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 {
- SequenceManagerContext,
- SequencePropsSubscriptionKey,
-} from '../SequenceManager.js';
+import type {SequencePropsSubscriptionKey} from '../SequenceManager.js';
import {
- SequenceManager,
+ SequenceManagerActionsContext,
SequenceManagerProvider,
SequenceManagerRefContext,
- VisualModeDragOverridesContext,
+ useSequenceManagerSequences,
+ VisualModeBatchSettersContext,
VisualModePropStatusesContext,
VisualModePropStatusesRefContext,
VisualModeSettersContext,
@@ -39,7 +37,10 @@ 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 {WrapSequenceContext} from './wrap-sequence-context.js';
+import {
+ ObserveSequenceRegistrations,
+ WrapSequenceContext,
+} from './wrap-sequence-context.js';
afterEach(cleanup);
@@ -58,6 +59,50 @@ type VisualModeOverrides = {
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',
@@ -105,18 +150,6 @@ const SequenceTestWrapperWithVisualModeOverrides: React.FC<
[onRegisterSequence, rerenderOnRegister],
);
- const unregisterSequence = useCallback(() => undefined, []);
-
- const ctx: SequenceManagerContext = useMemo(
- () => ({
- registerSequence,
- unregisterSequence,
- updateSequence: registerSequence,
- sequences: [],
- }),
- [registerSequence, unregisterSequence],
- );
-
const visualPropStatuses = useMemo(
() => ({
propStatuses: visualModeOverrides?.propStatuses ?? {},
@@ -124,17 +157,6 @@ const SequenceTestWrapperWithVisualModeOverrides: React.FC<
[visualModeOverrides],
);
- const visualDragOverrides = useMemo(
- () => ({
- getDragOverrides: (nodePath: SequencePropsSubscriptionKey) =>
- visualModeOverrides?.dragOverrides[
- Internals.makeSequencePropsSubscriptionKey(nodePath)
- ] ?? {},
- getEffectDragOverrides: () => ({}),
- }),
- [visualModeOverrides],
- );
-
const overrideIdToNodePathContext = useMemo(
() => ({
overrideIdToNodePathMappings:
@@ -172,17 +194,17 @@ const SequenceTestWrapperWithVisualModeOverrides: React.FC<
<OverrideIdsToNodePathsGettersContext.Provider
value={overrideIdToNodePathContext}
>
- <SequenceManager.Provider value={ctx}>
+ <SequenceManagerProvider>
+ <ApplyVisualModeOverrides overrides={visualModeOverrides} />
+ <ObserveSequenceRegistrations
+ onRegisterSequence={registerSequence}
+ />
<VisualModePropStatusesContext.Provider value={visualPropStatuses}>
- <VisualModeDragOverridesContext.Provider
- value={visualDragOverrides}
- >
- <VisualModeSettersContext.Provider value={visualSetters}>
- {children}
- </VisualModeSettersContext.Provider>
- </VisualModeDragOverridesContext.Provider>
+ <VisualModeSettersContext.Provider value={visualSetters}>
+ {children}
+ </VisualModeSettersContext.Provider>
</VisualModePropStatusesContext.Provider>
- </SequenceManager.Provider>
+ </SequenceManagerProvider>
</OverrideIdsToNodePathsGettersContext.Provider>
</Internals.RemotionEnvironmentContext>
</WrapSequenceContext>
@@ -654,7 +676,7 @@ test('read-only Studio registers visual controls without applying overrides', ()
</SequenceTestWrapperWithVisualModeOverrides>,
);
- const sequence = registeredSequences.find(
+ const sequence = registeredSequences.findLast(
(item) => item.displayName === '<Interactive.Div>',
);
expect(sequence?.controls).not.toBe(null);
@@ -1653,7 +1675,7 @@ test('Imperative sequence refs update without rerendering ref-only consumers', a
});
const Mutator = () => {
- const {registerSequence} = React.useContext(SequenceManager);
+ const {registerSequence} = React.useContext(SequenceManagerActionsContext);
const {setPropStatuses} = React.useContext(VisualModeSettersContext);
React.useEffect(() => {
diff --git a/packages/core/src/test/use-media-in-timeline.test.tsx b/packages/core/src/test/use-media-in-timeline.test.tsx
index b61e348509..86f8ddab51 100644
--- a/packages/core/src/test/use-media-in-timeline.test.tsx
+++ b/packages/core/src/test/use-media-in-timeline.test.tsx
@@ -8,14 +8,14 @@ import {
test,
} from 'bun:test';
import {cleanup, renderHook} from '@testing-library/react';
-import React, {useMemo} from 'react';
+import React from 'react';
+import type {TSequence} from '../CompositionManager.js';
import {
SequenceOutlineContext,
SequenceOutlineInternals,
} from '../sequence-outline.js';
-import type {SequenceManagerContext} from '../SequenceManager.js';
-import {SequenceManager} from '../SequenceManager.js';
-import {useMediaInTimeline} from '../use-media-in-timeline.js';
+import {SequenceRegistryContext} from '../SequenceManager.js';
+import {useMediaInTimelineRegistration} from '../use-media-in-timeline.js';
import * as useVideoConfigModule from '../use-video-config.js';
import {WrapSequenceContext} from './wrap-sequence-context.js';
@@ -47,34 +47,26 @@ afterAll(() => {
});
test('useMediaInTimeline registers muted changes and unregisters the sequence', () => {
- const registerSequence = mock();
- const updateSequence = mock();
- const unregisterSequence = mock();
- const wrapper: React.FC<{
- children: React.ReactNode;
- }> = ({children}) => {
- // eslint-disable-next-line react-hooks/rules-of-hooks
- const sequenceManagerContext: SequenceManagerContext = useMemo(() => {
- return {
- registerSequence,
- unregisterSequence,
- updateSequence,
- sequences: [],
- };
- }, []);
+ let getSequences = (): TSequence[] => {
+ throw new Error('Sequence registry has not mounted');
+ };
- return (
- <WrapSequenceContext>
- <SequenceManager.Provider value={sequenceManagerContext}>
- {children}
- </SequenceManager.Provider>
- </WrapSequenceContext>
- );
+ const CaptureRegistry = () => {
+ const registry = React.useContext(SequenceRegistryContext);
+ if (registry === null) throw new Error('Sequence registry has not mounted');
+ getSequences = registry.getSnapshot;
+ return null;
};
+ const wrapper: React.FC<{children: React.ReactNode}> = ({children}) => (
+ <WrapSequenceContext>
+ <CaptureRegistry />
+ {children}
+ </WrapSequenceContext>
+ );
const {rerender, unmount} = renderHook(
({muted}: {readonly muted: boolean}) =>
- useMediaInTimeline({
+ useMediaInTimelineRegistration({
volume: 1,
src: 'test',
mediaVolume: 1,
@@ -91,56 +83,45 @@ test('useMediaInTimeline registers muted changes and unregisters the sequence',
documentationLink: null,
muted,
}),
- {
- wrapper,
- initialProps: {muted: false},
- },
+ {wrapper, initialProps: {muted: false}},
);
- expect(registerSequence).toHaveBeenCalled();
- expect(registerSequence.mock.calls[0]?.[0]).toMatchObject({
+ expect(getSequences()).toHaveLength(1);
+ expect(getSequences()[0]).toMatchObject({
mediaFrameAtSequenceZero: 0,
muted: false,
refForOutline: null,
});
-
+ const id = getSequences()[0]?.id;
rerender({muted: true});
- expect(registerSequence).toHaveBeenCalledTimes(1);
- expect(updateSequence.mock.calls.at(-1)?.[0]).toMatchObject({muted: true});
-
+ expect(getSequences()).toHaveLength(1);
+ expect(getSequences()[0]).toMatchObject({id, muted: true});
unmount();
- expect(unregisterSequence).toHaveBeenCalled();
+ expect(getSequences()).toEqual([]);
});
test('useMediaInTimeline keeps documentation links for custom display names', () => {
- const registerSequence = mock();
- const unregisterSequence = mock();
- const wrapper: React.FC<{
- children: React.ReactNode;
- }> = ({children}) => {
- // eslint-disable-next-line react-hooks/rules-of-hooks
- const sequenceManagerContext: SequenceManagerContext = useMemo(() => {
- return {
- registerSequence,
- unregisterSequence,
- updateSequence: null,
- sequences: [],
- };
- }, []);
+ let getSequences = (): TSequence[] => {
+ throw new Error('Sequence registry has not mounted');
+ };
- return (
- <SequenceOutlineContext.Provider value>
- <WrapSequenceContext>
- <SequenceManager.Provider value={sequenceManagerContext}>
- {children}
- </SequenceManager.Provider>
- </WrapSequenceContext>
- </SequenceOutlineContext.Provider>
- );
+ const CaptureRegistry = () => {
+ const registry = React.useContext(SequenceRegistryContext);
+ if (registry === null) throw new Error('Sequence registry has not mounted');
+ getSequences = registry.getSnapshot;
+ return null;
};
+ const wrapper: React.FC<{children: React.ReactNode}> = ({children}) => (
+ <SequenceOutlineContext.Provider value>
+ <WrapSequenceContext>
+ <CaptureRegistry />
+ {children}
+ </WrapSequenceContext>
+ </SequenceOutlineContext.Provider>
+ );
const {result} = renderHook(
() =>
- useMediaInTimeline({
+ useMediaInTimelineRegistration({
volume: 1,
src: 'test.mp4',
mediaVolume: 1,
@@ -157,15 +138,14 @@ test('useMediaInTimeline keeps documentation links for custom display names', ()
documentationLink: 'https://www.remotion.dev/docs/html5-video',
muted: false,
}),
- {
- wrapper,
- },
+ {wrapper},
);
-
- expect(registerSequence.mock.calls[0]?.[0]).toMatchObject({
+ expect(getSequences()[0]).toMatchObject({
displayName: 'Intro',
documentationLink: 'https://www.remotion.dev/docs/html5-video',
- refForOutline: result.current,
+ refForOutline: result.current.automaticOutlineRef,
});
- expect(SequenceOutlineInternals.getNodes(result.current!)).toEqual([]);
+ expect(
+ SequenceOutlineInternals.getNodes(result.current.automaticOutlineRef!),
+ ).toEqual([]);
});
diff --git a/packages/core/src/test/wrap-sequence-context.tsx b/packages/core/src/test/wrap-sequence-context.tsx
index c7b0c86a39..81e309e671 100644
--- a/packages/core/src/test/wrap-sequence-context.tsx
+++ b/packages/core/src/test/wrap-sequence-context.tsx
@@ -1,12 +1,16 @@
-import React, {useContext, useMemo} from 'react';
+import React, {useContext, useEffect, useMemo, useRef} from 'react';
import {BufferingProvider} from '../buffering.js';
import {CanUseRemotionHooksProvider} from '../CanUseRemotionHooks.js';
+import type {TSequence} from '../CompositionManager.js';
import type {CompositionManagerContext} from '../CompositionManagerContext.js';
import {CompositionManager} from '../CompositionManagerContext.js';
import type {LoggingContextValue} from '../log-level-context.js';
import {LogLevelContext} from '../log-level-context.js';
import {createRuntimeValueStore} from '../runtime-value-store.js';
-import {SequenceManagerProvider} from '../SequenceManager.js';
+import {
+ SequenceManagerProvider,
+ SequenceRegistryContext,
+} from '../SequenceManager.js';
import type {
PlaybackRateContextValue,
SetTimelineContextValue,
@@ -21,6 +25,34 @@ import {
const Comp: React.FC = () => null;
+export const ObserveSequenceRegistrations: React.FC<{
+ readonly onRegisterSequence: (sequence: TSequence) => void;
+}> = ({onRegisterSequence}) => {
+ const registry = useContext(SequenceRegistryContext);
+ const previous = useRef(new Map<string, TSequence>());
+ useEffect(() => {
+ if (registry === null) {
+ throw new Error('Sequence registry has not mounted');
+ }
+
+ const observe = () => {
+ const sequences = registry.getSnapshot();
+ const changed = sequences.filter(
+ (sequence) => previous.current.get(sequence.id) !== sequence,
+ );
+ previous.current = new Map(
+ sequences.map((sequence) => [sequence.id, sequence]),
+ );
+ changed.forEach(onRegisterSequence);
+ };
+
+ const unsubscribe = registry.subscribe(observe);
+ observe();
+ return unsubscribe;
+ }, [onRegisterSequence, registry]);
+ return null;
+};
+
const makeMockCompositionContext = (
durationInFrames: number,
): CompositionManagerContext => ({
diff --git a/packages/core/src/use-media-in-timeline.ts b/packages/core/src/use-media-in-timeline.ts
index 7e4e129a3e..84e6819a3c 100644
--- a/packages/core/src/use-media-in-timeline.ts
+++ b/packages/core/src/use-media-in-timeline.ts
@@ -348,9 +348,3 @@ export const useMediaInTimelineRegistration = ({
});
return {automaticOutlineRef, registration};
};
-
-// Outline-only helper. Internal registration consumers use the full descriptor
-// returned by useMediaInTimelineRegistration and attach committed metadata.
-export const useMediaInTimeline = (
- props: Parameters<typeof useMediaInTimelineRegistration>[0],
-) => useMediaInTimelineRegistration(props).automaticOutlineRef;
diff --git a/packages/core/src/use-sequence-registration.ts b/packages/core/src/use-sequence-registration.ts
index d77e7db973..f6b4534f34 100644
--- a/packages/core/src/use-sequence-registration.ts
+++ b/packages/core/src/use-sequence-registration.ts
@@ -62,7 +62,6 @@ export const useSequenceRegistration = ({
commitRegistrationEnabled ||
registrationDisabled ||
getSequence === null ||
- updateSequence === null ||
lastRegisteredGetterRef.current === getSequence
) {
return;
diff --git a/packages/gif/src/test/Gif.test.tsx b/packages/gif/src/test/Gif.test.tsx
index 160f0b4e4a..de84fdf67b 100644
--- a/packages/gif/src/test/Gif.test.tsx
+++ b/packages/gif/src/test/Gif.test.tsx
@@ -1,6 +1,6 @@
import {afterEach, beforeEach, expect, test} from 'bun:test';
import {cleanup, render, waitFor} from '@testing-library/react';
-import React, {useCallback, useMemo} from 'react';
+import React, {useMemo} from 'react';
import {Internals} from 'remotion';
import {Gif, gifSchema} from '../Gif';
import {manuallyManagedGifCache} from '../gif-cache';
@@ -128,28 +128,41 @@ const logContext = {
mountTime: 0,
} as React.ContextType<typeof Internals.LogLevelContext>;
+const ObserveSequenceRegistrations: React.FC<{
+ readonly onRegisterSequence: (sequence: RegisteredSequence) => void;
+}> = ({onRegisterSequence}) => {
+ const registry = React.useContext(Internals.SequenceRegistryContext);
+ const previous = React.useRef(
+ new Map<
+ string,
+ ReturnType<typeof Internals.useSequenceManagerSequences>[number]
+ >(),
+ );
+ React.useEffect(() => {
+ if (registry === null) throw new Error('Sequence registry has not mounted');
+ const observe = () => {
+ const sequences = registry.getSnapshot();
+ const changed = sequences.filter(
+ (sequence) => previous.current.get(sequence.id) !== sequence,
+ );
+ previous.current = new Map(
+ sequences.map((sequence) => [sequence.id, sequence]),
+ );
+ changed.forEach(onRegisterSequence);
+ };
+
+ const unsubscribe = registry.subscribe(observe);
+ observe();
+ return unsubscribe;
+ }, [onRegisterSequence, registry]);
+ return null;
+};
+
const SequenceRegistrationWrapper: React.FC<{
readonly children: React.ReactNode;
readonly onRegisterSequence: (sequence: RegisteredSequence) => void;
readonly currentFrame?: number;
}> = ({children, onRegisterSequence, currentFrame = 0}) => {
- const registerSequence = useCallback(
- (sequence: RegisteredSequence) => {
- onRegisterSequence(sequence);
- },
- [onRegisterSequence],
- );
- const unregisterSequence = useCallback(() => undefined, []);
- const sequenceManagerContext = useMemo(
- () =>
- ({
- registerSequence,
- unregisterSequence,
- updateSequence: registerSequence,
- sequences: [],
- }) as React.ContextType<typeof Internals.SequenceManager>,
- [registerSequence, unregisterSequence],
- );
const currentTimelineContext = useMemo(
() => ({...timelineContext, frame: {comp: currentFrame}}),
[currentFrame],
@@ -169,15 +182,16 @@ const SequenceRegistrationWrapper: React.FC<{
<Internals.RemotionEnvironmentContext.Provider
value={studioEnvironment}
>
- <Internals.SequenceManager.Provider
- value={sequenceManagerContext}
- >
+ <Internals.SequenceManagerProvider>
+ <ObserveSequenceRegistrations
+ onRegisterSequence={onRegisterSequence}
+ />
<Internals.CompositionManager.Provider
value={compositionContext}
>
{children}
</Internals.CompositionManager.Provider>
- </Internals.SequenceManager.Provider>
+ </Internals.SequenceManagerProvider>
</Internals.RemotionEnvironmentContext.Provider>
</Internals.PlaybackRateContext.Provider>
</Internals.TimelineContext.Provider>
diff --git a/packages/media/src/test/sequence-playback-rate.test.tsx b/packages/media/src/test/sequence-playback-rate.test.tsx
index f8fb373696..10de6ce79e 100644
--- a/packages/media/src/test/sequence-playback-rate.test.tsx
+++ b/packages/media/src/test/sequence-playback-rate.test.tsx
@@ -415,9 +415,7 @@ test('trimmed loop volume matches live playback and complete Studio curves for r
isStudio: true,
isReadOnlyStudio: false,
};
- let sequences: React.ContextType<
- typeof Internals.SequenceManager
- >['sequences'] = [];
+ let sequences: ReturnType<typeof Internals.useSequenceManagerSequences> = [];
const observedFrames = {repeat: -1, extend: -1};
const repeatVolume = (frame: number) => {
observedFrames.repeat = frame;
@@ -430,7 +428,7 @@ test('trimmed loop volume matches live playback and complete Studio curves for r
};
const ObserveSequences: React.FC = () => {
- sequences = React.useContext(Internals.SequenceManager).sequences;
+ sequences = Internals.useSequenceManagerSequences();
return null;
};
diff --git a/packages/player/src/test/audio-context-resume.test.tsx b/packages/player/src/test/audio-context-resume.test.tsx
index 7ce5dd302a..788bf5ddac 100644
--- a/packages/player/src/test/audio-context-resume.test.tsx
+++ b/packages/player/src/test/audio-context-resume.test.tsx
@@ -73,18 +73,11 @@ class FrozenAudioContext {
}
}
-const sequenceManager = {
- registerSequence: () => undefined,
- unregisterSequence: () => undefined,
- updateSequence: null,
- sequences: [],
-};
-
const AudioComposition = () => {
return (
- <Internals.SequenceManager.Provider value={sequenceManager}>
+ <Internals.SequenceManagerProvider>
<Html5Audio src="audio.mp3" />
- </Internals.SequenceManager.Provider>
+ </Internals.SequenceManagerProvider>
);
};
diff --git a/packages/player/src/test/index.test.ts b/packages/player/src/test/index.test.ts
index eee795395c..5246d53df5 100644
--- a/packages/player/src/test/index.test.ts
+++ b/packages/player/src/test/index.test.ts
@@ -224,15 +224,8 @@ class MockAudioContext {
const AudioComposition = () => {
return React.createElement(
- Internals.SequenceManager.Provider,
- {
- value: {
- registerSequence: () => undefined,
- unregisterSequence: () => undefined,
- updateSequence: null,
- sequences: [],
- },
- },
+ Internals.SequenceManagerProvider,
+ null,
React.createElement(Html5Audio, {src: 'audio.mp3'}),
);
};
diff --git a/packages/player/src/test/keep-audio-context-alive.test.tsx b/packages/player/src/test/keep-audio-context-alive.test.tsx
index bbae8b1a57..3741f04ee5 100644
--- a/packages/player/src/test/keep-audio-context-alive.test.tsx
+++ b/packages/player/src/test/keep-audio-context-alive.test.tsx
@@ -67,22 +67,15 @@ class TrackedAudioContext {
}
}
-const sequenceManager = {
- registerSequence: () => undefined,
- unregisterSequence: () => undefined,
- updateSequence: null,
- sequences: [],
-};
-
let startBuffering: (() => {unblock: () => void}) | null = null;
const AudioComposition = () => {
startBuffering = useBufferState().delayPlayback;
return (
- <Internals.SequenceManager.Provider value={sequenceManager}>
+ <Internals.SequenceManagerProvider>
<Html5Audio src="audio.mp3" />
- </Internals.SequenceManager.Provider>
+ </Internals.SequenceManagerProvider>
);
};
diff --git a/packages/player/src/test/sandboxed-iframe.test.tsx b/packages/player/src/test/sandboxed-iframe.test.tsx
index ef08f6309b..679684718e 100644
--- a/packages/player/src/test/sandboxed-iframe.test.tsx
+++ b/packages/player/src/test/sandboxed-iframe.test.tsx
@@ -1,5 +1,5 @@
import {afterEach, expect, test} from 'bun:test';
-import {useMemo, useState} from 'react';
+import {useState} from 'react';
import {AnimatedImage, Html5Audio, Html5Video, Internals} from 'remotion';
import {Player} from '../Player.js';
import {act, cleanup, render} from './test-utils.js';
@@ -17,26 +17,17 @@ test('Player resolves media sources when its origin is opaque', () => {
const [audioSource, setAudioSourceState] = useState(
'https://example.com/audio.mp3',
);
- const sequenceManagerContext = useMemo(
- () => ({
- registerSequence: () => undefined,
- unregisterSequence: () => undefined,
- updateSequence: null,
- sequences: [],
- }),
- [],
- );
setAudioSource = setAudioSourceState;
return (
- <Internals.SequenceManager.Provider value={sequenceManagerContext}>
+ <Internals.SequenceManagerProvider>
<Html5Video src="/video.mp4" />
<Html5Audio src={audioSource} />
<AnimatedImage
src="https://example.com/image.gif"
onError={() => undefined}
/>
- </Internals.SequenceManager.Provider>
+ </Internals.SequenceManagerProvider>
);
};
diff --git a/packages/sdk/src/install-fiber-sequence-order-observer.ts b/packages/sdk/src/install-fiber-sequence-order-observer.ts
index 217bc774e2..19f3c9befa 100644
--- a/packages/sdk/src/install-fiber-sequence-order-observer.ts
+++ b/packages/sdk/src/install-fiber-sequence-order-observer.ts
@@ -84,10 +84,6 @@ const createCommitSnapshotCollector = <T>(previous: readonly T[] | null) => {
};
};
-type CompositionAndFolderOrderItem =
- | {readonly type: 'composition'; readonly id: string}
- | {readonly type: 'folder'; readonly id: string};
-
export const collectCommitOrderFromFiber = (
root: FiberRoot,
registrations: Map<string, CommittedSequenceRegistration> | null = null,
@@ -129,7 +125,6 @@ export const collectCommitOrderFromFiber = (
const compositionsAndFoldersByManager = new Map<
string,
{
- readonly order: CompositionAndFolderOrderItem[];
readonly registration: {
readonly onCommit: CommittedCompositionRegistration['onCommit'];
readonly previous: CommittedCompositionRegistration | null;
@@ -194,7 +189,6 @@ export const collectCommitOrderFromFiber = (
previousCompositionRegistrations?.get(metadata.id) ?? null;
const {onCommit} = metadata;
compositionsAndFoldersByManager.set(metadata.id, {
- order: [],
registration:
compositionRegistrations !== null && onCommit !== null
? {
@@ -227,7 +221,6 @@ export const collectCommitOrderFromFiber = (
compositionManagerId !== null
) {
const manager = compositionsAndFoldersByManager.get(compositionManagerId);
- manager?.order.push({type: metadata.type, id: metadata.id});
manager?.registration?.orderIds.push(`${metadata.type}:${metadata.id}`);
if (metadata.type === 'composition') {
manager?.registration?.compositions.push(metadata.value);
@@ -329,37 +322,32 @@ 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};
- },
- );
+ for (const [managerId, manager] of compositionsAndFoldersByManager) {
+ 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 {
outlineCount: outlineNodesByRef.size,
sequenceManagers,
- compositionManagers,
};
};
@@ -463,16 +451,13 @@ export const installFiberCommitOrderObserver = (
if (
order !== null &&
- (order.outlineCount > 0 ||
- order.sequenceManagers.length > 0 ||
- order.compositionManagers.length > 0)
+ (order.outlineCount > 0 || order.sequenceManagers.length > 0)
) {
try {
target.dispatchEvent(
new CustomEvent(Internals.CommittedMetadataInternals.eventName, {
detail: {
sequenceManagers: order.sequenceManagers,
- compositionManagers: order.compositionManagers,
},
}),
);
diff --git a/packages/studio/src/components/SelectedOutlineOverlay.tsx b/packages/studio/src/components/SelectedOutlineOverlay.tsx
index 45ca39cd23..c6cfafe7fc 100644
--- a/packages/studio/src/components/SelectedOutlineOverlay.tsx
+++ b/packages/studio/src/components/SelectedOutlineOverlay.tsx
@@ -13,6 +13,7 @@ import {
type GetDragOverrides,
type InteractivitySchema,
type RuntimeValueStore,
+ type TSequence,
} from 'remotion';
import {NoReactInternals} from 'remotion/no-react';
import {StudioServerConnectionCtx} from '../helpers/client-id';
@@ -710,9 +711,7 @@ type ActiveSelectedOutlineOverlayProps = Omit<
) => void;
readonly selectedSequenceKeys: ReadonlySet<string>;
readonly sequenceKeysContainingSelection: ReadonlySet<string>;
- readonly sequences: React.ContextType<
- typeof Internals.SequenceManager
- >['sequences'];
+ readonly sequences: TSequence[];
};
const ActiveSelectedOutlineOverlayUnmemoized: React.FC<
diff --git a/packages/studio/src/test/fiber-sequence-order-observer.test.ts b/packages/studio/src/test/fiber-sequence-order-observer.test.ts
index fa4d3f713e..40161af6be 100644
--- a/packages/studio/src/test/fiber-sequence-order-observer.test.ts
+++ b/packages/studio/src/test/fiber-sequence-order-observer.test.ts
@@ -54,7 +54,7 @@ test('collects sequence, composition, and folder order per manager', () => {
_remotionCommitMetadata: {
type: 'composition-manager',
id: 'compositions',
- onCommit: null,
+ onCommit: () => undefined,
},
},
children: [
@@ -129,22 +129,33 @@ test('collects sequence, composition, and folder order per manager', () => {
}),
};
- expect(collectCommitOrderFromFiber(root)).toEqual({
+ const compositionRegistrations: NonNullable<
+ Parameters<typeof collectCommitOrderFromFiber>[3]
+ >['registrations'] = new Map();
+ expect(
+ collectCommitOrderFromFiber(root, null, null, {
+ registrations: compositionRegistrations,
+ previous: null,
+ }),
+ ).toEqual({
outlineCount: 0,
sequenceManagers: [
{managerId: 'sequences', sequenceIds: ['left', 'right']},
],
- compositionManagers: [
- {
- managerId: 'compositions',
- compositionAndFolderOrder: [
- {type: 'folder', id: 'group'},
- {type: 'composition', id: 'inside'},
- {type: 'composition', id: 'outside'},
- ],
- },
- ],
});
+ const snapshot = compositionRegistrations.get('compositions')?.snapshot;
+ expect(snapshot?.compositions.map(({id}) => id)).toEqual([
+ 'inside',
+ 'outside',
+ ]);
+ expect(snapshot?.folders).toEqual([
+ {name: 'group', parent: null, order: null, stack: null},
+ ]);
+ expect(snapshot?.orderIds).toEqual([
+ 'folder:group',
+ 'composition:inside',
+ 'composition:outside',
+ ]);
});
test('chains the existing commit hook and emits the committed order once', () => {
@@ -210,7 +221,6 @@ test('chains the existing commit hook and emits the committed order once', () =>
expect(events).toEqual([
{
sequenceManagers: [{managerId: 'manager-a', sequenceIds: ['first']}],
- compositionManagers: [],
},
]);
});
diff --git a/packages/studio/src/test/sequence-props-subscription-provider.test.tsx b/packages/studio/src/test/sequence-props-subscription-provider.test.tsx
index ad5b8cbdf2..aa8b19814d 100644
--- a/packages/studio/src/test/sequence-props-subscription-provider.test.tsx
+++ b/packages/studio/src/test/sequence-props-subscription-provider.test.tsx
@@ -40,20 +40,13 @@ test('updates the imperative node path mappings without rerendering consumers',
};
render(
- <Internals.SequenceManager.Provider
- value={{
- registerSequence: () => undefined,
- sequences: [],
- unregisterSequence: () => undefined,
- updateSequence: null,
- }}
- >
+ <Internals.SequenceManagerProvider>
<SequencePropsSubscriptionProvider>
<RefConsumer />
<ReactiveConsumer />
<Setter />
</SequencePropsSubscriptionProvider>
- </Internals.SequenceManager.Provider>,
+ </Internals.SequenceManagerProvider>,
);
const nodePath: SequencePropsSubscriptionKey = {
diff --git a/packages/transitions/src/test/transition-series-stack.test.tsx b/packages/transitions/src/test/transition-series-stack.test.tsx
index b8cfb26f82..7d9ac5f0c9 100644
--- a/packages/transitions/src/test/transition-series-stack.test.tsx
+++ b/packages/transitions/src/test/transition-series-stack.test.tsx
@@ -3,7 +3,7 @@ import {
makeMockCompositionManagerContext,
makeTimelineContext,
} from '@remotion/test-utils';
-import React, {useCallback, useMemo} from 'react';
+import React, {useMemo} from 'react';
import {createRoot} from 'react-dom/client';
import {
Internals,
@@ -47,6 +47,55 @@ const visualModeSetters = {
setPropStatuses: () => undefined,
};
+const ObserveSequenceRegistrations: React.FC<{
+ readonly onRegisterSequence: (sequence: RegisteredSequence) => void;
+}> = ({onRegisterSequence}) => {
+ const registry = React.useContext(Internals.SequenceRegistryContext);
+ const previous = React.useRef(
+ new Map<
+ string,
+ ReturnType<typeof Internals.useSequenceManagerSequences>[number]
+ >(),
+ );
+ React.useEffect(() => {
+ if (registry === null) throw new Error('Sequence registry has not mounted');
+ const observe = () => {
+ const sequences = registry.getSnapshot();
+ const changed = sequences.filter(
+ (sequence) => previous.current.get(sequence.id) !== sequence,
+ );
+ previous.current = new Map(
+ sequences.map((sequence) => [sequence.id, sequence]),
+ );
+ changed.forEach(onRegisterSequence);
+ };
+
+ const unsubscribe = registry.subscribe(observe);
+ observe();
+ return unsubscribe;
+ }, [onRegisterSequence, registry]);
+ return null;
+};
+
+const ApplyVisualModeOverrides: React.FC<{
+ readonly mappings: OverrideIdToNodePaths;
+ readonly overrides: DragOverrides;
+}> = ({mappings, overrides}) => {
+ const setters = React.useContext(Internals.VisualModeBatchSettersContext);
+ React.useLayoutEffect(() => {
+ if (setters === null)
+ throw new Error('Visual mode setters have not mounted');
+ setters.setDragOverridesBatch(
+ Object.values(mappings).flatMap((nodePath) =>
+ Object.entries(
+ overrides[Internals.makeSequencePropsSubscriptionKey(nodePath)] ?? {},
+ ).map(([key, value]) => ({nodePath, key, value})),
+ ),
+ );
+ }, [mappings, overrides, setters]);
+ return null;
+};
+
const SequenceTestWrapper: React.FC<{
readonly children: React.ReactNode;
readonly frame?: number;
@@ -62,39 +111,10 @@ const SequenceTestWrapper: React.FC<{
propStatuses,
dragOverrides,
}) => {
- const registerSequence = useCallback(
- (sequence: RegisteredSequence) => {
- onRegisterSequence(sequence);
- },
- [onRegisterSequence],
- );
-
- const sequenceContext = useMemo(
- () => ({
- registerSequence,
- unregisterSequence: () => undefined,
- updateSequence: registerSequence,
- sequences: [],
- }),
- [registerSequence],
- );
const visualModePropStatuses = useMemo(
() => ({propStatuses}),
[propStatuses],
);
- const visualModeDragOverrides = useMemo(
- () => ({
- getDragOverrides: (
- nodePath: Parameters<
- typeof Internals.makeSequencePropsSubscriptionKey
- >[0],
- ) =>
- dragOverrides[Internals.makeSequencePropsSubscriptionKey(nodePath)] ??
- {},
- getEffectDragOverrides: () => ({}),
- }),
- [dragOverrides],
- );
const overrideIdToNodePathContext = useMemo(
() => ({overrideIdToNodePathMappings}),
[overrideIdToNodePathMappings],
@@ -112,21 +132,24 @@ const SequenceTestWrapper: React.FC<{
<Internals.OverrideIdsToNodePathsGettersContext.Provider
value={overrideIdToNodePathContext}
>
- <Internals.SequenceManager.Provider value={sequenceContext}>
+ <Internals.SequenceManagerProvider>
+ <ApplyVisualModeOverrides
+ mappings={overrideIdToNodePathMappings}
+ overrides={dragOverrides}
+ />
+ <ObserveSequenceRegistrations
+ onRegisterSequence={onRegisterSequence}
+ />
<Internals.VisualModePropStatusesContext.Provider
value={visualModePropStatuses}
>
- <Internals.VisualModeDragOverridesContext.Provider
- value={visualModeDragOverrides}
+ <Internals.VisualModeSettersContext.Provider
+ value={visualModeSetters}
>
- <Internals.VisualModeSettersContext.Provider
- value={visualModeSetters}
- >
- {children}
- </Internals.VisualModeSettersContext.Provider>
- </Internals.VisualModeDragOverridesContext.Provider>
+ {children}
+ </Internals.VisualModeSettersContext.Provider>
</Internals.VisualModePropStatusesContext.Provider>
- </Internals.SequenceManager.Provider>
+ </Internals.SequenceManagerProvider>
</Internals.OverrideIdsToNodePathsGettersContext.Provider>
</Internals.TimelineContext.Provider>
</Internals.CompositionManager.Provider>