🎥 Make videos programmatically with React
import type {ChangeEventHandler} from 'react';
import React, {useCallback, useContext, useMemo, useState} from 'react';
import {Internals} from 'remotion';
import {getRoute, pushUrl} from '../../helpers/url-state';
import {
validateCompositionDimension,
validateCompositionName,
} from '../../helpers/validate-new-comp-data';
import {Spacing} from '../layout';
import {ModalFooterContainer} from '../ModalFooter';
import {ModalHeader} from '../ModalHeader';
import {label, optionRow, rightRow} from '../RenderModal/layout';
import {
ResolveCompositionBeforeModal,
ResolvedCompositionContext,
} from '../RenderModal/ResolveCompositionBeforeModal';
import {duplicateComposition} from '../RenderQueue/actions';
import type {ComboboxValue} from './ComboBox';
import {Combobox} from './ComboBox';
import {CompositionEditFooter} from './CompositionEditFooter';
import {DismissableModal} from './DismissableModal';
import {InputAndValidationContainer} from './InputAndValidationContainer';
import {InputDragger} from './InputDragger';
import {NewCompDuration} from './NewCompDuration';
import {RemotionInput} from './RemInput';
import {ValidationMessage} from './ValidationMessage';
const content: React.CSSProperties = {
padding: 12,
paddingRight: 12,
flex: 1,
fontSize: 13,
minWidth: 500,
};
const comboBoxStyle: React.CSSProperties = {
width: 190,
};
export type CompType = 'composition' | 'still';
const DuplicateCompositionLoaded: React.FC<{
readonly initialType: CompType;
}> = ({initialType}) => {
const context = useContext(ResolvedCompositionContext);
if (!context) {
throw new Error('Resolved composition context');
}
const {resolved, unresolved} = context;
const compositionStack = unresolved.stack ?? null;
const [initialCompType] = useState<CompType>(initialType);
const hadDimensionsDefined = unresolved.width && unresolved.height;
const hadFpsDefined = unresolved.fps !== undefined;
const hadDurationDefined = unresolved.durationInFrames !== undefined;
const [selectedFrameRate, setFrameRate] = useState(resolved.result.fps);
const {compositions} = useContext(Internals.CompositionManager);
const [type, setType] = useState<CompType>(initialCompType);
const [newId, setName] = useState(() => {
const numberAtEnd = resolved.result.id.match(/([0-9]+)$/)?.[0];
let prefix = numberAtEnd ? Number(numberAtEnd) : 1;
const initialName = resolved.result.id.replace(/([0-9]+)$/, '');
let currentName = initialName;
while (true) {
currentName = initialName + prefix;
const err = validateCompositionName(currentName, compositions);
if (!err) {
break;
}
prefix++;
}
return currentName;
});
const [size, setSize] = useState(() => ({
width: resolved.result.width,
height: resolved.result.height,
}));
const [durationInFrames, setDurationInFrames] = useState(
resolved.result.durationInFrames,
);
const onTypeChanged = useCallback((newType: CompType) => {
setType(newType);
}, []);
const onWidthChanged = useCallback((newValue: string) => {
setSize((s) => {
const {height} = s;
const newWidth = Number(newValue);
return {
height,
width: newWidth,
};
});
}, []);
const onWidthDirectlyChanged = useCallback((newWidth: number) => {
setSize((s) => {
const {height} = s;
return {
height,
width: newWidth,
};
});
}, []);
const onHeightDirectlyChanged = useCallback((newHeight: number) => {
setSize((s) => {
const {width} = s;
return {
width,
height: newHeight,
};
});
}, []);
const onHeightChanged = useCallback((newValue: string) => {
setSize((s) => {
const {width} = s;
const newHeight = Number(newValue);
return {
width,
height: newHeight,
};
});
}, []);
const onNameChange: ChangeEventHandler<HTMLInputElement> = useCallback(
(e) => {
setName(e.target.value);
},
[],
);
const onTextFpsChange = useCallback((newFps: string) => {
setFrameRate(Number(newFps));
}, []);
const onFpsChange = useCallback((newFps: number) => {
setFrameRate(newFps);
}, []);
const compNameErrMessage = validateCompositionName(newId, compositions);
const compWidthErrMessage = validateCompositionDimension('Width', size.width);
const compHeightErrMessage = validateCompositionDimension(
'Height',
size.height,
);
const typeValues: ComboboxValue[] = useMemo(() => {
return [
{
id: 'composition',
keyHint: null,
label: '<Composition />',
leftItem: null,
onClick: () => onTypeChanged('composition'),
subMenu: null,
type: 'item',
value: 'composition' as CompType,
quickSwitcherLabel: null,
},
{
id: 'still',
keyHint: null,
label: '<Still />',
leftItem: null,
onClick: () => onTypeChanged('still'),
subMenu: null,
type: 'item',
value: 'still' as CompType,
quickSwitcherLabel: null,
},
];
}, [onTypeChanged]);
const valid =
compNameErrMessage === null &&
compWidthErrMessage === null &&
compHeightErrMessage === null;
const duplicateRequest = useMemo(() => {
return {
idToDuplicate: resolved.result.id,
newDurationInFrames: hadDurationDefined ? Number(durationInFrames) : null,
newFps: hadFpsDefined ? Number(selectedFrameRate) : null,
newHeight: hadDimensionsDefined ? Number(size.height) : null,
newWidth: hadDimensionsDefined ? Number(size.width) : null,
newId,
tag: type === 'still' ? ('Still' as const) : ('Composition' as const),
};
}, [
durationInFrames,
hadDimensionsDefined,
hadDurationDefined,
hadFpsDefined,
newId,
resolved.result.id,
selectedFrameRate,
size.height,
size.width,
type,
]);
const onDuplicateSuccess = useCallback(() => {
pushUrl(`/${newId}`);
}, [newId]);
const onSubmit: React.FormEventHandler<HTMLFormElement> = useCallback((e) => {
e.preventDefault();
}, []);
return (
<>
<ModalHeader title={`Duplicate ${resolved.result.id}`} />
<form onSubmit={onSubmit}>
<div style={content}>
{initialCompType === 'composition' ? (
// We allow converting from a composition to a still, but
// not the other way around
<div style={optionRow}>
<div style={label}>Type</div>
<div style={rightRow}>
<Combobox
aria-label="Type of composition"
style={comboBoxStyle}
values={typeValues}
selectedId={type}
/>
</div>
</div>
) : null}
<div style={optionRow}>
<div style={label}>ID</div>
<div style={rightRow}>
<InputAndValidationContainer>
<RemotionInput
value={newId}
onChange={onNameChange}
type="text"
autoFocus
placeholder="Composition ID"
status="ok"
rightAlign
/>
{compNameErrMessage ? (
<>
<Spacing y={1} block />
<ValidationMessage
align="flex-start"
message={compNameErrMessage}
type="error"
/>
</>
) : null}
</InputAndValidationContainer>
</div>
</div>
{hadDimensionsDefined ? (
<>
<div style={optionRow}>
<div style={label}>Width</div>
<div style={rightRow}>
<InputAndValidationContainer>
<InputDragger
type="number"
value={size.width}
placeholder="Width"
onTextChange={onWidthChanged}
name="width"
step={2}
min={2}
required
status="ok"
formatter={(w) => `${w}px`}
max={100000000}
onValueChange={onWidthDirectlyChanged}
rightAlign={false}
/>
{compWidthErrMessage ? (
<>
<Spacing y={1} block />
<ValidationMessage
align="flex-start"
message={compWidthErrMessage}
type="error"
/>
</>
) : null}
</InputAndValidationContainer>
</div>
</div>
<div style={optionRow}>
<div style={label}>Height</div>
<div style={rightRow}>
<InputAndValidationContainer>
<InputDragger
type="number"
value={size.height}
onTextChange={onHeightChanged}
placeholder="Height"
name="height"
step={2}
required
formatter={(h) => `${h}px`}
min={2}
status="ok"
max={100000000}
onValueChange={onHeightDirectlyChanged}
rightAlign={false}
/>
{compHeightErrMessage ? (
<>
<Spacing y={1} block />
<ValidationMessage
align="flex-start"
message={compHeightErrMessage}
type="error"
/>
</>
) : null}
</InputAndValidationContainer>
</div>
</div>
</>
) : null}
{type === 'composition' && hadDurationDefined ? (
<NewCompDuration
durationInFrames={durationInFrames}
setDurationInFrames={setDurationInFrames}
/>
) : null}
{type === 'composition' && hadFpsDefined ? (
<div style={optionRow}>
<div style={label}>FPS</div>
<div style={rightRow}>
<InputDragger
type="number"
value={selectedFrameRate}
onTextChange={onTextFpsChange}
placeholder="Frame rate (fps)"
name="fps"
min={1}
required
status="ok"
max={240}
step={0.01}
onValueChange={onFpsChange}
rightAlign={false}
/>
</div>
</div>
) : null}
</div>
<ModalFooterContainer>
<CompositionEditFooter
loadingNotification={'Duplicating...'}
errorNotification={'Could not duplicate composition'}
genericSubmitLabel={'Duplicate'}
submitLabel={({relativeRootPath}) => `Add to ${relativeRootPath}`}
stack={compositionStack}
valid={valid}
onSuccess={onDuplicateSuccess}
applyEdit={({signal, symbolicatedStack}) =>
duplicateComposition(
{
...duplicateRequest,
symbolicatedStack,
undoRedoNavigation: {
undoRoute: getRoute(),
redoRoute: `/${newId}`,
},
},
signal,
)
}
/>
</ModalFooterContainer>
</form>
</>
);
};
export const DuplicateComposition: React.FC<{
readonly compositionId: string;
readonly compositionType: CompType;
}> = ({compositionId, compositionType}) => {
return (
<DismissableModal>
<ResolveCompositionBeforeModal compositionId={compositionId}>
<DuplicateCompositionLoaded initialType={compositionType} />
</ResolveCompositionBeforeModal>
</DismissableModal>
);
};