🎥 Make videos programmatically with React
import {execSync} from 'node:child_process';
import fs, {rmSync} from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import {VERSION} from 'remotion/version';
import {chalk} from './chalk';
import {findRemotionRoot} from './find-closest-package-json';
import {isServeUrl} from './is-serve-url';
import type {LogLevel} from './log-level';
import {Log} from './logger';
const REPRO_DIR = '.remotionrepro';
const LOG_FILE_NAME = 'logs.txt';
const INPUT_DIR = 'bundle';
const OUTPUT_DIR = 'output';
const LINE_SPLIT = '\n';
const getZipFileName = (name: string) =>
`remotion-repro-${name}-${Date.now()}.zip`;
const readyDirSync = (dir: string) => {
let items;
try {
items = fs.readdirSync(dir);
} catch {
return fs.mkdirSync(dir, {recursive: true});
}
items.forEach((item) => {
item = path.join(dir, item);
fs.rmSync(item, {recursive: true, force: true});
});
};
const zipFolder = ({
sourceFolder,
targetZip,
indent,
logLevel,
}: {
sourceFolder: string;
targetZip: string;
indent: boolean;
logLevel: LogLevel;
}) => {
const platform = os.platform();
try {
Log.info({indent, logLevel}, '+ Creating reproduction ZIP');
if (platform === 'win32') {
execSync(
`powershell.exe Compress-Archive -Path "${sourceFolder}" -DestinationPath "${targetZip}"`,
);
} else {
execSync(`zip -r "${targetZip}" "${sourceFolder}"`);
}
rmSync(sourceFolder, {recursive: true});
Log.info({indent, logLevel}, `${chalk.blue(`+ Repro: ${targetZip}`)}`);
} catch (error) {
Log.error(
{indent, logLevel},
`Failed to zip repro folder, The repro folder is ${sourceFolder}. You can try manually zip it.`,
);
Log.error({indent, logLevel}, error);
}
};
type ReproWriter = {
start: (options: {
serveUrl: string;
serializedInputPropsWithCustomSchema: string;
serializedResolvedPropsWithCustomSchema: string;
}) => void;
writeLine: (level: string, ...args: Parameters<typeof console.log>[]) => void;
onRenderSucceed: (options: {
output: string | null;
logLevel: LogLevel;
indent: boolean;
}) => Promise<void>;
};
const reproWriter = (name: string): ReproWriter => {
const root = findRemotionRoot();
const reproFolder = path.join(root, REPRO_DIR);
const logPath = path.join(reproFolder, LOG_FILE_NAME);
const zipFile = path.join(root, getZipFileName(name));
readyDirSync(reproFolder);
const reproLogWriteStream = fs.createWriteStream(logPath, {flags: 'a'});
const serializeArgs = (args: Parameters<typeof console.log>[]) =>
JSON.stringify(args);
const writeLine = (
level: string,
...args: Parameters<typeof console.log>[]
) => {
if (!args.length) return;
const startTime = new Date().toISOString();
const line = `[${startTime}] ${level} ${serializeArgs(args)}`;
reproLogWriteStream.write(line + LINE_SPLIT);
};
const start = ({
serveUrl,
serializedInputPropsWithCustomSchema,
serializedResolvedPropsWithCustomSchema,
}: {
serveUrl: string;
serializedInputPropsWithCustomSchema: string;
serializedResolvedPropsWithCustomSchema: string;
}) => {
const isServe = isServeUrl(serveUrl);
if (!isServe) {
const inputDir = path.resolve(reproFolder, INPUT_DIR);
readyDirSync(inputDir);
fs.cpSync(serveUrl, inputDir, {recursive: true});
}
const serializedProps = path.resolve(reproFolder, 'input-props.json');
fs.writeFileSync(serializedProps, serializedInputPropsWithCustomSchema);
const serializedResolvedProps = path.resolve(
reproFolder,
'resolved-props.json',
);
fs.writeFileSync(
serializedResolvedProps,
serializedResolvedPropsWithCustomSchema,
);
writeLine('info', [`Args: ${JSON.stringify(process.argv)}`]);
writeLine('info', [`Node/Bun version: ${process.version}`]);
writeLine('info', [`OS: ${process.platform}-${process.arch}`]);
writeLine('info', [`Serve URL: ${serveUrl}`]);
writeLine('info', [`Remotion version: ${VERSION}`]);
};
const onRenderSucceed = ({
indent,
logLevel,
output,
}: {
output: string | null;
logLevel: LogLevel;
indent: boolean;
}) => {
return new Promise<void>((resolve, reject) => {
try {
if (output) {
const outputDir = path.resolve(reproFolder, OUTPUT_DIR);
readyDirSync(outputDir);
const fileName = path.basename(output);
const targetPath = path.join(outputDir, fileName);
fs.copyFileSync(output, targetPath);
}
disableRepro();
reproLogWriteStream.end(() => {
reproLogWriteStream.close(() => {
zipFolder({
sourceFolder: reproFolder,
targetZip: zipFile,
indent,
logLevel,
});
resolve();
});
});
} catch (error) {
Log.error({indent: false, logLevel}, `repro render success error:`);
Log.error({indent: false, logLevel}, error);
reject(error);
}
});
};
return {
start,
writeLine,
onRenderSucceed,
};
};
let reproWriteInstance: ReturnType<typeof reproWriter> | null = null;
export const getReproWriter = () => {
if (!reproWriteInstance) {
throw new Error('reproWriteInstance is not initialized');
}
return reproWriteInstance;
};
export const writeInRepro = (
level: string,
...args: Parameters<typeof console.log>
) => {
if (isReproEnabled()) {
getReproWriter().writeLine(level, ...args);
}
};
let shouldRepro = false;
export const enableRepro = ({
serveUrl,
compositionName,
serializedInputPropsWithCustomSchema,
serializedResolvedPropsWithCustomSchema,
}: {
serveUrl: string;
compositionName: string;
serializedInputPropsWithCustomSchema: string;
serializedResolvedPropsWithCustomSchema: string;
}) => {
shouldRepro = true;
reproWriteInstance = reproWriter(compositionName);
getReproWriter().start({
serveUrl,
serializedInputPropsWithCustomSchema,
serializedResolvedPropsWithCustomSchema,
});
};
export const disableRepro = () => {
shouldRepro = false;
};
export const isReproEnabled = () => shouldRepro;