🎥 Make videos programmatically with React
import type {File, ObjectExpression, ObjectProperty} from '@babel/types';
import type {
EffectClipboardKeyframedParam,
EffectClipboardParam,
EffectClipboardSnapshot,
} from '@remotion/studio-shared';
import type {ExpressionKind} from 'ast-types/lib/gen/kinds';
import * as recast from 'recast';
import {ensureNamedImport} from '../helpers/imports';
import {parseValueExpression} from './update-nested-prop';
const b = recast.types.builders;
export type RemotionImportName =
| 'Easing'
| 'interpolate'
| 'interpolateColors'
| 'interpolatePaths'
| 'useCurrentFrame';
export type RemotionLocalNames = Partial<Record<RemotionImportName, string>>;
const isNonLinearEasing = (
easing: EffectClipboardKeyframedParam['easing'][number],
) => easing.type !== 'linear';
const keyframedParamNeedsEasingImport = (
param: EffectClipboardKeyframedParam,
) => param.easing.some(isNonLinearEasing);
export const getRequiredRemotionImportsForEffectParams = (
params: Iterable<EffectClipboardParam>,
): Set<RemotionImportName> => {
const requiredImports = new Set<RemotionImportName>();
for (const param of params) {
if (param.type !== 'keyframed') {
continue;
}
requiredImports.add('useCurrentFrame');
requiredImports.add(param.interpolationFunction);
if (keyframedParamNeedsEasingImport(param)) {
requiredImports.add('Easing');
}
}
return requiredImports;
};
export const getRequiredRemotionImports = (
effects: EffectClipboardSnapshot[],
): Set<RemotionImportName> => {
return getRequiredRemotionImportsForEffectParams(
effects.flatMap((effect) => Object.values(effect.params)),
);
};
export const ensureRemotionImportLocalNames = ({
ast,
requiredImports,
}: {
ast: File;
requiredImports: Set<RemotionImportName>;
}): RemotionLocalNames => {
const localNames: RemotionLocalNames = {};
for (const importedName of requiredImports) {
localNames[importedName] = ensureNamedImport({
ast,
importedName,
sourcePath:
importedName === 'interpolatePaths' ? '@remotion/paths' : 'remotion',
localName: importedName,
});
}
return localNames;
};
const makeEasingExpression = ({
easing,
easingLocalName,
}: {
easing: EffectClipboardKeyframedParam['easing'][number];
easingLocalName: string;
}): ExpressionKind => {
switch (easing.type) {
case 'linear':
return b.memberExpression(
b.identifier(easingLocalName),
b.identifier('linear'),
) as ExpressionKind;
case 'step1':
return b.memberExpression(
b.identifier(easingLocalName),
b.identifier('step1'),
) as ExpressionKind;
case 'spring':
return b.callExpression(
b.memberExpression(
b.identifier(easingLocalName),
b.identifier('spring'),
),
[
b.objectExpression([
b.objectProperty(
b.identifier('damping'),
parseValueExpression(easing.damping),
),
b.objectProperty(
b.identifier('mass'),
parseValueExpression(easing.mass),
),
b.objectProperty(
b.identifier('stiffness'),
parseValueExpression(easing.stiffness),
),
...(easing.allowTail === null
? []
: [
b.objectProperty(
b.identifier('allowTail'),
b.booleanLiteral(easing.allowTail),
),
]),
...(easing.durationRestThreshold === null
? []
: [
b.objectProperty(
b.identifier('durationRestThreshold'),
parseValueExpression(easing.durationRestThreshold),
),
]),
b.objectProperty(
b.identifier('overshootClamping'),
b.booleanLiteral(easing.overshootClamping),
),
]),
] as never,
) as ExpressionKind;
case 'bezier':
return b.callExpression(
b.memberExpression(
b.identifier(easingLocalName),
b.identifier('bezier'),
),
[easing.x1, easing.y1, easing.x2, easing.y2].map((value) =>
parseValueExpression(value),
) as never,
) as ExpressionKind;
default:
throw new Error(
`Unsupported easing: ${JSON.stringify(easing satisfies never)}`,
);
}
};
const makeKeyframedOptions = ({
param,
remotionLocalNames,
}: {
param: EffectClipboardKeyframedParam;
remotionLocalNames: RemotionLocalNames;
}): ObjectExpression | null => {
const properties: ObjectProperty[] = [];
if (param.interpolationFunction !== 'interpolateColors') {
if (param.clamping.left !== 'extend') {
properties.push(
b.objectProperty(
b.identifier('extrapolateLeft'),
b.stringLiteral(param.clamping.left),
) as ObjectProperty,
);
}
if (param.clamping.right !== 'extend') {
properties.push(
b.objectProperty(
b.identifier('extrapolateRight'),
b.stringLiteral(param.clamping.right),
) as ObjectProperty,
);
}
if (
param.interpolationFunction === 'interpolate' &&
param.output === 'perceptual-scale'
) {
properties.push(
b.objectProperty(
b.identifier('output'),
b.stringLiteral(param.output),
) as ObjectProperty,
);
}
}
if (keyframedParamNeedsEasingImport(param)) {
const easingLocalName = remotionLocalNames.Easing ?? 'Easing';
properties.push(
b.objectProperty(
b.identifier('easing'),
b.arrayExpression(
param.easing.map((easing) =>
makeEasingExpression({easing, easingLocalName}),
) as never,
),
) as ObjectProperty,
);
}
if (param.posterize !== undefined) {
properties.push(
b.objectProperty(
b.identifier('posterize'),
parseValueExpression(param.posterize) as never,
) as ObjectProperty,
);
}
if (properties.length === 0) {
return null;
}
return b.objectExpression(properties as never) as ObjectExpression;
};
const makeKeyframedExpression = ({
param,
remotionLocalNames,
}: {
param: EffectClipboardKeyframedParam;
remotionLocalNames: RemotionLocalNames;
}): ExpressionKind => {
const expectedEasingCount = Math.max(0, param.keyframes.length - 1);
if (param.easing.length !== expectedEasingCount) {
throw new Error('Cannot paste keyframed effect: invalid easing metadata');
}
const calleeName =
remotionLocalNames[param.interpolationFunction] ??
param.interpolationFunction;
const args: ExpressionKind[] = [
b.identifier('frame') as ExpressionKind,
b.arrayExpression(
param.keyframes.map((keyframe) =>
parseValueExpression(keyframe.frame),
) as never,
) as ExpressionKind,
b.arrayExpression(
param.keyframes.map((keyframe) =>
parseValueExpression(keyframe.value),
) as never,
) as ExpressionKind,
];
const options = makeKeyframedOptions({param, remotionLocalNames});
if (options) {
args.push(options as ExpressionKind);
}
return b.callExpression(
b.identifier(calleeName),
args as never,
) as ExpressionKind;
};
export const makeParamExpression = ({
param,
remotionLocalNames,
}: {
param: EffectClipboardParam;
remotionLocalNames: RemotionLocalNames;
}): ExpressionKind => {
if (param.type === 'static') {
return parseValueExpression(param.value);
}
return makeKeyframedExpression({param, remotionLocalNames});
};