@remotion/cli 3.3.27 → 3.3.28

package/dist/preview-server/get-file-existence.d.ts

@@ -0,0 +1,2 @@
+export declare const subscribeToFileExistenceWatchers: (file: string) => void;
+export declare const unsubscribeToFileExistenceWatchers: (file: string) => void;

package/dist/preview-server/get-file-existence.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsubscribeToFileExistenceWatchers = exports.subscribeToFileExistenceWatchers = void 0;
+const file_watcher_1 = require("../file-watcher");
+const live_events_1 = require("./live-events");
+const fileExistenceWatchers = {};
+const subscribeToFileExistenceWatchers = (file) => {
+    fileExistenceWatchers[file] = (0, file_watcher_1.installFileWatcher)({
+        file,
+        onChange: (type) => {
+            if (type === 'created') {
+                (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+                    listener.sendEventToClient({
+                        type: 'watched-file-undeleted',
+                        file,
+                    });
+                });
+            }
+            if (type === 'deleted') {
+                (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+                    listener.sendEventToClient({
+                        type: 'watched-file-deleted',
+                        file,
+                    });
+                });
+            }
+        },
+    });
+};
+exports.subscribeToFileExistenceWatchers = subscribeToFileExistenceWatchers;
+const unsubscribeToFileExistenceWatchers = (file) => {
+    var _a;
+    (_a = fileExistenceWatchers[file]) === null || _a === void 0 ? void 0 : _a.call(fileExistenceWatchers);
+    delete fileExistenceWatchers[file];
+};
+exports.unsubscribeToFileExistenceWatchers = unsubscribeToFileExistenceWatchers;

package/dist/preview-server/get-files-in-public-folder.d.ts

@@ -0,0 +1,2 @@
+import type { StaticFile } from 'remotion';
+export declare const getFilesInPublicFolder: (publicFolder: string) => StaticFile[];

package/dist/preview-server/get-files-in-public-folder.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilesInPublicFolder = void 0;
+const getFilesInPublicFolder = (publicFolder) => {
+    return readRecursively({ folder: '.', startPath: publicFolder });
+};
+exports.getFilesInPublicFolder = getFilesInPublicFolder;

package/dist/preview-server/handler.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { ApiHandler } from './api-types';
+export declare const handleRequest: <Req, Res>({ remotionRoot, request, response, entryPoint, handler, }: {
+    remotionRoot: string;
+    request: IncomingMessage;
+    response: ServerResponse;
+    entryPoint: string;
+    handler: ApiHandler<Req, Res>;
+}) => Promise<void>;

package/dist/preview-server/handler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequest = void 0;
+const parse_body_1 = require("./parse-body");
+const handleRequest = async ({ remotionRoot, request, response, entryPoint, handler, }) => {
+    if (request.method === 'OPTIONS') {
+        response.statusCode = 200;
+        response.end();
+        return;
+    }
+    response.setHeader('content-type', 'application/json');
+    response.writeHead(200);
+    try {
+        const body = (await (0, parse_body_1.parseRequestBody)(request));
+        const outputData = await handler({
+            entryPoint,
+            remotionRoot,
+            request,
+            response,
+            input: body,
+        });
+        response.end(JSON.stringify({
+            success: true,
+            data: outputData,
+        }));
+    }
+    catch (err) {
+        response.end(JSON.stringify({
+            success: false,
+            error: err.message,
+        }));
+    }
+};
+exports.handleRequest = handleRequest;

package/dist/preview-server/live-event-listener.js

@@ -0,0 +1 @@
+"use strict";

package/dist/preview-server/parse-body.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingMessage } from 'http';
+export declare const parseRequestBody: (req: IncomingMessage) => Promise<unknown>;

package/dist/preview-server/parse-body.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRequestBody = void 0;
+const parseRequestBody = async (req) => {
+    const body = await new Promise((_resolve) => {
+        let data = '';
+        req.on('data', (chunk) => {
+            data += chunk;
+        });
+        req.on('end', () => {
+            _resolve(data.toString());
+        });
+    });
+    return JSON.parse(body);
+};
+exports.parseRequestBody = parseRequestBody;

package/dist/preview-server/public-folder.js

@@ -7,6 +7,7 @@ exports.getFiles = exports.watchPublicFolder = exports.fetchFolder = exports.ini
 const bundler_1 = require("@remotion/bundler");
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
+const env_supports_fs_recursive_1 = require("./env-supports-fs-recursive");
 let files = [];
 const initPublicFolderWatch = ({ publicDir, onUpdate, staticHash, }) => {
     (0, exports.fetchFolder)({ publicDir, staticHash });
@@ -43,7 +44,7 @@ const watchPublicFolder = ({ publicDir, onUpdate, staticHash, }) => {
         const watcher = (0, fs_1.watch)(parentDir, {}, onDirChange);
         return;
     }
-    (0, fs_1.watch)(publicDir, { recursive: true }, () => {
+    (0, fs_1.watch)(publicDir, { recursive: (0, env_supports_fs_recursive_1.envSupportsFsRecursive)() }, () => {
         (0, exports.fetchFolder)({ publicDir, staticHash });
         onUpdate();
     });

package/dist/preview-server/render-queue/add-render.d.ts

@@ -0,0 +1,3 @@
+import type { ApiHandler } from '../api-types';
+import type { AddRenderRequest } from './job';
+export declare const handleAddRender: ApiHandler<AddRenderRequest, undefined>;

package/dist/preview-server/render-queue/add-render.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAddRender = void 0;
+const path_1 = __importDefault(require("path"));
+const queue_1 = require("./queue");
+const handleAddRender = ({ input, entryPoint, remotionRoot, }) => {
+    if (input.type !== 'still') {
+        // TODO support composition rendering
+        throw new Error('Only still images are supported for now');
+    }
+    (0, queue_1.addJob)({
+        job: {
+            compositionId: input.compositionId,
+            id: String(Math.random()).replace('0.', ''),
+            startedAt: Date.now(),
+            type: 'still',
+            outputLocation: path_1.default.resolve(remotionRoot, input.outName),
+            status: 'idle',
+            imageFormat: input.imageFormat,
+            quality: input.quality,
+            frame: input.frame,
+            scale: input.scale,
+            cleanup: [],
+            deletedOutputLocation: false,
+        },
+        entryPoint,
+        remotionRoot,
+    });
+    return Promise.resolve(undefined);
+};
+exports.handleAddRender = handleAddRender;

package/dist/preview-server/render-queue/index.d.ts

@@ -0,0 +1,18 @@
+import type { RenderJob } from './job';
+export declare const getRenderQueue: () => RenderJob[];
+export declare const notifyClientsOfJobUpdate: () => void;
+export declare const processJob: ({ job, remotionRoot, entryPoint, }: {
+    job: RenderJob;
+    remotionRoot: string;
+    entryPoint: string;
+}) => Promise<never>;
+export declare const addJob: ({ job, entryPoint, remotionRoot, }: {
+    job: RenderJob;
+    entryPoint: string;
+    remotionRoot: string;
+}) => void;
+export declare const removeJob: (jobId: string) => void;
+export declare const processJobIfPossible: ({ remotionRoot, entryPoint, }: {
+    remotionRoot: string;
+    entryPoint: string;
+}) => Promise<void>;

package/dist/preview-server/render-queue/index.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processJobIfPossible = exports.removeJob = exports.addJob = exports.processJob = exports.notifyClientsOfJobUpdate = exports.getRenderQueue = void 0;
+const renderer_1 = require("@remotion/renderer");
+const config_1 = require("../../config");
+const get_cli_options_1 = require("../../get-cli-options");
+const setup_cache_1 = require("../../setup-cache");
+const live_events_1 = require("../live-events");
+let jobQueue = [];
+const updateJob = (id, updater) => {
+    jobQueue = jobQueue.map((j) => {
+        if (id === j.id) {
+            return updater(j);
+        }
+        return j;
+    });
+    (0, exports.notifyClientsOfJobUpdate)();
+};
+const getRenderQueue = () => {
+    return jobQueue;
+};
+exports.getRenderQueue = getRenderQueue;
+const notifyClientsOfJobUpdate = () => {
+    (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+        listener.sendEventToClient({
+            type: 'render-queue-updated',
+            queue: jobQueue,
+        });
+    });
+};
+exports.notifyClientsOfJobUpdate = notifyClientsOfJobUpdate;
+const processJob = async ({ job, remotionRoot, entryPoint, }) => {
+    if (job.type === 'still') {
+        const { publicDir, browserExecutable, ffmpegExecutable, ffprobeExecutable, chromiumOptions, envVariables, inputProps, port, scale, browser, puppeteerTimeout, } = await (0, get_cli_options_1.getCliOptions)({
+            isLambda: false,
+            type: 'get-compositions',
+            remotionRoot,
+        });
+        const browserInstance = (0, renderer_1.openBrowser)(browser, {
+            browserExecutable,
+            chromiumOptions,
+            shouldDumpIo: renderer_1.RenderInternals.isEqualOrBelowLogLevel(config_1.ConfigInternals.Logging.getLogLevel(), 'verbose'),
+            forceDeviceScaleFactor: scale,
+        });
+        const serveUrl = await (0, setup_cache_1.bundleOnCli)({
+            fullPath: entryPoint,
+            publicDir,
+            remotionRoot,
+            steps: ['bundling'],
+        });
+        const compositions = await (0, renderer_1.getCompositions)(serveUrl, {
+            browserExecutable,
+            chromiumOptions,
+            envVariables,
+            ffmpegExecutable,
+            ffprobeExecutable,
+            inputProps,
+            port,
+            puppeteerInstance: await browserInstance,
+            timeoutInMilliseconds: puppeteerTimeout,
+        });
+        const composition = compositions.find((c) => {
+            return c.id === job.compositionId;
+        });
+        if (!composition) {
+            throw new TypeError(`Composition ${job.compositionId} not found`);
+        }
+        await (0, renderer_1.renderStill)({
+            composition,
+            output: job.outputLocation,
+            serveUrl,
+            browserExecutable,
+            chromiumOptions,
+            envVariables,
+            ffmpegExecutable,
+            ffprobeExecutable,
+            scale,
+            timeoutInMilliseconds: puppeteerTimeout,
+            // TODO: Write download progress to CLI
+            overwrite: false,
+            // TODO: Allow user to overwrite file
+            port,
+            inputProps,
+            puppeteerInstance: await browserInstance,
+            // TODO: Allow to specify quality
+            // TODO: Allow to customize image format
+            imageFormat: 'png',
+            // TODO: Allow specific frame
+            // TODO: Allow cancel signal
+            // TODO: Accept CLI options
+        });
+    }
+    throw new TypeError(`Could not process job of type ${job.type}`);
+};
+exports.processJob = processJob;
+const addJob = ({ job, entryPoint, remotionRoot, }) => {
+    jobQueue.push(job);
+    (0, exports.processJobIfPossible)({ entryPoint, remotionRoot });
+    (0, exports.notifyClientsOfJobUpdate)();
+};
+exports.addJob = addJob;
+const removeJob = (jobId) => {
+    jobQueue = jobQueue.filter((job) => job.id !== jobId);
+    (0, exports.notifyClientsOfJobUpdate)();
+};
+exports.removeJob = removeJob;
+const processJobIfPossible = async ({ remotionRoot, entryPoint, }) => {
+    const nextJob = jobQueue.find((q) => {
+        return q.status === 'idle';
+    });
+    if (!nextJob) {
+        return;
+    }
+    try {
+        updateJob(nextJob.id, (job) => {
+            return {
+                ...job,
+                status: 'running',
+            };
+        });
+        await (0, exports.processJob)({ job: nextJob, entryPoint, remotionRoot });
+        updateJob(nextJob.id, (job) => {
+            return {
+                ...job,
+                status: 'done',
+            };
+        });
+    }
+    catch (err) {
+        updateJob(nextJob.id, (job) => {
+            return {
+                ...job,
+                status: 'failed',
+                error: err,
+            };
+        });
+        (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+            listener.sendEventToClient({
+                type: 'render-job-failed',
+                compositionId: nextJob.compositionId,
+                error: err,
+            });
+        });
+    }
+};
+exports.processJobIfPossible = processJobIfPossible;

package/dist/preview-server/render-queue/job.d.ts

@@ -0,0 +1,81 @@
+import type { Codec, StillImageFormat } from '@remotion/renderer';
+declare type RenderJobDynamicStatus = {
+    status: 'done';
+} | {
+    status: 'running';
+    progress: number;
+    message: string;
+} | {
+    status: 'idle';
+} | {
+    status: 'failed';
+    error: {
+        message: string;
+        stack: string | undefined;
+    };
+};
+export declare type JobProgressCallback = (options: {
+    progress: number;
+    message: string;
+}) => void;
+declare type RenderJobDynamicFields = {
+    type: 'still';
+    imageFormat: StillImageFormat;
+    quality: number | null;
+    frame: number;
+    scale: number;
+} | {
+    type: 'video';
+    imageFormat: StillImageFormat;
+    quality: number | null;
+    scale: number;
+    codec: Codec;
+};
+export declare type RenderJob = {
+    startedAt: number;
+    compositionId: string;
+    id: string;
+    outName: string;
+    deletedOutputLocation: boolean;
+    verbose: boolean;
+} & RenderJobDynamicStatus & RenderJobDynamicFields;
+export declare type RenderJobWithCleanup = RenderJob & {
+    cleanup: (() => void)[];
+};
+declare type AddRenderRequestDynamicFields = {
+    type: 'still';
+    imageFormat: StillImageFormat;
+    quality: number | null;
+    frame: number;
+    scale: number;
+    verbose: boolean;
+} | {
+    type: 'video';
+    codec: Codec;
+    imageFormat: StillImageFormat;
+    quality: number | null;
+    scale: number;
+    verbose: boolean;
+};
+export declare type AddRenderRequest = {
+    compositionId: string;
+    outName: string;
+} & AddRenderRequestDynamicFields;
+export declare type RemoveRenderRequest = {
+    jobId: string;
+};
+export declare type OpenInFileExplorerRequest = {
+    directory: string;
+};
+export declare type SubscribeToFileExistenceRequest = {
+    file: string;
+    clientId: string;
+};
+export declare type SubscribeToFileExistenceResponse = {
+    exists: boolean;
+};
+export declare type UnsubscribeFromFileExistenceRequest = {
+    file: string;
+    clientId: string;
+};
+export {};

package/dist/preview-server/render-queue/job.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/preview-server/render-queue/make-retry-payload.d.ts

@@ -0,0 +1,3 @@
+import type { RenderModalState } from '../../editor/state/modals';
+import type { RenderJob } from './job';
+export declare const makeRetryPayload: (job: RenderJob) => RenderModalState;

package/dist/preview-server/render-queue/make-retry-payload.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRetryPayload = void 0;
+const makeRetryPayload = (job) => {
+    if (job.type === 'still') {
+        return {
+            type: 'render',
+            compositionId: job.compositionId,
+            initialFrame: job.frame,
+            initialImageFormat: job.imageFormat,
+            initialQuality: job.quality,
+            initialOutName: job.outName,
+            initialScale: job.scale,
+            initialVerbose: job.verbose,
+        };
+    }
+    if (job.type === 'video') {
+        // TODO: Implement correct retry mechanism for video
+        return {
+            type: 'render',
+            compositionId: job.compositionId,
+            initialImageFormat: job.imageFormat,
+            initialQuality: job.quality,
+            initialOutName: job.outName,
+            initialScale: job.scale,
+            initialVerbose: job.verbose,
+            initialFrame: 0,
+        };
+    }
+    throw new Error(`Job ${JSON.stringify(job)} Not implemented`);
+};
+exports.makeRetryPayload = makeRetryPayload;

package/dist/preview-server/render-queue/open-directory-in-finder.d.ts

@@ -0,0 +1 @@
+export declare const openDirectoryInFinder: (dirToOpen: string) => Promise<void>;

package/dist/preview-server/render-queue/open-directory-in-finder.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openDirectoryInFinder = void 0;
+const child_process_1 = require("child_process");
+const os_1 = require("os");
+const truthy_1 = require("../../truthy");
+const openDirectoryInFinder = (dirToOpen) => {
+    const command = (0, os_1.platform)() === 'darwin'
+        ? 'open'
+        : (0, os_1.platform)() === 'linux'
+            ? 'xdg-open'
+            : 'start';
+    const p = (0, child_process_1.spawn)(command, [(0, os_1.platform)() === 'darwin' ? '-R' : null, dirToOpen].filter(truthy_1.truthy));
+    const stderrChunks = [];
+    p.stderr.on('data', (d) => stderrChunks.push(d));
+    return new Promise((resolve, reject) => {
+        p.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                const message = Buffer.concat(stderrChunks).toString('utf-8');
+                reject(new Error(message));
+            }
+        });
+        p.on('error', (err) => {
+            p.kill();
+            if (err) {
+                reject(err);
+            }
+        });
+    });
+};
+exports.openDirectoryInFinder = openDirectoryInFinder;

package/dist/preview-server/render-queue/open-in-file-explorer.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+export declare const handleOpenInFileExplorer: (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/dist/preview-server/render-queue/open-in-file-explorer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOpenInFileExplorer = void 0;
+const parse_body_1 = require("../parse-body");
+const open_directory_in_finder_1 = require("./open-directory-in-finder");
+const handleOpenInFileExplorer = async (req, res) => {
+    if (req.method === 'OPTIONS') {
+        res.statusCode = 200;
+        res.end();
+        return;
+    }
+    try {
+        const body = (await (0, parse_body_1.parseRequestBody)(req));
+        // TODO: Disallow opening file that is not in Remotion CWD
+        await (0, open_directory_in_finder_1.openDirectoryInFinder)(body.directory);
+        res.setHeader('content-type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify({
+            success: true,
+        }));
+    }
+    catch (err) {
+        res.setHeader('content-type', 'application/json');
+        res.writeHead(200);
+        res.end(JSON.stringify({
+            success: false,
+            error: err.message,
+        }));
+    }
+};
+exports.handleOpenInFileExplorer = handleOpenInFileExplorer;

package/dist/preview-server/render-queue/process-still.d.ts

@@ -0,0 +1,8 @@
+import type { JobProgressCallback, RenderJob } from './job';
+export declare const processStill: ({ job, remotionRoot, entryPoint, onProgress, addCleanupCallback, }: {
+    job: RenderJob;
+    remotionRoot: string;
+    entryPoint: string;
+    onProgress: JobProgressCallback;
+    addCleanupCallback: (cb: () => Promise<void>) => void;
+}) => Promise<void>;

package/dist/preview-server/render-queue/process-still.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processStill = void 0;
+const convert_entry_point_to_serve_url_1 = require("../../convert-entry-point-to-serve-url");
+const get_cli_options_1 = require("../../get-cli-options");
+const still_1 = require("../../render-flows/still");
+const processStill = async ({ job, remotionRoot, entryPoint, onProgress, addCleanupCallback, }) => {
+    var _a;
+    if (job.type !== 'still') {
+        throw new Error('Expected still job');
+    }
+    const { publicDir, browserExecutable, ffmpegExecutable, ffprobeExecutable, chromiumOptions, envVariables, inputProps, port, browser, puppeteerTimeout, } = await (0, get_cli_options_1.getCliOptions)({
+        isLambda: false,
+        type: 'still',
+        remotionRoot,
+    });
+    const fullEntryPoint = (0, convert_entry_point_to_serve_url_1.convertEntryPointToServeUrl)(entryPoint);
+    await (0, still_1.renderStillFlow)({
+        remotionRoot,
+        browser,
+        browserExecutable,
+        chromiumOptions,
+        entryPointReason: 'same as preview',
+        envVariables,
+        ffmpegExecutable,
+        ffprobeExecutable,
+        height: null,
+        fullEntryPoint,
+        inputProps,
+        overwrite: true,
+        port,
+        publicDir,
+        puppeteerTimeout,
+        quality: (_a = job.quality) !== null && _a !== void 0 ? _a : undefined,
+        remainingArgs: [],
+        scale: job.scale,
+        stillFrame: job.frame,
+        width: null,
+        compositionIdFromUi: job.compositionId,
+        imageFormatFromUi: job.imageFormat,
+        configFileImageFormat: undefined,
+        logLevel: job.verbose ? 'verbose' : 'info',
+        onProgress,
+        indentOutput: true,
+        addCleanupCallback,
+    });
+    // TODO: Allow cancel signal
+    // TODO: Accept CLI options
+};
+exports.processStill = processStill;

package/dist/preview-server/render-queue/process-video.d.ts

@@ -0,0 +1,8 @@
+import type { JobProgressCallback, RenderJob } from './job';
+export declare const processVideoJob: ({ job, remotionRoot, entryPoint, onProgress, addCleanupCallback, }: {
+    job: RenderJob;
+    remotionRoot: string;
+    entryPoint: string;
+    onProgress: JobProgressCallback;
+    addCleanupCallback: (cb: () => Promise<void>) => void;
+}) => Promise<void>;