Skip to content

🎥 Make videos programmatically with React

6.3 KB
Raw Blame
import React, {useCallback, useEffect, useMemo} from 'react';
import {useContext} from 'react';
import type {SerializedJSONWithCustomFields} from 'remotion';
import {NoReactInternals} from 'remotion/no-react';
import {StudioServerConnectionCtx} from '../../helpers/client-id';
import {FAIL_COLOR} from '../../helpers/colors';
import {Button} from '../Button';
import {Flex, Row, Spacing} from '../layout';
import {RemTextarea} from '../NewComposition/RemTextarea';
import {ValidationMessage} from '../NewComposition/ValidationMessage';
import type {State} from './DataEditor';
import {deepEqual} from './SchemaEditor/deep-equal';
import type {AnyZodSchema} from './SchemaEditor/zod-schema-type';
import {zodSafeParse} from './SchemaEditor/zod-schema-type';
import {ZodErrorMessages} from './SchemaEditor/ZodErrorMessages';

const style: React.CSSProperties = {
	fontFamily: 'monospace',
	flex: 1,
};

const inspectorStyle: React.CSSProperties = {
	fontFamily: 'monospace',
	boxSizing: 'border-box',
	flex: 'none',
	fontSize: 11,
	lineHeight: '15px',
	minHeight: 220,
	overflowY: 'hidden',
	...({
		fieldSizing: 'content',
	} satisfies React.CSSProperties & {fieldSizing: 'content'}),
};

const scrollable: React.CSSProperties = {
	padding: '8px 12px',
	display: 'flex',
	flexDirection: 'column',
	flex: 1,
};

const inspectorScrollable: React.CSSProperties = {
	...scrollable,
	flex: 'none',
};

const parseJS = (
	value: Record<string, unknown>,
	schema: AnyZodSchema,
): State => {
	try {
		const zodValidation = zodSafeParse(schema, value);
		return {
			str: JSON.stringify(value, null, 2),
			value,
			validJSON: true,
			zodValidation,
		};
	} catch (e) {
		return {
			str: JSON.stringify(value, null, 2),
			validJSON: false,
			error: (e as Error).message,
		};
	}
};

const parseJSON = (str: string, schema: AnyZodSchema): State => {
	try {
		const value = NoReactInternals.deserializeJSONWithSpecialTypes(str);
		const zodValidation = zodSafeParse(schema, value);
		return {str, value, validJSON: true, zodValidation};
	} catch (e) {
		return {str, validJSON: false, error: (e as Error).message};
	}
};

export const RenderModalJSONPropsEditor: React.FC<{
	readonly value: unknown;
	readonly setValue: React.Dispatch<
		React.SetStateAction<Record<string, unknown>>
	>;
	readonly onSave: () => void;
	readonly serializedJSON: SerializedJSONWithCustomFields | null;
	readonly defaultProps: Record<string, unknown>;
	readonly schema: AnyZodSchema;
	readonly compositionId: string;
	readonly layout?: 'default' | 'inspector';
}> = ({
	setValue,
	value,
	defaultProps,
	onSave,
	serializedJSON,
	schema,
	compositionId,
	layout = 'default',
}) => {
	if (serializedJSON === null) {
		throw new Error('expecting serializedJSON to be defined');
	}

	const {subscribeToEvent} = useContext(StudioServerConnectionCtx);

	const [localValue, setLocalValue] = React.useState<State>(() => {
		return parseJSON(serializedJSON.serializedString, schema);
	});

	useEffect(() => {
		const unsub = subscribeToEvent('default-props-updatable-changed', (e) => {
			if (e.type !== 'default-props-updatable-changed') {
				return;
			}

			if (e.compositionId !== compositionId) {
				return;
			}

			const {result} = e;
			if (result.canUpdate) {
				const deserialized = NoReactInternals.deserializeJSONWithSpecialTypes<
					Record<string, unknown>
				>(JSON.stringify(result.currentDefaultProps));
				const nextState = parseJS(deserialized, schema);
				setLocalValue(nextState);
			}
		});

		return () => {
			unsub();
		};
	}, [subscribeToEvent, compositionId, schema]);

	useEffect(() => {
		setLocalValue((prev) => {
			if (prev.validJSON && deepEqual(value, prev.value)) {
				return prev;
			}

			return parseJS(value as Record<string, unknown>, schema);
		});
	}, [value, schema]);

	const onPretty = useCallback(() => {
		if (!localValue.validJSON) {
			return;
		}

		const parsed = JSON.parse(localValue.str);
		setLocalValue({...localValue, str: JSON.stringify(parsed, null, 2)});
	}, [localValue, setLocalValue]);

	const onChange: React.ChangeEventHandler<HTMLTextAreaElement> = useCallback(
		(e) => {
			const parsed = parseJSON(e.target.value, schema);
			setLocalValue(parsed);
			if (parsed.validJSON && parsed.zodValidation.success) {
				setValue(parsed.value);
			}
		},
		[schema, setValue],
	);

	const hasError = useMemo(() => {
		return !localValue.validJSON || !localValue.zodValidation.success;
	}, [localValue]);

	const hasChanged = useMemo(() => {
		return !deepEqual(value, defaultProps);
	}, [defaultProps, value]);

	const onQuickSave = useCallback(() => {
		if (hasChanged && !hasError) {
			onSave();
		}
	}, [hasChanged, hasError, onSave]);

	// If schema is changed in code
	useEffect(() => {
		setLocalValue((v) => parseJSON(v.str, schema));
	}, [schema]);

	const reset = useCallback(() => {
		setValue(defaultProps);
		setLocalValue(parseJSON(JSON.stringify(defaultProps, null, 2), schema));
	}, [defaultProps, schema, setValue]);

	const textAreaStyle: React.CSSProperties = useMemo(() => {
		const baseStyle = layout === 'inspector' ? inspectorStyle : style;
		if (!hasError) {
			return baseStyle;
		}

		return {
			...baseStyle,
			borderColor: FAIL_COLOR,
		};
	}, [hasError, layout]);
	const buttonSize = layout === 'inspector' ? 'condensed' : 'default';

	return (
		<div style={layout === 'inspector' ? inspectorScrollable : scrollable}>
			<RemTextarea
				onChange={onChange}
				onBlur={onQuickSave}
				value={localValue.str}
				status={localValue.validJSON ? 'ok' : 'error'}
				style={textAreaStyle}
				small={layout === 'inspector'}
			/>
			<Spacing y={1} />
			<div data-testid="json-props-error">
				{localValue.validJSON === false ? (
					<ValidationMessage
						align="flex-start"
						message={localValue.error}
						type="error"
						size={layout === 'inspector' ? 'compact' : 'default'}
					/>
				) : localValue.zodValidation.success === false ? (
					<ZodErrorMessages
						zodValidationResult={localValue.zodValidation}
						viewTab="json"
						size={layout === 'inspector' ? 'compact' : 'default'}
					/>
				) : null}
			</div>
			<Spacing y={1} />
			<Row>
				<Button
					disabled={!(hasChanged || !localValue.validJSON)}
					onClick={reset}
					size={buttonSize}
				>
					Reset
				</Button>
				<Flex />
				<Button
					disabled={!localValue.validJSON}
					onClick={onPretty}
					size={buttonSize}
				>
					Format
				</Button>
				<Spacing x={1} />
			</Row>
		</div>
	);
};