🎥 Make videos programmatically with React
import type {RenderDefaults} from '@remotion/studio-shared';
import {studioHtml} from '@remotion/studio-shared/studio-html';
import React, {useCallback, useEffect, useMemo, useRef, useState} from 'react';
import {
createBrowserStudioHmrAssetManager,
type BrowserStudioHmrBridge,
} from './browser-studio-hmr-assets';
import {
BROWSER_STUDIO_TRANSFORMERS_PACKAGE,
getBrowserStudioTransformersUrl,
} from './browser-studio-import-map';
import {createBrowserStudioOperations} from './browser-studio-operations';
import {
areBrowserStudioProjectsEqual,
createBrowserStudioPublicFileManager,
} from './browser-studio-project-controller';
import {browserStudioDependencyVersions} from './dependency-versions';
import {studioRenderEntryExternal} from './dev/studio-render-entry-external';
import {LoadingProgress} from './LoadingProgress';
import {deleteBrowserStudioProjectStorage} from './opfs-public-files';
import type {
BrowserStudioDependencyResolution,
BrowserStudioProps,
BrowserStudioWorkerCompileRequest,
BrowserStudioWorkerCompileResponse,
CompileState,
} from './types';
declare const __BROWSER_STUDIO_ASSET_SIZES__: {
readonly rspackWasm: number;
readonly vendorBundle: number;
};
const makeInitialState = (): CompileState => ({
status: 'idle',
});
// The host and iframe may use different studio-shared versions, so this
// handshake intentionally has no shared runtime import.
const BROWSER_STUDIO_OPERATIONS_READY_EVENT =
'remotion-browser-studio-operations-ready';
const localStudioPreviewEntry = new URL(
'./browser-studio-preview-entry.mjs',
import.meta.url,
).href;
const localVendorEntry = new URL(
'./browser-studio-vendor-entry.mjs',
import.meta.url,
).href;
const localTransformersEntry = new URL(
'./browser-studio-transformers-entry.mjs',
import.meta.url,
).href;
const localVendorEntryWithMarker = `${localVendorEntry}?browserStudioVendor`;
const browserStudioPointerLeaveEvent = 'remotion-browser-studio-pointerleave';
type BrowserStudioContentWindow = Window & {
remotion_browserStudioHmr: BrowserStudioHmrBridge;
};
const containerStyle: React.CSSProperties = {
backgroundColor: '#111111',
color: '#ffffff',
height: '100%',
minHeight: 480,
position: 'relative',
width: '100%',
};
const iframeStyle: React.CSSProperties = {
border: 0,
display: 'block',
height: '100%',
width: '100%',
};
const overlayStyle: React.CSSProperties = {
alignItems: 'center',
backgroundColor: '#111111',
color: '#ffffff',
display: 'flex',
fontFamily: 'Arial, Helvetica, sans-serif',
fontSize: 14,
inset: 0,
justifyContent: 'center',
padding: 24,
position: 'absolute',
textAlign: 'center',
};
const errorStyle: React.CSSProperties = {
...overlayStyle,
alignItems: 'flex-start',
fontFamily: 'monospace',
justifyContent: 'flex-start',
overflow: 'auto',
textAlign: 'left',
whiteSpace: 'pre-wrap',
};
const getBrowserRenderDefaults = (): RenderDefaults => {
const maxConcurrency = navigator.hardwareConcurrency || 1;
return {
allowHtmlInCanvas: false,
audioBitrate: null,
audioCodec: null,
beepOnFinish: false,
chromeMode: 'headless-shell',
codec: 'h264',
colorSpace: 'default',
configFileRenderDefaults: null,
concurrency: Math.round(Math.min(8, Math.max(1, maxConcurrency / 2))),
crf: null,
darkMode: false,
delayRenderTimeout: 30_000,
disableWebSecurity: false,
encodingBufferSize: null,
encodingMaxRate: null,
enforceAudioTrack: false,
everyNthFrame: 1,
forSeamlessAacConcatenation: false,
gopSize: null,
hardwareAcceleration: 'disable',
headless: true,
ignoreCertificateErrors: false,
jpegQuality: 80,
logLevel: 'info',
maxConcurrency,
mediaCacheSizeInBytes: null,
metadata: null,
minConcurrency: 1,
multiProcessOnLinux: true,
muted: false,
numberOfGifLoops: null,
offthreadVideoCacheSizeInBytes: null,
offthreadVideoThreads: null,
openGlRenderer: null,
outputLocation: null,
pixelFormat: 'yuv420p',
proResProfile: null,
publicLicenseKey: null,
repro: false,
sampleRate: 48_000,
scale: 1,
sharedMemoryCapture: null,
stillImageFormat: 'png',
userAgent: null,
videoBitrate: null,
videoImageFormat: 'jpeg',
x264Preset: 'medium',
};
};
export const BrowserStudio: React.FC<BrowserStudioProps> = ({
project,
readOnly,
initialElement,
iframeSrc,
dependencyResolver,
onCompileStateChange,
onProjectChange,
remotionPackageSource,
showExperimentalNotice = false,
}) => {
const [state, setState] = useState<CompileState>(makeInitialState);
const [iframeHtml, setIframeHtml] = useState<string | null>(null);
const [iframeLoaded, setIframeLoaded] = useState(false);
const [loadingProgress, setLoadingProgress] = useState<number | null>(null);
const [compileGeneration, setCompileGeneration] = useState(0);
const reloadBrowserStudio = useCallback(() => {
setCompileGeneration((generation) => generation + 1);
}, []);
const installedDependencyResolutionsRef = useRef<
Record<string, BrowserStudioDependencyResolution>
>({});
const iframeRef = useRef<HTMLIFrameElement | null>(null);
const lastWrittenDocumentRef = useRef<Document | null>(null);
const lastWrittenHtmlRef = useRef<string | null>(null);
const workerRef = useRef<Worker | null>(null);
const initialElementRef = useRef(initialElement);
const lastSentProjectRef = useRef<BrowserStudioProps['project'] | null>(null);
const bundleUrlRef = useRef<string | null>(null);
const unsubscribeFromIframeEventsRef = useRef(new Set<() => void>());
const notifyStudioOfPointerLeave = useCallback(() => {
const contentWindow = iframeRef.current?.contentWindow;
contentWindow?.dispatchEvent(new Event(browserStudioPointerLeaveEvent));
}, []);
const onCompileStateChangeRef = useRef(onCompileStateChange);
onCompileStateChangeRef.current = onCompileStateChange;
const dependencyResolverRef = useRef(dependencyResolver);
dependencyResolverRef.current = dependencyResolver;
const publicFileManager = useMemo(
() =>
createBrowserStudioPublicFileManager({
createObjectUrl: null,
revokeObjectUrl: null,
}),
[],
);
useEffect(() => {
const onBeforeUnload = (event: BeforeUnloadEvent) => {
event.preventDefault();
event.returnValue = true;
};
window.addEventListener('beforeunload', onBeforeUnload);
return () => {
window.removeEventListener('beforeunload', onBeforeUnload);
};
}, []);
useEffect(() => {
return () => publicFileManager.dispose();
}, [publicFileManager]);
const hmrAssetManager = useMemo(
() =>
createBrowserStudioHmrAssetManager({
createObjectUrl: URL.createObjectURL,
revokeObjectUrl: URL.revokeObjectURL,
}),
[],
);
useEffect(() => {
return () => hmrAssetManager.dispose();
}, [hmrAssetManager]);
const [editedProject, setEditedProject] = useState<{
project: BrowserStudioProps['project'];
sourceProject: BrowserStudioProps['project'];
} | null>(null);
const incomingProjectMatchesEditSource =
editedProject !== null &&
areBrowserStudioProjectsEqual(editedProject.sourceProject, project);
const activeProject =
editedProject && incomingProjectMatchesEditSource
? editedProject.project
: project;
const activeProjectRef = useRef(activeProject);
activeProjectRef.current = activeProject;
const previousProjectStorageRef = useRef(activeProject.publicFileStorage);
useEffect(() => {
const previousStorage = previousProjectStorageRef.current;
const nextStorage = activeProject.publicFileStorage;
previousProjectStorageRef.current = nextStorage;
if (
previousStorage &&
previousStorage.directoryName !== nextStorage?.directoryName
) {
deleteBrowserStudioProjectStorage(previousStorage).catch((error) => {
setTimeout(() => {
throw error;
}, 0);
});
}
}, [activeProject.publicFileStorage]);
const incomingProjectRef = useRef(project);
incomingProjectRef.current = project;
const onProjectChangeRef = useRef(onProjectChange);
onProjectChangeRef.current = onProjectChange;
const updateProject = useCallback(
(nextProject: BrowserStudioProps['project']) => {
activeProjectRef.current = nextProject;
setEditedProject({
project: nextProject,
sourceProject: incomingProjectRef.current,
});
onProjectChangeRef.current?.(nextProject);
},
[],
);
const resolveElementDependencies = useCallback(
(dependencies: readonly {name: string; version: string | null}[]) => {
const remotionVersion =
remotionPackageSource?.type === 'release'
? remotionPackageSource.version
: browserStudioDependencyVersions.remotion;
if (!remotionVersion) {
throw new Error('Browser Studio Remotion version is unavailable');
}
const versions: Record<string, string> = {};
const resolutions: Record<string, BrowserStudioDependencyResolution> = {};
for (const dependency of dependencies) {
const requestedVersion = dependency.name.startsWith('@remotion/')
? remotionVersion
: dependency.version;
const customResolution = dependencyResolverRef.current?.({
name: dependency.name,
version: requestedVersion,
});
const customVersion =
typeof customResolution === 'string' &&
!customResolution.startsWith('http')
? customResolution
: typeof customResolution === 'object'
? (customResolution?.version ?? null)
: null;
const version = dependency.name.startsWith('@remotion/')
? remotionVersion
: (customVersion ?? requestedVersion);
if (version === null) {
throw new Error(`Could not resolve ${dependency.name}`);
}
versions[dependency.name] = version;
resolutions[dependency.name] = dependency.name.startsWith('@remotion/')
? typeof customResolution === 'string' &&
customResolution.startsWith('http')
? customResolution
: typeof customResolution === 'object' && customResolution?.url
? {url: customResolution.url}
: version
: (customResolution ?? version);
}
installedDependencyResolutionsRef.current = {
...installedDependencyResolutionsRef.current,
...resolutions,
};
return Promise.resolve(versions);
},
[remotionPackageSource],
);
const browserStudioOperations = useMemo(
() =>
createBrowserStudioOperations({
dependencyVersions: browserStudioDependencyVersions,
getStaticFiles: publicFileManager.getStaticFiles,
getProject: () => activeProjectRef.current,
initialElement: initialElementRef.current,
onProjectChange: updateProject,
resolveDependencies: resolveElementDependencies,
}),
[publicFileManager, resolveElementDependencies, updateProject],
);
const previousIncomingProject = useRef(project);
const incomingProjectAcknowledgesEdit =
editedProject !== null &&
areBrowserStudioProjectsEqual(editedProject.project, project);
useEffect(() => {
if (
!areBrowserStudioProjectsEqual(
previousIncomingProject.current,
project,
) &&
!incomingProjectAcknowledgesEdit
) {
browserStudioOperations.resetHistory();
}
if (incomingProjectAcknowledgesEdit) {
setEditedProject(null);
}
previousIncomingProject.current = project;
}, [browserStudioOperations, incomingProjectAcknowledgesEdit, project]);
useEffect(() => {
setIframeLoaded(false);
lastWrittenDocumentRef.current = null;
lastWrittenHtmlRef.current = null;
}, [iframeSrc]);
useEffect(() => {
let didCancel = false;
const iframeEventUnsubscribers = unsubscribeFromIframeEventsRef.current;
const setCompileState = (nextState: CompileState) => {
if (didCancel) {
return;
}
setState(nextState);
onCompileStateChangeRef.current?.(nextState);
};
setIframeLoaded(false);
lastWrittenDocumentRef.current = null;
lastWrittenHtmlRef.current = null;
setIframeHtml(null);
setCompileState({status: 'compiling'});
const configuredDependencyResolutions = Object.fromEntries(
Object.entries(browserStudioDependencyVersions).map(([name, version]) => [
name,
dependencyResolver?.({name, version}) ?? null,
]),
);
const dependencyResolutions = {
...configuredDependencyResolutions,
...installedDependencyResolutionsRef.current,
};
const transformersUrl = getBrowserStudioTransformersUrl({
localUrl: localTransformersEntry,
resolution:
dependencyResolutions[BROWSER_STUDIO_TRANSFORMERS_PACKAGE] ?? null,
});
const hasVendorOverride = Object.entries(dependencyResolutions).some(
([name, resolution]) =>
resolution !== null &&
(name.startsWith('@remotion/') ||
name === 'react-refresh' ||
studioRenderEntryExternal.includes(name)),
);
const releaseMatchesVendor =
remotionPackageSource?.type !== 'release' ||
remotionPackageSource.version ===
browserStudioDependencyVersions.remotion;
const useVendorBundle = !hasVendorOverride && releaseMatchesVendor;
const downloadProgress: Record<
'vendor-bundle' | 'rspack-wasm',
{loadedBytes: number; totalBytes: number | null} | null
> = {
'rspack-wasm': {
loadedBytes: 0,
totalBytes: __BROWSER_STUDIO_ASSET_SIZES__.rspackWasm,
},
'vendor-bundle': useVendorBundle
? {
loadedBytes: 0,
totalBytes: __BROWSER_STUDIO_ASSET_SIZES__.vendorBundle,
}
: null,
};
const updateLoadingProgress = ({
asset,
loadedBytes,
totalBytes,
}: {
asset: 'vendor-bundle' | 'rspack-wasm';
loadedBytes: number;
totalBytes: number | null;
}) => {
if (didCancel) {
return;
}
downloadProgress[asset] = {
loadedBytes,
totalBytes: downloadProgress[asset]?.totalBytes ?? totalBytes,
};
const assets = Object.values(downloadProgress).filter(
(progress) => progress !== null,
);
if (assets.some((progress) => progress.totalBytes === null)) {
setLoadingProgress(null);
return;
}
const total = assets.reduce(
(sum, progress) => sum + (progress.totalBytes ?? 0),
0,
);
const loaded = assets.reduce(
(sum, progress) =>
sum + Math.min(progress.loadedBytes, progress.totalBytes ?? 0),
0,
);
setLoadingProgress(total === 0 ? null : Math.min(0.95, loaded / total));
};
setLoadingProgress(0);
// Start the large, stable vendor download alongside the compiler. The
// iframe later executes these same bytes from a Blob URL, avoiding a
// second request after compilation finishes.
const vendorBundleAbortController = new AbortController();
const vendorBundlePromise = useVendorBundle
? fetch(localVendorEntryWithMarker, {
signal: vendorBundleAbortController.signal,
})
.then(async (response) => {
if (!response.ok) {
throw new Error(
`Failed to load the Browser Studio vendor bundle: ${response.status}`,
);
}
const contentLength = Number(
response.headers.get('content-length'),
);
const totalBytes =
Number.isFinite(contentLength) && contentLength > 0
? contentLength
: null;
updateLoadingProgress({
asset: 'vendor-bundle',
loadedBytes: 0,
totalBytes,
});
if (!response.body) {
const fallbackBlob = await response.blob();
updateLoadingProgress({
asset: 'vendor-bundle',
loadedBytes: fallbackBlob.size,
totalBytes: totalBytes ?? fallbackBlob.size,
});
return {
blob: fallbackBlob.slice(
0,
fallbackBlob.size,
'text/javascript',
),
type: 'success' as const,
};
}
const reader = response.body.getReader();
const chunks: BlobPart[] = [];
let loadedBytes = 0;
let lastProgressUpdate = 0;
while (true) {
const result = await reader.read();
if (result.done) {
break;
}
chunks.push(result.value);
loadedBytes += result.value.byteLength;
const now = performance.now();
if (now - lastProgressUpdate >= 50) {
lastProgressUpdate = now;
updateLoadingProgress({
asset: 'vendor-bundle',
loadedBytes,
totalBytes,
});
}
}
const vendorBlob = new Blob(chunks, {type: 'text/javascript'});
updateLoadingProgress({
asset: 'vendor-bundle',
loadedBytes,
totalBytes: totalBytes ?? loadedBytes,
});
return {
blob: vendorBlob,
type: 'success' as const,
};
})
.catch((error: unknown) => ({error, type: 'error' as const}))
: null;
let vendorBundleUrl: string | null = null;
if (
!useVendorBundle &&
!remotionPackageSource &&
dependencyResolutions['@remotion/studio'] === null
) {
dependencyResolutions['@remotion/studio'] = {
url: localStudioPreviewEntry,
};
}
const worker = new Worker(
new URL('./browser-studio-worker.mjs', import.meta.url),
{type: 'module'},
);
workerRef.current = worker;
lastSentProjectRef.current = activeProjectRef.current;
worker.onmessage = async (
event: MessageEvent<BrowserStudioWorkerCompileResponse>,
) => {
if (didCancel) {
return;
}
const response = event.data;
if (response.type === 'error') {
setCompileState({status: 'error', error: response.error});
return;
}
if (response.type === 'load-progress') {
updateLoadingProgress(response);
return;
}
if (response.type === 'building') {
setCompileState({status: 'compiling'});
return;
}
if (response.type === 'hmr-update') {
hmrAssetManager.updateAssets(response.assets);
browserStudioOperations.emitEvent({
hmrEvent: response.hmrEvent,
type: 'hmr',
});
setCompileState({status: 'compiled', warnings: response.warnings});
return;
}
if (bundleUrlRef.current) {
URL.revokeObjectURL(bundleUrlRef.current);
}
bundleUrlRef.current = URL.createObjectURL(
new Blob([response.bundle], {type: 'text/javascript'}),
);
const currentProject = activeProjectRef.current;
const publicFiles = await publicFileManager.getStaticFiles({
lastModifiedByPath: null,
project: currentProject,
});
if (didCancel) {
return;
}
if (vendorBundlePromise && !vendorBundleUrl) {
const vendorBundleResult = await vendorBundlePromise;
if (didCancel) {
return;
}
if (vendorBundleResult.type === 'error') {
setCompileState({
status: 'error',
error: {
message:
vendorBundleResult.error instanceof Error
? vendorBundleResult.error.message
: String(vendorBundleResult.error),
},
});
return;
}
vendorBundleUrl ??= URL.createObjectURL(vendorBundleResult.blob);
}
const bundleScriptUrl = vendorBundleUrl
? `${vendorBundleUrl}#projectBundleUrl=${encodeURIComponent(bundleUrlRef.current)}`
: bundleUrlRef.current;
const html = studioHtml({
importMap: {
[BROWSER_STUDIO_TRANSFORMERS_PACKAGE]: transformersUrl,
},
audioLatencyHint: 'playback',
experimentalKeepAudioContextAlive: false,
bundleScriptUrl,
bundleScriptType: useVendorBundle ? 'module' : undefined,
completedClientRenders: [],
editorName: null,
envVariables: {NODE_ENV: 'development'},
gitSource: null,
includeFavicon: true,
inputProps: {},
installedDependencies: null,
logLevel: 'info',
mode: 'dev',
numberOfAudioTags: 0,
outputHash: null,
packageManager: 'unknown',
projectName: 'template-blank',
publicFiles,
publicFolderExists: null,
fileSystemPlatform: null,
publicPath: '',
readOnlyStudio: readOnly,
remotionRoot: currentProject.rootDir,
renderDefaults: getBrowserRenderDefaults(),
renderQueue: [],
sampleRate: null,
staticHash: '',
studioRuntimeConfig: {
preservePitchOnPlayback: true,
showLayerFrameNumbers: false,
showPremounting: null,
defaultPremountInSeconds: null,
sequenceActivityLimit: null,
askAIEnabled: false,
bufferStateDelayInMilliseconds: null,
defaultCodingAgent: null,
defaultEditor: null,
interactivityEnabled: true,
keyboardShortcutsEnabled: true,
maxTimelineTracks: null,
publicLicenseKey: null,
canvasTabsEnabled: true,
configFileStudioSettings: null,
},
studioServerCommand: null,
title: 'Remotion Studio',
});
setIframeHtml(html);
setLoadingProgress(1);
setCompileState({status: 'compiled', warnings: response.warnings});
};
worker.onerror = (event) => {
setCompileState({
status: 'error',
error: {
message: event.message,
},
});
};
worker.postMessage({
type: 'init',
dependencyResolutions,
project: activeProjectRef.current,
remotionPackageSource: remotionPackageSource ?? null,
useVendorBundle,
} satisfies BrowserStudioWorkerCompileRequest);
return () => {
didCancel = true;
for (const unsubscribe of iframeEventUnsubscribers) {
unsubscribe();
}
iframeEventUnsubscribers.clear();
browserStudioOperations.clearPendingHmrEvent();
hmrAssetManager.dispose();
vendorBundleAbortController.abort();
if (vendorBundleUrl) {
URL.revokeObjectURL(vendorBundleUrl);
}
if (bundleUrlRef.current) {
URL.revokeObjectURL(bundleUrlRef.current);
bundleUrlRef.current = null;
}
workerRef.current = null;
lastSentProjectRef.current = null;
worker.terminate();
};
}, [
browserStudioOperations,
compileGeneration,
dependencyResolver,
hmrAssetManager,
publicFileManager,
readOnly,
remotionPackageSource,
activeProject.entryPoint,
activeProject.rootDir,
]);
useEffect(() => {
const worker = workerRef.current;
const lastSentProject = lastSentProjectRef.current;
if (
!worker ||
!lastSentProject ||
areBrowserStudioProjectsEqual(lastSentProject, activeProject)
) {
return;
}
lastSentProjectRef.current = activeProject;
worker.postMessage({
dependencyResolutions: installedDependencyResolutionsRef.current,
project: activeProject,
type: 'update-project',
} satisfies BrowserStudioWorkerCompileRequest);
}, [activeProject]);
useEffect(() => {
let cancelled = false;
publicFileManager
.getStaticFiles({
lastModifiedByPath: null,
project: activeProject,
})
.then((files) => {
if (cancelled) {
return;
}
browserStudioOperations.emitEvent({
files,
folderExists: '/public',
type: 'new-public-folder',
});
})
.catch((error) => {
if (cancelled) {
return;
}
const nextState: CompileState = {
status: 'error',
error: {
message: error instanceof Error ? error.message : String(error),
stack: error instanceof Error ? error.stack : undefined,
},
};
setState(nextState);
onCompileStateChangeRef.current?.(nextState);
});
return () => {
cancelled = true;
};
}, [activeProject, browserStudioOperations, publicFileManager]);
useEffect(() => {
return () => {
if (bundleUrlRef.current) {
URL.revokeObjectURL(bundleUrlRef.current);
bundleUrlRef.current = null;
}
};
}, []);
useEffect(() => {
if (!iframeHtml) {
return;
}
if (iframeSrc && !iframeLoaded) {
return;
}
const iframe = iframeRef.current;
const contentWindow = iframe?.contentWindow;
const contentDocument = iframe?.contentDocument;
if (!contentWindow || !contentDocument) {
return;
}
if (
lastWrittenDocumentRef.current === contentDocument &&
lastWrittenHtmlRef.current === iframeHtml
) {
return;
}
lastWrittenDocumentRef.current = contentDocument;
lastWrittenHtmlRef.current = iframeHtml;
const reloadCurrentStudio = () => {
if (
iframeRef.current?.contentWindow !== contentWindow ||
lastWrittenDocumentRef.current !== contentDocument
) {
return;
}
reloadBrowserStudio();
};
const iframeOperations = {
...browserStudioOperations,
subscribeToEvent: (
listener: Parameters<
typeof browserStudioOperations.subscribeToEvent
>[0],
) => {
const unsubscribe = browserStudioOperations.subscribeToEvent(listener);
unsubscribeFromIframeEventsRef.current.add(unsubscribe);
return () => {
unsubscribeFromIframeEventsRef.current.delete(unsubscribe);
unsubscribe();
};
},
};
contentDocument.open();
(contentWindow as BrowserStudioContentWindow).remotion_browserStudioHmr =
hmrAssetManager.bridge;
contentWindow.remotion_browserStudio = iframeOperations;
contentWindow.remotion_browserStudioReload = reloadCurrentStudio;
contentWindow.remotion_showBrowserStudioExperimentalNotice =
showExperimentalNotice;
contentDocument.write(iframeHtml);
contentDocument.close();
const activeContentWindow = iframe.contentWindow;
if (activeContentWindow) {
(
activeContentWindow as BrowserStudioContentWindow
).remotion_browserStudioHmr = hmrAssetManager.bridge;
activeContentWindow.remotion_browserStudio = iframeOperations;
activeContentWindow.remotion_browserStudioReload = reloadCurrentStudio;
activeContentWindow.remotion_showBrowserStudioExperimentalNotice =
showExperimentalNotice;
activeContentWindow.dispatchEvent(
new Event(BROWSER_STUDIO_OPERATIONS_READY_EVENT),
);
}
}, [
browserStudioOperations,
hmrAssetManager,
iframeHtml,
iframeLoaded,
iframeSrc,
reloadBrowserStudio,
showExperimentalNotice,
]);
return (
<div style={containerStyle}>
{iframeHtml ? (
<iframe
key={compileGeneration}
ref={iframeRef}
allow="cross-origin-isolated"
onLoad={() => setIframeLoaded(true)}
onPointerOut={notifyStudioOfPointerLeave}
sandbox="allow-scripts allow-same-origin allow-downloads allow-popups allow-popups-to-escape-sandbox"
src={iframeSrc ?? 'about:blank'}
style={iframeStyle}
aria-label="Remotion Studio"
/>
) : null}
{state.status === 'compiling' && iframeHtml === null ? (
<div style={overlayStyle}>
<LoadingProgress progress={loadingProgress} />
</div>
) : null}
{state.status === 'error' ? (
<pre style={errorStyle}>
{state.error.message}
{state.error.diagnostics?.length
? `\n\n${state.error.diagnostics.join('\n')}`
: ''}
</pre>
) : null}
</div>
);
};