Skip to content

🎥 Make videos programmatically with React

4.2 KB
Raw Blame
import type {UpdateAvailableResponse} from '@remotion/studio-shared';
import React, {
	createContext,
	useCallback,
	useContext,
	useEffect,
	useMemo,
	useRef,
	useState,
} from 'react';
import {VERSION} from 'remotion';
import {restartStudio} from '../api/restart-studio';
import {getBrowserStudioOperations} from '../helpers/browser-studio-operations';
import {canShowUpdates} from '../helpers/can-show-updates';
import {StudioServerConnectionCtx} from '../helpers/client-id';
import {callApi} from './call-api';
import {updateAvailable} from './RenderQueue/actions';

// Keep in sync with packages/bugs/api/[v].ts
export type Bug = {
	title: string;
	description: string;
	link: string;
	versions: string[];
};

type UpgradeState = 'idle' | 'upgrading' | 'upgraded' | 'restarting';

type UpdateStatusContextValue = {
	readonly upgradeState: UpgradeState;
	readonly upgradeError: string | null;
	readonly upgrade: (version: string) => Promise<void>;
	readonly restart: () => Promise<void>;
	readonly error: string | null;
	readonly info: UpdateAvailableResponse | null;
	readonly knownBugs: Bug[] | null;
};

const UpdateStatusContext = createContext<UpdateStatusContextValue | null>(
	null,
);

export const UpdateStatusProvider: React.FC<{
	readonly children: React.ReactNode;
	readonly skillsRevision: number;
}> = ({children, skillsRevision}) => {
	const {previewServerState} = useContext(StudioServerConnectionCtx);
	const [upgradeState, setUpgradeState] = useState<UpgradeState>('idle');
	const [upgradeError, setUpgradeError] = useState<string | null>(null);
	const busy = useRef(false);
	const upgrade = useCallback(async (version: string) => {
		if (busy.current) {
			return;
		}

		busy.current = true;
		setUpgradeState('upgrading');
		setUpgradeError(null);
		try {
			await callApi('/api/upgrade-remotion', {version});
			setUpgradeState('upgraded');
		} catch (err) {
			setUpgradeError((err as Error).message);
			setUpgradeState('idle');
		} finally {
			busy.current = false;
		}
	}, []);
	const restart = useCallback(async () => {
		if (busy.current) {
			return;
		}

		busy.current = true;
		setUpgradeState('restarting');
		setUpgradeError(null);
		try {
			await restartStudio();
		} catch (err) {
			setUpgradeError((err as Error).message);
			setUpgradeState('upgraded');
		} finally {
			busy.current = false;
		}
	}, []);
	const [info, setInfo] = useState<UpdateAvailableResponse | null>(null);
	const [knownBugs, setKnownBugs] = useState<Bug[] | null>(null);
	const [error, setError] = useState<string | null>(null);
	const showUpdates = canShowUpdates({
		connectionStatus: previewServerState.type,
		isBrowserStudio: getBrowserStudioOperations() !== null,
		readOnlyStudio: window.remotion_isReadOnlyStudio,
	});

	useEffect(() => {
		if (!showUpdates) {
			setInfo(null);
			setKnownBugs(null);
			setError(null);
			return;
		}

		const updateController = new AbortController();
		const bugsController = new AbortController();

		updateAvailable(updateController.signal)
			.then((response) => {
				setInfo(response);
				setError(null);
			})
			.catch((err: Error) => {
				if (updateController.signal.aborted) {
					return;
				}

				setError(err.message);
			});

		fetch('https://bugs.remotion.dev/api/' + VERSION, {
			signal: bugsController.signal,
		})
			.then(async (response) => {
				const body = await response.json();
				setKnownBugs(body.bugs);
			})
			.catch((err: Error) => {
				if (bugsController.signal.aborted) {
					return;
				}

				// eslint-disable-next-line no-console
				console.log('Could not check for bugs in this version', err);
			});

		return () => {
			updateController.abort();
			bugsController.abort();
		};
	}, [showUpdates, skillsRevision]);

	const value = useMemo<UpdateStatusContextValue>(() => {
		return {
			error,
			info,
			knownBugs,
			upgradeState,
			upgradeError,
			upgrade,
			restart,
		};
	}, [error, info, knownBugs, upgradeState, upgradeError, upgrade, restart]);

	return (
		<UpdateStatusContext.Provider value={value}>
			{children}
		</UpdateStatusContext.Provider>
	);
};

export const useUpdateStatus = (): UpdateStatusContextValue => {
	const context = useContext(UpdateStatusContext);
	if (context === null) {
		throw new Error('useUpdateStatus must be used inside UpdateStatusProvider');
	}

	return context;
};