🎥 Make videos programmatically with React
import type {File} from '@babel/types';
import type {ExpressionKind} from 'ast-types/lib/gen/kinds';
import * as recast from 'recast';
export type VisualControlValueFromCode = {
id: string;
value: unknown;
isUndefined: boolean;
};
const getStringValue = (
node: ExpressionKind | recast.types.namedTypes.SpreadElement,
): string | null => {
if (node.type === 'StringLiteral') {
return (node as unknown as {value: string}).value;
}
if (node.type === 'TemplateLiteral') {
const tl = node as unknown as {
expressions: unknown[];
quasis: Array<{value: {raw: string}}>;
};
if (tl.expressions.length > 0) {
return null;
}
return tl.quasis[0].value.raw;
}
return null;
};
const evaluateExpression = (node: ExpressionKind): unknown => {
switch (node.type) {
case 'NumericLiteral':
return (node as unknown as {value: number}).value;
case 'StringLiteral':
return (node as unknown as {value: string}).value;
case 'BooleanLiteral':
return (node as unknown as {value: boolean}).value;
case 'NullLiteral':
return null;
case 'Identifier': {
const {name} = node as unknown as {name: string};
if (name === 'undefined') {
return undefined;
}
throw new Error(`Cannot evaluate identifier: ${name}`);
}
case 'UnaryExpression': {
const unary = node as unknown as {
operator: string;
argument: ExpressionKind;
};
if (unary.operator === '-') {
const arg = evaluateExpression(unary.argument);
if (typeof arg === 'number') {
return -arg;
}
}
if (unary.operator === '+') {
const arg = evaluateExpression(unary.argument);
if (typeof arg === 'number') {
return arg;
}
}
throw new Error(`Cannot evaluate unary: ${unary.operator}`);
}
case 'ObjectExpression': {
const obj: Record<string, unknown> = {};
const {properties} = node as unknown as {
properties: Array<{
type: string;
key: {type: string; name?: string; value?: string | number};
value: ExpressionKind;
}>;
};
for (const prop of properties) {
if (prop.type !== 'ObjectProperty') {
continue;
}
let key: string | null = null;
if (prop.key.type === 'Identifier') {
key = prop.key.name as string;
} else if (prop.key.type === 'StringLiteral') {
key = prop.key.value as string;
} else if (prop.key.type === 'NumericLiteral') {
key = String(prop.key.value);
}
if (key !== null) {
obj[key] = evaluateExpression(prop.value);
}
}
return obj;
}
case 'ArrayExpression': {
const {elements} = node as unknown as {
elements: Array<ExpressionKind | null>;
};
return elements.map((el) => {
if (el === null) {
return null;
}
return evaluateExpression(el);
});
}
case 'TemplateLiteral': {
const tl = node as unknown as {
expressions: unknown[];
quasis: Array<{value: {cooked: string}}>;
};
if (tl.expressions.length === 0) {
return tl.quasis[0].value.cooked;
}
throw new Error('Cannot evaluate template literal with expressions');
}
default:
throw new Error(`Cannot evaluate AST node: ${node.type}`);
}
};
export const readVisualControlValues = (
file: File,
): VisualControlValueFromCode[] => {
const values: VisualControlValueFromCode[] = [];
recast.types.visit(file.program, {
visitCallExpression(path) {
const {node} = path;
if (
node.callee.type !== 'Identifier' ||
(node.callee as unknown as {name: string}).name !== 'visualControl'
) {
return this.traverse(path);
}
const firstArg = node.arguments[0];
const id = getStringValue(
firstArg as ExpressionKind | recast.types.namedTypes.SpreadElement,
);
if (id === null) {
return this.traverse(path);
}
if (node.arguments.length < 2) {
return this.traverse(path);
}
const valueNode = node.arguments[1] as ExpressionKind;
try {
if (
valueNode.type === 'Identifier' &&
(valueNode as unknown as {name: string}).name === 'undefined'
) {
values.push({id, value: null, isUndefined: true});
} else {
values.push({
id,
value: evaluateExpression(valueNode),
isUndefined: false,
});
}
} catch {
// Skip values we can't evaluate statically
}
return this.traverse(path);
},
});
return values;
};