🎥 Make videos programmatically with React
import type {
ArrayExpression,
AssignmentExpression,
ExpressionStatement,
Identifier,
JSXAttribute,
JSXExpressionContainer,
JSXOpeningElement,
JSXSpreadAttribute,
ObjectExpression,
ObjectProperty,
StringLiteral,
Expression,
} from '@babel/types';
import {stringifyDefaultProps} from '@remotion/studio-shared';
import type {ExpressionKind} from 'ast-types/lib/gen/kinds';
import * as recast from 'recast';
import {parseAst} from './sequence-props/parse-ast';
const b = recast.types.builders;
export const parseValueExpression = (value: unknown): ExpressionKind => {
return (
(
parseAst(`a = ${stringifyDefaultProps({props: value, enumPaths: []})}`)
.program.body[0] as unknown as ExpressionStatement
).expression as AssignmentExpression
).right as ExpressionKind;
};
const findJsxAttribute = (
attributes: (JSXAttribute | JSXSpreadAttribute)[],
name: string,
): {attrIndex: number; attr: JSXAttribute | undefined} => {
const attrIndex = attributes.findIndex((a) => {
if (a.type === 'JSXSpreadAttribute') {
return false;
}
if (a.name.type === 'JSXNamespacedName') {
return false;
}
return a.name.name === name;
});
const found = attrIndex !== -1 ? attributes[attrIndex] : undefined;
return {
attrIndex,
attr:
found && found.type === 'JSXAttribute'
? (found as JSXAttribute)
: undefined,
};
};
const findObjectProperty = (
objExpr: ObjectExpression,
propertyName: string,
): {propIndex: number; prop: ObjectProperty | undefined} => {
const propIndex = objExpr.properties.findIndex(
(p) =>
p.type === 'ObjectProperty' &&
(((p as ObjectProperty).key.type === 'Identifier' &&
((p as ObjectProperty).key as Identifier).name === propertyName) ||
((p as ObjectProperty).key.type === 'StringLiteral' &&
((p as ObjectProperty).key as StringLiteral).value === propertyName)),
);
return {
propIndex,
prop:
propIndex !== -1
? (objExpr.properties[propIndex] as ObjectProperty)
: undefined,
};
};
const getObjectExpression = (attr: JSXAttribute): ObjectExpression | null => {
const {value} = attr;
if (!value || value.type !== 'JSXExpressionContainer') {
return null;
}
const container = value as JSXExpressionContainer;
if (container.expression.type !== 'ObjectExpression') {
return null;
}
return container.expression as ObjectExpression;
};
const getOldValueString = ({
attr,
childKey,
defaultValue,
}: {
attr: JSXAttribute | undefined;
childKey: string;
defaultValue: unknown | null;
}): string => {
if (attr) {
const objExpr = getObjectExpression(attr);
if (objExpr) {
const {prop} = findObjectProperty(objExpr, childKey);
if (prop) {
return recast.print(prop.value).code;
}
}
}
if (defaultValue !== null) {
return JSON.stringify(defaultValue);
}
return '';
};
const removeNestedProp = ({
attr,
attrIndex,
attributes,
childKey,
}: {
attr: JSXAttribute | undefined;
attrIndex: number;
attributes: (JSXAttribute | JSXSpreadAttribute)[];
childKey: string;
}) => {
if (!attr) {
return;
}
const objExpr = getObjectExpression(attr);
if (!objExpr) {
return;
}
const {propIndex} = findObjectProperty(objExpr, childKey);
if (propIndex !== -1) {
objExpr.properties.splice(propIndex, 1);
}
if (objExpr.properties.length === 0 && attrIndex !== -1) {
attributes.splice(attrIndex, 1);
}
};
const setNestedProp = ({
attr,
attributes,
parentKey,
childKey,
value,
createValueExpression,
}: {
attr: JSXAttribute | undefined;
attributes: (JSXAttribute | JSXSpreadAttribute)[];
parentKey: string;
childKey: string;
value: unknown;
createValueExpression:
| ((existing: Expression | null) => ExpressionKind)
| null;
}) => {
if (attr) {
const objExpr = getObjectExpression(attr);
if (objExpr) {
const {prop} = findObjectProperty(objExpr, childKey);
const parsedValue = createValueExpression
? createValueExpression((prop?.value as Expression | undefined) ?? null)
: parseValueExpression(value);
if (prop) {
prop.value = parsedValue as ObjectExpression | ArrayExpression;
} else {
objExpr.properties.push(
b.objectProperty(
b.identifier(childKey),
parsedValue,
) as ObjectProperty,
);
}
}
} else {
const parsedValue = createValueExpression
? createValueExpression(null)
: parseValueExpression(value);
const objExpr = b.objectExpression([
b.objectProperty(b.identifier(childKey), parsedValue),
]);
const newAttr = b.jsxAttribute(
b.jsxIdentifier(parentKey),
b.jsxExpressionContainer(objExpr),
);
attributes.push(newAttr as JSXAttribute | JSXSpreadAttribute);
}
};
export const updateNestedProp = ({
node,
parentKey,
childKey,
value,
defaultValue,
isDefault,
createValueExpression,
}: {
node: JSXOpeningElement;
parentKey: string;
childKey: string;
value: unknown;
defaultValue: unknown | null;
isDefault: boolean;
createValueExpression:
| ((existing: Expression | null) => ExpressionKind)
| null;
}): string => {
if (!node.attributes) {
node.attributes = [];
}
const {attributes} = node;
const {attrIndex, attr} = findJsxAttribute(attributes, parentKey);
const oldValueString = getOldValueString({attr, childKey, defaultValue});
if (isDefault) {
removeNestedProp({attr, attrIndex, attributes, childKey});
} else {
setNestedProp({
attr,
attributes,
parentKey,
childKey,
value,
createValueExpression,
});
}
return oldValueString;
};