🎥 Make videos programmatically with React
import {existsSync} from "node:fs";
import {cp, mkdir} from "node:fs/promises";
import path from "node:path";
import {ensureBrowser} from "@remotion/renderer";
import {VitePlugin} from "@electron-forge/plugin-vite";
import {getCompositorPackage} from "./src/compositor-package";
import {getPackagedBrowserPaths} from "./src/packaged-browser";
import {bundleRemotionProject, getPrebuiltRemotionBundlePath} from "./src/remotion-bundle";
const DARWIN_COMPOSITOR_PACKAGES = [
"@remotion/compositor-darwin-x64",
"@remotion/compositor-darwin-arm64",
];
const PACKAGE_BROWSER_ENV_VAR = "REMOTION_ELECTRON_PACKAGE_BROWSER";
const shouldPackageBrowser = process.env[PACKAGE_BROWSER_ENV_VAR] === "true";
const DARWIN_UNIVERSAL_ARCH_FILES =
"Contents/Resources/app.asar.unpacked/node_modules/@remotion/compositor-darwin-*/**";
function getCompositorPackagesForPackaging({
arch,
platform,
}: {
arch: string;
platform: string;
}): string[] {
if (platform === "darwin") {
return DARWIN_COMPOSITOR_PACKAGES;
}
return [getCompositorPackage({arch, platform})];
}
function isMissingPackageError(error: unknown): error is NodeJS.ErrnoException {
return (
error instanceof Error && "code" in error && error.code === "MODULE_NOT_FOUND"
);
}
function shouldAllowMissingCompositorPackage({
arch,
compositorPackage,
platform,
}: {
arch: string;
compositorPackage: string;
platform: string;
}): boolean {
if (platform !== "darwin" || arch === "universal") {
return false;
}
return compositorPackage !== getCompositorPackage({arch, platform});
}
function resolveInstalledCompositorPackageDirectory({
allowMissing,
compositorPackage,
}: {
allowMissing: boolean;
compositorPackage: string;
}): string | null {
try {
const compositorPackageJson = require.resolve(`${compositorPackage}/package.json`, {
paths: [process.cwd()],
});
return path.dirname(compositorPackageJson);
} catch (error: unknown) {
if (allowMissing && isMissingPackageError(error)) {
return null;
}
throw error;
}
}
async function stageCompositorPackages({
arch,
buildPath,
platform,
}: {
arch: string;
buildPath: string;
platform: string;
}): Promise<void> {
const compositorPackages = getCompositorPackagesForPackaging({
arch,
platform,
});
for (const compositorPackage of compositorPackages) {
const compositorSource = resolveInstalledCompositorPackageDirectory({
allowMissing: shouldAllowMissingCompositorPackage({
arch,
compositorPackage,
platform,
}),
compositorPackage,
});
if (!compositorSource) {
continue;
}
const compositorDestination = path.join(
buildPath,
"node_modules",
compositorPackage,
);
await mkdir(path.dirname(compositorDestination), {recursive: true});
await cp(compositorSource, compositorDestination, {recursive: true});
}
}
export async function stageBrowser({
arch,
buildPath,
platform,
}: {
arch: string;
buildPath: string;
platform: string;
}): Promise<void> {
const browserPaths = getPackagedBrowserPaths({
arch,
buildPath,
platform,
projectRoot: process.cwd(),
});
if (!browserPaths) {
return;
}
await ensureBrowser();
if (!existsSync(browserPaths.downloadedBrowserFolder)) {
return;
}
if (!browserPaths.packagedBrowserCopyDestination) {
return;
}
await mkdir(path.dirname(browserPaths.packagedBrowserCopyDestination), {
recursive: true,
});
await cp(
browserPaths.downloadedBrowserFolder,
browserPaths.packagedBrowserCopyDestination,
{recursive: true},
);
}
const config = {
packagerConfig: {
asar: {
unpackDir: shouldPackageBrowser
? "{node_modules/@remotion/compositor-*,remotion-browser}"
: "node_modules/@remotion/compositor-*",
},
osxUniversal: {
// These compositor binaries are already architecture-specific and should not be
// merged with lipo during universal packaging.
x64ArchFiles: DARWIN_UNIVERSAL_ARCH_FILES,
},
},
rebuildConfig: {},
hooks: {
packageAfterCopy: async (
_forgeConfig: unknown,
buildPath: string,
_electronVersion: string,
platform: string,
arch: string,
) => {
await bundleRemotionProject({
projectRoot: process.cwd(),
outDir: getPrebuiltRemotionBundlePath(buildPath),
});
// Set REMOTION_ELECTRON_PACKAGE_BROWSER=true to package Chrome Headless
// Shell into the app. This increases the final app size significantly, but
// packaged renders can run completely offline.
// IMPORTANT: This is not supported for macOS universal builds.
// `ensureBrowser()` only downloads a browser for the current architecture,
// so the other packaged architecture would not get an offline browser.
// For universal builds, prefer calling `ensureBrowser()` at runtime instead.
if (shouldPackageBrowser) {
await stageBrowser({
arch,
buildPath,
platform,
});
}
// Electron Forge's Vite packaging does not materialize this optional runtime binary
// into the packaged app automatically, so stage the required compositor packages explicitly.
await stageCompositorPackages({
arch,
buildPath,
platform,
});
},
},
plugins: [
new VitePlugin({
build: [
{
entry: "src/main.ts",
config: "vite.main.config.ts",
target: "main",
},
{
entry: "src/preload.ts",
config: "vite.preload.config.ts",
target: "preload",
},
],
renderer: [
{
name: "main_window",
config: "vite.renderer.config.ts",
},
],
}),
],
};
export default config;