Skip to content

🎥 Make videos programmatically with React

5.6 KB
Raw Blame
import React, {
	createContext,
	createRef,
	useCallback,
	useEffect,
	useImperativeHandle,
	useMemo,
	useRef,
	useState,
} from 'react';
import {useRemotionEnvironment} from 'remotion';
import {getZodSchemaFromPrimitive} from '../api/get-zod-schema-from-primitive';
import {useZodIfPossible} from '../components/get-zod-if-possible';
import type {AnyZodSchema} from '../components/RenderModal/SchemaEditor/zod-schema-type';
import {isStudioInteractivityEnabled} from '../helpers/interactivity-enabled';
import {getVisualControlEditedValue} from './get-current-edited-value';
import {visualControlStore} from './visual-control-store';

export type VisualControlValueWithoutUnsaved = {
	valueInCode: unknown;
	schema: AnyZodSchema;
	stack: string;
};

export type VisualControlValue = VisualControlValueWithoutUnsaved & {
	unsavedValue: unknown;
};

export type Handles = Record<string, VisualControlValue>;

export type VisualControlsContextType = {
	handles: Handles;
};

type VisualControlsTabActivated = boolean;

export const VisualControlsTabActivatedContext =
	createContext<VisualControlsTabActivated>(false);

export type SetVisualControlsContextType = {
	updateHandles: () => void;
	updateValue: (key: string, value: unknown) => void;
	visualControl: <T>(key: string, value: T, schema?: AnyZodSchema) => T;
};

export const VisualControlsContext = createContext<VisualControlsContextType>({
	handles: {},
});

export type VisualControlRef = {
	// May not call it visualControl, because we rely on stacktrace names
	globalVisualControl: <T>(key: string, value: T, schema?: AnyZodSchema) => T;
};

export const visualControlRef = createRef<VisualControlRef>();

export const SetVisualControlsContext =
	createContext<SetVisualControlsContextType>({
		updateHandles: () => {
			throw new Error('updateHandles is not implemented');
		},
		updateValue: () => {
			throw new Error('updateValue is not implemented');
		},
		visualControl: () => {
			throw new Error('visualControl is not implemented');
		},
	});

export const VisualControlsProvider: React.FC<{
	readonly children: React.ReactNode;
}> = ({children}) => {
	const imperativeHandles = useRef<Record<string, VisualControlValue>>({});

	const [handles, setHandles] = useState<Record<string, VisualControlValue>>(
		{},
	);

	const state: VisualControlsContextType = useMemo(() => {
		return {
			handles,
		};
	}, [handles]);

	const setControl = useCallback(
		(key: string, value: VisualControlValueWithoutUnsaved) => {
			const existingHandle = imperativeHandles.current?.[key];
			const currentSavedState = existingHandle?.valueInCode;

			const changedSavedValue = value.valueInCode !== currentSavedState;
			const changedUnsavedValue =
				existingHandle === undefined && value.valueInCode !== undefined;

			imperativeHandles.current = {
				...imperativeHandles.current,
				[key]: {
					...value,
					unsavedValue:
						existingHandle !== undefined && !changedSavedValue
							? existingHandle.unsavedValue
							: value.valueInCode,
					valueInCode: value.valueInCode,
				},
			};

			return {
				changed: changedSavedValue || changedUnsavedValue,
				currentValue: getVisualControlEditedValue({
					key,
					handles: imperativeHandles.current,
				}),
			};
		},
		[],
	);

	const z = useZodIfPossible();

	const changedRef = useRef(false);
	const env = useRemotionEnvironment();

	const visualControl = useCallback(
		// eslint-disable-next-line prefer-arrow-callback
		function <T>(key: string, value: T, schema?: AnyZodSchema): T {
			// eslint-disable-next-line no-constant-condition
			if (handles && false) {
				/** Intentional: State is managed imperatively */
			}

			if (!env.isStudio) {
				return value;
			}

			if (!isStudioInteractivityEnabled()) {
				return value;
			}

			if (!z) {
				return value;
			}

			const {changed, currentValue} = setControl(key, {
				valueInCode: value,
				schema: (schema ?? getZodSchemaFromPrimitive(value, z)) as AnyZodSchema,
				stack: new Error().stack as string,
			});

			if (changed) {
				changedRef.current = true;
			}

			return currentValue as T;
		},
		[setControl, handles, z, env.isStudio],
	);

	const updateHandles = useCallback(() => {
		setHandles(() => {
			return imperativeHandles.current;
		});
	}, []);

	const updateValue = useCallback(
		(key: string, value: unknown) => {
			imperativeHandles.current = {
				...imperativeHandles.current,
				[key]: {
					...imperativeHandles.current[key],
					unsavedValue: value,
				},
			};
			updateHandles();
			visualControlStore.emitChange();
		},
		[updateHandles],
	);

	useImperativeHandle(visualControlRef, () => {
		return {
			globalVisualControl: visualControl,
		};
	}, [visualControl]);

	useEffect(() => {
		// Controls may have rendered before the imperative API or Zod was ready.
		visualControlStore.emitChange();
	}, [visualControl]);

	useEffect(() => {
		const callback = () => {
			if (imperativeHandles.current) {
				updateHandles();
				changedRef.current = false;
			}
		};

		const interval = setInterval(callback, 100);

		return () => {
			clearInterval(interval);
		};
	}, [updateHandles]);

	const setState: SetVisualControlsContextType = useMemo(() => {
		return {
			setControl,
			updateHandles,
			updateValue,
			visualControl,
		};
	}, [setControl, updateHandles, updateValue, visualControl]);

	return (
		<VisualControlsTabActivatedContext.Provider
			value={Object.keys(state.handles).length > 0}
		>
			<VisualControlsContext.Provider value={state}>
				<SetVisualControlsContext.Provider value={setState}>
					{children}
				</SetVisualControlsContext.Provider>
			</VisualControlsContext.Provider>
		</VisualControlsTabActivatedContext.Provider>
	);
};