🎥 Make videos programmatically with React
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);