Skip to content

🎥 Make videos programmatically with React

25.0 KB
Raw Blame
import type {
	InputHTMLAttributes,
	MouseEventHandler,
	PointerEventHandler,
} from 'react';
import React, {
	useCallback,
	useEffect,
	useLayoutEffect,
	useMemo,
	useRef,
	useState,
} from 'react';
import {interpolate} from 'remotion';
import {
	BLUE,
	BLUE_HOVERED,
	TRANSPARENT,
	WHITE_ALPHA_10,
} from '../../helpers/colors';
import {noop} from '../../helpers/noop';
import {
	isPointerSessionRelease,
	observePointerRelease,
	startCapturedPointerSession,
} from '../../helpers/pointer-session';
import {getClickLock, setClickLock} from '../../state/input-dragger-click-lock';
import {HigherZIndex} from '../../state/z-index';
import {
	forceSpecificCursor,
	stopForcingSpecificCursor,
} from '../ForceSpecificCursor';
import type {RemInputStatus} from './RemInput';
import {RemotionInput, inputBaseStyle} from './RemInput';

type Props = Omit<InputHTMLAttributes<HTMLInputElement>, 'title'> & {
	readonly onValueChange: (newVal: number, source: 'input' | 'drag') => void;
	readonly onValueChangeEnd?: (
		newVal: number,
		source: 'input' | 'drag',
	) => void;
	readonly onTextChange: (newVal: string) => void;
	readonly status: RemInputStatus;
	readonly formatter?: (str: number | string) => string;
	readonly formatterStyle?: React.CSSProperties;
	readonly formatterSubtitle?: (str: number | string) => string;
	readonly formatterSubtitleStyle?: React.CSSProperties;
	readonly buttonStyle?: React.CSSProperties;
	readonly rightAlign: boolean;
	readonly small?: boolean;
	readonly allowStepMismatch?: boolean;
	readonly integerOnly?: boolean;
	readonly snapToStep?: boolean;
	readonly dragDecimalPlaces?: number;
	readonly dragSensitivity?: number;
};

type TextEditing = {
	readonly format: (value: number | string) => string;
	readonly parse: (text: string) => number | null;
	readonly invalidMessage: string;
	readonly onCancel: () => void;
};

type InputDraggerValidationResult =
	| {
			readonly valid: true;
			readonly value: number;
	  }
	| {
			readonly valid: false;
			readonly message: string;
	  };

const inputDraggerStyle: React.CSSProperties = {
	...inputBaseStyle,
	lineHeight: 1.5,
	padding: '4px 6px',
	fontVariantNumeric: 'tabular-nums',
};

export const inputDraggerContainerStyle: React.CSSProperties = {
	...inputDraggerStyle,
	backgroundColor: TRANSPARENT,
	borderColor: TRANSPARENT,
	display: 'inline-block',
	outline: 'none',
};

const containerStyle: React.CSSProperties = {
	display: 'inline-flex',
	position: 'relative',
};

const compactInputDraggerStyle: React.CSSProperties = {
	fontSize: 12,
	lineHeight: '16px',
	padding: '0 6px',
};

const compactInputDraggerContainerStyle: React.CSSProperties = {
	...inputDraggerContainerStyle,
	...compactInputDraggerStyle,
};

let activateInputDraggerOnNextFocus = false;

const clearInputDraggerActivationRequest = () => {
	// Let the receiving dragger's React onFocus handler consume the request first.
	setTimeout(() => {
		activateInputDraggerOnNextFocus = false;
	}, 0);
	document.removeEventListener(
		'focusin',
		clearInputDraggerActivationRequest,
		true,
	);
};

const requestInputDraggerActivationOnNextFocus = () => {
	activateInputDraggerOnNextFocus = true;
	document.addEventListener(
		'focusin',
		clearInputDraggerActivationRequest,
		true,
	);
};

const consumeInputDraggerActivationRequest = () => {
	if (!activateInputDraggerOnNextFocus) {
		return false;
	}

	activateInputDraggerOnNextFocus = false;
	document.removeEventListener(
		'focusin',
		clearInputDraggerActivationRequest,
		true,
	);

	return true;
};

const isInt = (num: number) => {
	return num % 1 === 0;
};

const roundToDecimalPlaces = (val: number, decimalPlaces: number) => {
	const factor = 10 ** decimalPlaces;
	const rounded = Math.round(val * factor) / factor;
	return Object.is(rounded, -0) ? 0 : rounded;
};

export type InputDraggerExpressionResult =
	| {
			readonly status: 'valid';
			readonly value: number;
	  }
	| {
			readonly status: 'incomplete' | 'invalid';
	  };

const numberAtStartPattern = /^(?:(?:\d+(?:\.\d*)?)|(?:\.\d+))(?:e[+-]?\d+)?/i;

export const parseInputDraggerExpression = (
	input: string,
): InputDraggerExpressionResult => {
	let index = 0;

	const invalid = (): InputDraggerExpressionResult => ({status: 'invalid'});
	const incomplete = (): InputDraggerExpressionResult => ({
		status: 'incomplete',
	});

	const skipWhitespace = () => {
		while (index < input.length && /\s/.test(input[index])) {
			index++;
		}
	};

	const parsePrimary = (): InputDraggerExpressionResult => {
		skipWhitespace();
		if (index === input.length) {
			return incomplete();
		}

		if (input[index] === '(') {
			index++;
			const expression = parseExpression();
			if (expression.status !== 'valid') {
				return expression;
			}

			skipWhitespace();
			if (index === input.length) {
				return incomplete();
			}

			if (input[index] !== ')') {
				return invalid();
			}

			index++;
			return expression;
		}

		const match = input.slice(index).match(numberAtStartPattern);
		if (!match) {
			return invalid();
		}

		index += match[0].length;
		const rest = input.slice(index);
		if (/^e[+-]?\s*$/i.test(rest)) {
			return incomplete();
		}

		const value = Number(match[0]);
		return Number.isFinite(value) ? {status: 'valid', value} : invalid();
	};

	const parseUnary = (): InputDraggerExpressionResult => {
		skipWhitespace();
		if (input[index] !== '+' && input[index] !== '-') {
			return parsePrimary();
		}

		const operator = input[index];
		index++;
		const operand = parseUnary();
		if (operand.status !== 'valid') {
			return operand;
		}

		const value = operator === '-' ? -operand.value : operand.value;
		return Number.isFinite(value) ? {status: 'valid', value} : invalid();
	};

	const parseTerm = (): InputDraggerExpressionResult => {
		let left = parseUnary();
		if (left.status !== 'valid') {
			return left;
		}

		while (true) {
			skipWhitespace();
			const operator = input[index];
			if (operator !== '*' && operator !== '/') {
				return left;
			}

			index++;
			const right = parseUnary();
			if (right.status !== 'valid') {
				return right;
			}

			if (operator === '/' && right.value === 0) {
				return invalid();
			}

			const value: number =
				operator === '*' ? left.value * right.value : left.value / right.value;
			if (!Number.isFinite(value)) {
				return invalid();
			}

			left = {status: 'valid', value};
		}
	};

	const parseExpression = (): InputDraggerExpressionResult => {
		let left = parseTerm();
		if (left.status !== 'valid') {
			return left;
		}

		while (true) {
			skipWhitespace();
			const operator = input[index];
			if (operator !== '+' && operator !== '-') {
				return left;
			}

			index++;
			const right = parseTerm();
			if (right.status !== 'valid') {
				return right;
			}

			const value: number =
				operator === '+' ? left.value + right.value : left.value - right.value;
			if (!Number.isFinite(value)) {
				return invalid();
			}

			left = {status: 'valid', value};
		}
	};

	const result = parseExpression();
	if (result.status !== 'valid') {
		return result;
	}

	skipWhitespace();
	return index === input.length ? result : invalid();
};

export const parseInputDraggerNumber = (value: string) => {
	const result = parseInputDraggerExpression(value);
	return result.status === 'valid' ? result.value : null;
};

const getFiniteAttribute = (
	value: React.InputHTMLAttributes<HTMLInputElement>['min'],
) => {
	const parsed = Number(value);
	return Number.isFinite(parsed) ? parsed : null;
};

const getPositiveStep = (
	step: React.InputHTMLAttributes<HTMLInputElement>['step'],
) => {
	if (step === 'any') {
		return null;
	}

	const parsed = Number(step);
	return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
};

export const isInputDraggerValueAlignedToStep = ({
	min,
	step,
	value,
}: {
	readonly min: React.InputHTMLAttributes<HTMLInputElement>['min'];
	readonly step: React.InputHTMLAttributes<HTMLInputElement>['step'];
	readonly value: number;
}) => {
	const numericStep = getPositiveStep(step);
	if (numericStep === null) {
		return true;
	}

	const stepBase = getFiniteAttribute(min) ?? 0;
	const stepsFromBase = (value - stepBase) / numericStep;
	const tolerance =
		Number.EPSILON *
		10 *
		Math.max(
			1,
			Math.abs(value / numericStep),
			Math.abs(stepBase / numericStep),
		);

	return Math.abs(stepsFromBase - Math.round(stepsFromBase)) <= tolerance;
};

export const validateInputDraggerValue = ({
	max,
	min,
	step,
	value,
	integerOnly = false,
}: {
	readonly max: React.InputHTMLAttributes<HTMLInputElement>['max'];
	readonly min: React.InputHTMLAttributes<HTMLInputElement>['min'];
	readonly step: React.InputHTMLAttributes<HTMLInputElement>['step'];
	readonly value: string;
	readonly integerOnly?: boolean;
}): InputDraggerValidationResult => {
	const parsed = parseInputDraggerNumber(value);
	if (parsed === null) {
		return {
			valid: false,
			message: 'Enter a valid number.',
		};
	}

	const numericMin = getFiniteAttribute(min);
	if (numericMin !== null && parsed < numericMin) {
		return {
			valid: false,
			message: `Value must be greater than or equal to ${numericMin}.`,
		};
	}

	const numericMax = getFiniteAttribute(max);
	if (numericMax !== null && parsed > numericMax) {
		return {
			valid: false,
			message: `Value must be less than or equal to ${numericMax}.`,
		};
	}

	if (integerOnly && !Number.isInteger(parsed)) {
		return {
			valid: false,
			message: 'Value must be an integer.',
		};
	}

	if (!isInputDraggerValueAlignedToStep({min, step, value: parsed})) {
		return {
			valid: false,
			message: `Value must align to a step of ${step}.`,
		};
	}

	return {valid: true, value: parsed};
};

const getDecimalPlaces = (value: number) => {
	const [mantissa, exponentString] = String(value).toLowerCase().split('e');
	const exponent = Number(exponentString ?? 0);
	const fractionLength = mantissa.split('.')[1]?.length ?? 0;
	return Math.max(0, fractionLength - exponent);
};

export const deriveInputDraggerArrowValue = ({
	direction,
	max,
	min,
	step,
	value,
}: {
	readonly direction: 1 | -1;
	readonly max: React.InputHTMLAttributes<HTMLInputElement>['max'];
	readonly min: React.InputHTMLAttributes<HTMLInputElement>['min'];
	readonly step: React.InputHTMLAttributes<HTMLInputElement>['step'];
	readonly value: number;
}) => {
	const numericStep = getPositiveStep(step) ?? 1;
	const decimalPlaces = Math.max(
		getDecimalPlaces(value),
		getDecimalPlaces(numericStep),
	);
	const unroundedValue = value + direction * numericStep;
	const steppedValue =
		decimalPlaces <= 15
			? roundToDecimalPlaces(unroundedValue, decimalPlaces)
			: Number(unroundedValue.toPrecision(15));
	const numericMin = getFiniteAttribute(min) ?? -Infinity;
	const numericMax = getFiniteAttribute(max) ?? Infinity;

	return Math.min(numericMax, Math.max(numericMin, steppedValue));
};

export const deriveInputDraggerStep = ({
	min,
	snapToStep,
	step,
}: {
	readonly min: React.InputHTMLAttributes<HTMLInputElement>['min'];
	readonly snapToStep: boolean;
	readonly step: React.InputHTMLAttributes<HTMLInputElement>['step'];
}) => {
	if (!snapToStep) {
		return 'any';
	}

	if (step !== undefined) {
		return step;
	}

	if (typeof min === 'number' && isInt(min)) {
		return 1;
	}

	return 0.0001;
};

export const deriveInputDraggerDragStartValue = ({
	min,
	value,
}: {
	readonly min: React.InputHTMLAttributes<HTMLInputElement>['min'];
	readonly value: React.InputHTMLAttributes<HTMLInputElement>['value'];
}) => {
	const numericValue = Number(value);
	if (Number.isFinite(numericValue)) {
		return numericValue;
	}

	const numericMin = Number(min);
	if (Number.isFinite(numericMin)) {
		return numericMin;
	}

	return 0;
};

export const isInputDraggerValueInRange = ({
	max,
	min,
	value,
}: {
	readonly max: React.InputHTMLAttributes<HTMLInputElement>['max'];
	readonly min: React.InputHTMLAttributes<HTMLInputElement>['min'];
	readonly value: number;
}) => {
	const numericMin = Number(min);
	const numericMax = Number(max);

	return (
		(!Number.isFinite(numericMin) || value >= numericMin) &&
		(!Number.isFinite(numericMax) || value <= numericMax)
	);
};

export const deriveInputDraggerValueDiff = ({
	dragSensitivity,
	step,
	xDistance,
}: {
	readonly dragSensitivity: number;
	readonly step: number;
	readonly xDistance: number;
}) => {
	return interpolate(
		xDistance,
		[-5, -4, 0, 4, 5],
		[-step * dragSensitivity, 0, 0, 0, step * dragSensitivity],
	);
};

const InputDraggerForwardRefFn: React.ForwardRefRenderFunction<
	HTMLButtonElement,
	Props & {readonly textEditing: TextEditing | null}
> = (
	{
		onValueChange,
		onValueChangeEnd,
		min: _min,
		max: _max,
		step: _step,
		value,
		onTextChange,
		formatter = (q) => String(q),
		formatterStyle,
		formatterSubtitle,
		formatterSubtitleStyle,
		buttonStyle,
		style: inputStyle,
		status,
		rightAlign,
		small,
		allowStepMismatch = false,
		integerOnly = false,
		snapToStep = true,
		dragDecimalPlaces,
		dragSensitivity = 1,
		type: _type,
		textEditing,
		...props
	},
	ref,
) => {
	const [inputFallback, setInputFallback] = useState(false);
	const [dragging, setDragging] = useState(false);
	const fallbackRef = useRef<HTMLInputElement>(null);
	const displayRef = useRef<HTMLSpanElement>(null);
	const pointerDownRef = useRef(false);
	const editingDisplayValueRef = useRef('');
	const editingPaddingRightRef = useRef<string | null>(null);
	const formattedInputValueRef = useRef<{text: string; value: number} | null>(
		null,
	);
	const startEditing = useCallback(() => {
		editingDisplayValueRef.current = formatter(value as number | string);
		const text =
			textEditing?.format(value as number | string) ?? String(value ?? '');
		editingPaddingRightRef.current = null;
		const display = displayRef.current;
		if (
			rightAlign &&
			display?.firstChild &&
			display.parentElement &&
			editingDisplayValueRef.current.startsWith(text) &&
			editingDisplayValueRef.current !== text
		) {
			// Keep numbers in place when their display-only unit (such as fps) disappears.
			const suffix = document.createRange();
			suffix.selectNodeContents(display);
			suffix.setStart(display.firstChild, text.length);
			const {paddingRight} = window.getComputedStyle(display.parentElement);
			editingPaddingRightRef.current = `calc(${paddingRight} + ${suffix.getBoundingClientRect().width}px)`;
		}

		formattedInputValueRef.current = {
			text,
			value: deriveInputDraggerDragStartValue({min: _min, value}),
		};
		setInputFallback(true);
	}, [_min, formatter, rightAlign, textEditing, value]);
	const parseText = useCallback(
		(text: string) => {
			// Preserve the exact value when a rounded display is left untouched.
			if (
				textEditing !== null &&
				text === formattedInputValueRef.current?.text
			) {
				return formattedInputValueRef.current.value;
			}

			return textEditing === null
				? parseInputDraggerNumber(text)
				: textEditing.parse(text);
		},
		[textEditing],
	);
	const deriveStep = useMemo(() => {
		return deriveInputDraggerStep({
			min: _min,
			snapToStep,
			step: _step,
		});
	}, [_min, _step, snapToStep]);
	const validationStep = allowStepMismatch || integerOnly ? 'any' : deriveStep;

	const span: React.CSSProperties = useMemo(
		() => ({
			color: dragging ? BLUE_HOVERED : BLUE,
			cursor: 'ew-resize',
			userSelect: 'none',
			WebkitUserSelect: 'none',
			fontSize: small ? 12 : 14,
			lineHeight: small ? '16px' : undefined,
			fontVariantNumeric: 'tabular-nums',
			...formatterStyle,
		}),
		[dragging, formatterStyle, small],
	);

	const onFocus = useCallback(() => {
		if (pointerDownRef.current) {
			return;
		}

		const wasActivatedByInputDragger = consumeInputDraggerActivationRequest();
		if (small || wasActivatedByInputDragger) {
			startEditing();
		}
	}, [small, startEditing]);

	const onClick: MouseEventHandler<HTMLButtonElement> = useCallback(
		(e) => {
			if (!getClickLock()) {
				e.stopPropagation();
			}

			if (getClickLock()) {
				return;
			}

			startEditing();
		},
		[startEditing],
	);

	const onKeyDown: React.KeyboardEventHandler<HTMLButtonElement> = useCallback(
		(e) => {
			if (e.key !== 'Enter') {
				return;
			}

			e.preventDefault();
			e.stopPropagation();
			startEditing();
		},
		[startEditing],
	);

	const onEscape = useCallback(() => {
		textEditing?.onCancel();
		setInputFallback(false);
	}, [textEditing]);

	const onInputChange: React.ChangeEventHandler<HTMLInputElement> = useCallback(
		(e) => {
			e.target.setCustomValidity('');
			const parsed = parseText(e.target.value);
			if (
				parsed !== null &&
				(!integerOnly || Number.isInteger(parsed)) &&
				isInputDraggerValueInRange({
					max: _max,
					min: _min,
					value: parsed,
				})
			) {
				onValueChange(parsed, 'input');
			}
		},
		[_max, _min, integerOnly, onValueChange, parseText],
	);

	const onBlur = useCallback(() => {
		if (!fallbackRef.current) {
			return;
		}

		const newValue = fallbackRef.current.value;
		if (newValue.trim() === '') {
			onEscape();
			return;
		}

		const parsed = parseText(newValue);
		const validation = validateInputDraggerValue({
			max: _max,
			min: _min,
			step: validationStep,
			value: parsed === null ? '' : String(parsed),
			integerOnly,
		});

		if (validation.valid) {
			fallbackRef.current.setCustomValidity('');
			onValueChangeEnd?.(validation.value, 'input');

			setInputFallback(false);
		} else {
			fallbackRef.current.setCustomValidity(
				parsed === null && textEditing !== null
					? textEditing.invalidMessage
					: validation.message,
			);
			fallbackRef.current.reportValidity();
		}
	}, [
		_max,
		_min,
		integerOnly,
		onEscape,
		onValueChangeEnd,
		parseText,
		textEditing,
		validationStep,
	]);

	const onInputKeyDown: React.KeyboardEventHandler<HTMLInputElement> =
		useCallback(
			(e) => {
				if (e.key === 'Tab') {
					requestInputDraggerActivationOnNextFocus();
					return;
				}

				if (e.key === 'Enter') {
					fallbackRef.current?.blur();
					return;
				}

				if (e.key !== 'ArrowUp' && e.key !== 'ArrowDown') {
					return;
				}

				e.preventDefault();
				const parsedInputValue = parseText(e.currentTarget.value);
				const currentValue =
					parsedInputValue ??
					deriveInputDraggerDragStartValue({
						min: _min,
						value,
					});
				const steppedValue = deriveInputDraggerArrowValue({
					direction: e.key === 'ArrowUp' ? 1 : -1,
					max: _max,
					min: _min,
					step: deriveStep,
					value: currentValue,
				});
				const nextValue = integerOnly ? Math.round(steppedValue) : steppedValue;
				if (
					integerOnly &&
					!isInputDraggerValueInRange({max: _max, min: _min, value: nextValue})
				) {
					return;
				}

				e.currentTarget.value =
					textEditing?.format(nextValue) ?? String(nextValue);
				formattedInputValueRef.current = {
					text: e.currentTarget.value,
					value: nextValue,
				};
				e.currentTarget.setCustomValidity('');
				onValueChange(nextValue, 'input');
			},
			[
				_max,
				_min,
				deriveStep,
				integerOnly,
				onValueChange,
				parseText,
				textEditing,
				value,
			],
		);

	const roundToStep = (val: number, stepSize: number) => {
		const factor = 1 / stepSize;
		return Math.ceil(val * factor) / factor;
	};

	const onPointerDown: PointerEventHandler<HTMLButtonElement> = useCallback(
		(e) => {
			e.stopPropagation();
			const target = e.currentTarget as HTMLButtonElement;
			const {pageX, pageY, button} = e;
			if (button !== 0) {
				return;
			}

			pointerDownRef.current = true;
			let lastDragValue: number | null = null;

			const moveListener = (ev: PointerEvent) => {
				const xDistance = ev.pageX - pageX;
				const distanceFromStart = Math.sqrt(
					xDistance ** 2 + (ev.pageY - pageY) ** 2,
				);
				const step = Number(_step ?? 1);
				const min = Number(_min ?? 0);
				const max = Number(_max ?? Infinity);
				const dragStartValue = deriveInputDraggerDragStartValue({
					min: _min,
					value,
				});

				if (distanceFromStart > 4) {
					setClickLock(true);
					setDragging(true);
					forceSpecificCursor('ew-resize');
					target.blur();
				}

				const diff = deriveInputDraggerValueDiff({
					dragSensitivity,
					step,
					xDistance,
				});
				const newValue = Math.min(max, Math.max(min, dragStartValue + diff));
				const steppedValue = snapToStep
					? roundToStep(newValue, step)
					: dragDecimalPlaces === undefined
						? newValue
						: roundToDecimalPlaces(newValue, dragDecimalPlaces);
				const nextValue = integerOnly ? Math.round(steppedValue) : steppedValue;
				if (
					integerOnly &&
					!isInputDraggerValueInRange({max: _max, min: _min, value: nextValue})
				) {
					return;
				}

				lastDragValue = nextValue;
				onValueChange(nextValue, 'drag');
			};

			startCapturedPointerSession({
				event: e.nativeEvent,
				captureTarget: target,
				onMove: moveListener,
				onEnd: (reason, endEvent) => {
					pointerDownRef.current = false;
					setDragging(false);
					stopForcingSpecificCursor();
					const commit = isPointerSessionRelease(reason, endEvent);
					if (commit && lastDragValue !== null && onValueChangeEnd) {
						onValueChangeEnd(lastDragValue, 'drag');
					}

					setTimeout(() => {
						setClickLock(false);
					}, 2);
				},
			});
		},
		[
			_step,
			_min,
			_max,
			value,
			integerOnly,
			onValueChange,
			onValueChangeEnd,
			snapToStep,
			dragDecimalPlaces,
			dragSensitivity,
		],
	);

	useLayoutEffect(() => {
		if (inputFallback) {
			fallbackRef.current?.focus({preventScroll: true});
			fallbackRef.current?.select();
		}
	}, [inputFallback]);

	useEffect(() => {
		if (!inputFallback) {
			return;
		}

		const commitWithoutClickThrough = (event: PointerEvent) => {
			const input = fallbackRef.current;
			if (
				event.button !== 0 ||
				input === null ||
				document.activeElement !== input ||
				input.contains(event.target as Node)
			) {
				return;
			}

			// Commit before timeline selection handlers can hide the edited row.
			event.preventDefault();
			event.stopImmediatePropagation();

			const stopClick = (clickEvent: MouseEvent) => {
				clickEvent.preventDefault();
				clickEvent.stopImmediatePropagation();
			};

			window.addEventListener('click', stopClick, {capture: true, once: true});
			observePointerRelease({
				event,
				onEnd: () => {
					// The click follows pointerup, even though blurring unmounts the input.
					setTimeout(() => {
						window.removeEventListener('click', stopClick, true);
					}, 0);
				},
			});
			input.blur();
		};

		window.addEventListener('pointerdown', commitWithoutClickThrough, true);
		return () => {
			window.removeEventListener(
				'pointerdown',
				commitWithoutClickThrough,
				true,
			);
		};
	}, [inputFallback]);

	// The first flex item determines the inline baseline, so keep the button first.
	return (
		<span style={{...containerStyle, width: inputStyle?.width}}>
			<button
				ref={ref}
				type="button"
				aria-label={props['aria-label']}
				aria-hidden={inputFallback}
				tabIndex={inputFallback ? -1 : undefined}
				className={'__remotion_input_dragger'}
				style={{
					...(small
						? compactInputDraggerContainerStyle
						: inputDraggerContainerStyle),
					textAlign: rightAlign ? 'right' : 'left',
					...buttonStyle,
					width: inputStyle?.width === undefined ? buttonStyle?.width : '100%',
					// Reserve the same space while the editor is absolutely positioned above it.
					visibility: inputFallback ? 'hidden' : undefined,
				}}
				onClick={onClick}
				onFocus={onFocus}
				onKeyDown={onKeyDown}
				onPointerDown={onPointerDown}
			>
				<span ref={displayRef} style={span}>
					{inputFallback
						? editingDisplayValueRef.current
						: formatter(value as string | number)}
				</span>
				{formatterSubtitle ? (
					<span style={formatterSubtitleStyle}>
						{formatterSubtitle(value as string | number)}
					</span>
				) : null}
			</button>
			{inputFallback ? (
				<HigherZIndex onEscape={onEscape} onOutsideClick={noop}>
					<RemotionInput
						ref={fallbackRef}
						onKeyDown={onInputKeyDown}
						onBlur={onBlur}
						onChange={onInputChange}
						min={_min}
						max={_max}
						step={validationStep}
						defaultValue={formattedInputValueRef.current?.text ?? value}
						status={status}
						rightAlign={rightAlign}
						small={small}
						{...props}
						className={`__remotion_input_dragger_input ${props.className ?? ''}`}
						style={{
							...inputDraggerStyle,
							...(small ? compactInputDraggerStyle : null),
							...buttonStyle,
							...formatterStyle,
							userSelect: 'text',
							WebkitUserSelect: 'text',
							...inputStyle,
							backgroundColor: TRANSPARENT,
							borderRadius: 3,
							paddingTop: 0,
							paddingBottom: 0,
							outline: 'none',
							boxShadow: 'none',
							...(status === 'ok' ? {borderColor: WHITE_ALPHA_10} : null),
							...(editingPaddingRightRef.current === null
								? null
								: {paddingRight: editingPaddingRightRef.current}),
							display: 'block',
							position: 'absolute',
							left: 0,
							top: '50%',
							transform: 'translateY(-50%)',
							width: '100%',
							height: 'auto',
						}}
						type="text"
					/>
				</HigherZIndex>
			) : null}
		</span>
	);
};

export const InputDraggerWithTextEditing = React.forwardRef(
	InputDraggerForwardRefFn,
);

const InputDraggerWithoutTextEditing: React.ForwardRefRenderFunction<
	HTMLButtonElement,
	Props
> = (props, ref) => (
	<InputDraggerWithTextEditing {...props} ref={ref} textEditing={null} />
);

export const InputDragger = React.forwardRef(InputDraggerWithoutTextEditing);