🎥 Make videos programmatically with React
import {
StudioProtocolInternals,
type InstallInStudioResult,
} from '@remotion/studio-protocol';
import type {ElementInstallRequest} from '@remotion/studio-shared';
import {
useCallback,
useContext,
useEffect,
useMemo,
useRef,
useState,
type FC,
} from 'react';
import {Internals} from 'remotion';
import {getBrowserStudioOperations} from '../helpers/browser-studio-operations';
import {StudioServerConnectionCtx} from '../helpers/client-id';
import {getMissingPackages} from '../helpers/install-required-package';
import {SelectedModalContext, SetSelectedModalContext} from '../state/modals';
import {callApi} from './call-api';
import {prepareElementInstall} from './element-install-api';
import {
enqueueElementInstallRequest,
subscribeToElementInstallRequests,
} from './element-install-request';
import {getElementPositionForDrop} from './import-assets';
import {showNotification} from './Notifications/NotificationCenter';
import {getCurrentFrame} from './Timeline/imperative-state';
import {useResolvedStack} from './Timeline/use-resolved-stack';
export const ElementInstallRequestHandler: FC = () => {
const {canvasContent, compositions} = useContext(
Internals.CompositionManager,
);
const config = Internals.useUnsafeVideoConfig();
const {setSelectedModal} = useContext(SetSelectedModalContext);
const selectedModal = useContext(SelectedModalContext);
const selectedModalRef = useRef(selectedModal);
selectedModalRef.current = selectedModal;
const showingExperimentalNotice =
selectedModal?.type === 'browser-studio-experimental-notice';
const {previewServerState, subscribeToEvent} = useContext(
StudioServerConnectionCtx,
);
const previewServerClientId =
previewServerState.type === 'connected'
? previewServerState.clientId
: null;
const [pendingRequests, setPendingRequests] = useState<
ElementInstallRequest[]
>([]);
const [activeRequest, setActiveRequest] =
useState<ElementInstallRequest | null>(null);
const lastFocusedAtRef = useRef<number | null>(
typeof document === 'undefined' || document.hasFocus() ? Date.now() : null,
);
const currentCompositionId =
canvasContent?.type === 'composition' ? canvasContent.compositionId : null;
const currentComposition = useMemo(() => {
if (currentCompositionId === null) {
return null;
}
return (
compositions.find(
(composition) => composition.id === currentCompositionId,
) ?? null
);
}, [compositions, currentCompositionId]);
const resolvedCompositionLocation = useResolvedStack(
currentComposition?.stack ?? null,
);
const compositionFile = resolvedCompositionLocation?.source ?? null;
const canInstallElement =
previewServerClientId !== null && !window.remotion_isReadOnlyStudio;
const hasCurrentComposition =
canInstallElement &&
currentCompositionId !== null &&
compositionFile !== null;
const updateElementInstallTarget = useCallback(
(requestId: string) => {
if (previewServerClientId === null) {
return;
}
callApi('/api/update-element-install-target', {
requestId,
clientId: previewServerClientId,
compositionFile: hasCurrentComposition ? compositionFile : null,
compositionId: hasCurrentComposition ? currentCompositionId : null,
lastFocusedAt: lastFocusedAtRef.current,
readOnly: window.remotion_isReadOnlyStudio,
studioUrl: window.location.href,
}).catch(() => undefined);
},
[
compositionFile,
currentCompositionId,
hasCurrentComposition,
previewServerClientId,
],
);
useEffect(() => {
const markFocused = () => {
lastFocusedAtRef.current = Date.now();
};
window.addEventListener('focus', markFocused);
document.addEventListener('pointerdown', markFocused, {capture: true});
return () => {
window.removeEventListener('focus', markFocused);
document.removeEventListener('pointerdown', markFocused, {capture: true});
};
}, []);
useEffect(() => {
return subscribeToEvent('request-element-install-target', (event) => {
if (event.type !== 'request-element-install-target') {
return;
}
updateElementInstallTarget(event.requestId);
});
}, [subscribeToEvent, updateElementInstallTarget]);
useEffect(() => {
if (previewServerClientId === null) {
return;
}
return subscribeToEvent('element-install-request', (event) => {
if (
event.type !== 'element-install-request' ||
event.request.clientId !== previewServerClientId
) {
return;
}
enqueueElementInstallRequest(event.request);
});
}, [previewServerClientId, subscribeToEvent]);
useEffect(() => {
const onMessage = (event: MessageEvent) => {
const elementLibrary = document.querySelector<HTMLIFrameElement>(
'iframe[data-remotion-element-library]',
);
if (
event.source !== elementLibrary?.contentWindow ||
!StudioProtocolInternals.isAllowedStudioProtocolPageOrigin(event.origin)
) {
return;
}
const payload =
StudioProtocolInternals.parseStudioProtocolIframeInstallRequest(
event.data,
);
const responsePort = event.ports[0];
if (payload === null || responsePort === undefined) {
return;
}
const modal = selectedModalRef.current;
const selectsCaptionStyle =
modal?.type === 'transcribe' && modal.target !== null;
if (
selectsCaptionStyle &&
(payload.element.isCaptionStyle !== true ||
payload.element.installationMode !== 'component-owned-sequence')
) {
responsePort.postMessage({
success: false,
code: 'request-rejected',
message: 'This Element is not a caption style',
} satisfies InstallInStudioResult);
window.setTimeout(() => responsePort.close(), 1000);
showNotification('This Element is not a caption style', 4000);
return;
}
const request: ElementInstallRequest | null = canInstallElement
? {
clientId: previewServerClientId,
compositionFile,
compositionId: currentCompositionId,
createdAt: Date.now(),
element: {
...payload.element,
durationInFrames: payload.element.durationInFrames ?? null,
initialProps: payload.element.initialProps ?? null,
installationMode: payload.element.installationMode ?? null,
isCaptionStyle: payload.element.isCaptionStyle ?? false,
},
from: null,
id: crypto.randomUUID(),
position: null,
source: {origin: event.origin, type: 'studio-protocol'},
}
: null;
const result: InstallInStudioResult = canInstallElement
? {
success: true,
status: 'awaiting-confirmation',
target: {
compositionId: currentCompositionId,
projectName: window.remotion_projectName,
studioOrigin: window.location.origin,
studioVersion: window.remotion_version,
},
}
: {
success: false,
code: 'no-installable-target',
message: 'Focus Remotion Studio, then try again.',
};
const timeout = window.setTimeout(() => responsePort.close(), 1000);
responsePort.onmessage = () => {
window.clearTimeout(timeout);
responsePort.close();
if (request === null) {
return;
}
if (selectsCaptionStyle) {
setSelectedModal((current) =>
current?.type === 'transcribe' && current.target !== null
? {...current, captionStyle: request}
: current,
);
return;
}
enqueueElementInstallRequest(request);
};
responsePort.postMessage(result);
};
window.addEventListener('message', onMessage);
return () => window.removeEventListener('message', onMessage);
}, [
canInstallElement,
compositionFile,
currentCompositionId,
previewServerClientId,
setSelectedModal,
]);
useEffect(() => {
return subscribeToElementInstallRequests((request) => {
const shouldAddCompositionDefaults =
request.source.type !== 'drag-and-drop' &&
request.compositionFile !== null &&
request.compositionId !== null;
const requestWithDefaults = shouldAddCompositionDefaults
? {
...request,
from: request.from ?? getCurrentFrame(),
position:
request.position ??
getElementPositionForDrop({
dimensions: request.element.dimensions,
dropPosition:
config === null
? null
: {
centerX: config.width / 2,
centerY: config.height / 2,
},
}),
}
: request;
setPendingRequests((requests) => [...requests, requestWithDefaults]);
});
}, [config]);
useEffect(() => {
if (!canInstallElement || showingExperimentalNotice) {
return;
}
const initialElement =
getBrowserStudioOperations()?.consumeInitialElement() ?? null;
if (initialElement === null) {
return;
}
enqueueElementInstallRequest({
clientId: 'browser-studio',
compositionFile,
compositionId: currentCompositionId,
createdAt: Date.now(),
element: initialElement.element,
from: null,
id: crypto.randomUUID(),
position: null,
source: {
origin: initialElement.sourceOrigin,
type: 'browser-studio-link',
},
});
}, [
canInstallElement,
compositionFile,
currentCompositionId,
showingExperimentalNotice,
]);
useEffect(() => {
if (
activeRequest !== null ||
pendingRequests.length === 0 ||
showingExperimentalNotice
) {
return;
}
const [nextRequest, ...remainingRequests] = pendingRequests;
if (!nextRequest) {
throw new Error('Expected pending Element install request');
}
setActiveRequest(nextRequest);
setPendingRequests(remainingRequests);
}, [activeRequest, pendingRequests, showingExperimentalNotice]);
const closeElementInstallDialog = useCallback(() => {
setSelectedModal((modal) =>
modal?.type === 'element-install' ? null : modal,
);
setActiveRequest(null);
}, [setSelectedModal]);
const cancelElementInstallDialog = useCallback(() => {
setSelectedModal((modal) =>
modal?.type === 'element-install' ? modal.library : modal,
);
setActiveRequest(null);
}, [setSelectedModal]);
useEffect(() => {
if (activeRequest === null) {
return;
}
let canceled = false;
const handleInstallRequest = async () => {
try {
const currentDestination =
activeRequest.compositionFile === null ||
activeRequest.compositionId === null
? null
: {
compositionFile: activeRequest.compositionFile,
compositionId: activeRequest.compositionId,
};
const [newPreflight, currentPreflight] = await Promise.all([
prepareElementInstall({
installationName: null,
destination: {
type: 'new-composition',
compositionFile: null,
},
element: activeRequest.element,
}),
currentDestination === null
? null
: prepareElementInstall({
installationName: null,
destination: {
type: 'current-composition',
compositionFile: currentDestination.compositionFile,
compositionId: currentDestination.compositionId,
},
element: activeRequest.element,
}),
]);
if (canceled) {
return;
}
if (!newPreflight.success) {
showNotification(
`Could not review Element installation: ${newPreflight.reason}`,
4000,
);
setActiveRequest(null);
return;
}
const declaredDependencies = Array.from(
new Map(
activeRequest.element.dependencies.map((dependency) => [
dependency.name,
dependency,
]),
).values(),
);
const missingPackages = getMissingPackages(declaredDependencies).map(
(dependency) =>
dependency.version === null
? dependency.name
: `${dependency.name}@${dependency.version}`,
);
const {source} = activeRequest;
const sourceLabel =
source.type === 'studio-protocol'
? source.origin
: source.type === 'browser-studio-link'
? (source.origin ?? 'Unverified Browser Studio link')
: 'Unverified drag-and-drop payload';
const sourceIsUnverified =
source.type === 'drag-and-drop' ||
(source.type === 'browser-studio-link' && source.origin === null);
const currentPlan =
currentPreflight?.success === true ? currentPreflight.plan : null;
setSelectedModal((modal) => ({
type: 'element-install',
currentPlan,
library:
activeRequest.source.type === 'studio-protocol' &&
modal?.type === 'element-library'
? modal
: null,
missingPackages,
newPlan: newPreflight.plan,
onCancel: cancelElementInstallDialog,
onClose: closeElementInstallDialog,
request: activeRequest,
sourceIsUnverified,
sourceLabel,
}));
} catch (error) {
if (canceled) {
return;
}
showNotification(
`Could not review Element installation: ${
error instanceof Error ? error.message : String(error)
}`,
4000,
);
setActiveRequest(null);
}
};
handleInstallRequest();
return () => {
canceled = true;
};
}, [
activeRequest,
cancelElementInstallDialog,
closeElementInstallDialog,
setSelectedModal,
]);
return null;
};