@remotion/cli 3.3.87 → 3.3.89

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

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsubscribeClientFileExistenceWatchers = exports.unsubscribeFromFileExistenceWatchers = exports.subscribeToFileExistenceWatchers = void 0;
+const path_1 = __importDefault(require("path"));
+const file_watcher_1 = require("../file-watcher");
+const live_events_1 = require("./live-events");
+const fileExistenceWatchers = {};
+const subscribeToFileExistenceWatchers = ({ file: relativeFile, remotionRoot, clientId, }) => {
+    const file = path_1.default.resolve(remotionRoot, relativeFile);
+    const { unwatch, exists } = (0, file_watcher_1.installFileWatcher)({
+        file,
+        onChange: (type) => {
+            if (type === 'created') {
+                (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+                    listener.sendEventToClient({
+                        type: 'watched-file-undeleted',
+                        // Must be relative file because that's what the client expects
+                        file: relativeFile,
+                    });
+                });
+            }
+            if (type === 'deleted') {
+                (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+                    listener.sendEventToClient({
+                        type: 'watched-file-deleted',
+                        // Must be relative file because that's what the client expects
+                        file: relativeFile,
+                    });
+                });
+            }
+        },
+    });
+    if (!fileExistenceWatchers[clientId]) {
+        fileExistenceWatchers[clientId] = {};
+    }
+    fileExistenceWatchers[clientId][file] = unwatch;
+    return { exists };
+};
+exports.subscribeToFileExistenceWatchers = subscribeToFileExistenceWatchers;
+const unsubscribeFromFileExistenceWatchers = ({ file, remotionRoot, clientId, }) => {
+    var _a, _b;
+    const actualPath = path_1.default.resolve(remotionRoot, file);
+    if (!fileExistenceWatchers[clientId]) {
+        return;
+    }
+    (_b = (_a = fileExistenceWatchers[clientId])[actualPath]) === null || _b === void 0 ? void 0 : _b.call(_a);
+    delete fileExistenceWatchers[clientId][actualPath];
+};
+exports.unsubscribeFromFileExistenceWatchers = unsubscribeFromFileExistenceWatchers;
+const unsubscribeClientFileExistenceWatchers = (clientId) => {
+    if (!fileExistenceWatchers[clientId]) {
+        return;
+    }
+    Object.values(fileExistenceWatchers[clientId]).forEach((unwatch) => {
+        unwatch();
+    });
+    delete fileExistenceWatchers[clientId];
+};
+exports.unsubscribeClientFileExistenceWatchers = unsubscribeClientFileExistenceWatchers;

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/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/render-queue/get-default-video-contexts.d.ts

@@ -0,0 +1,10 @@
+import type { Codec } from '@remotion/renderer';
+import type { RenderType } from '../../editor/components/RenderModal/RenderModalAdvanced';
+export declare const getDefaultCodecs: ({ defaultCodec, isStill, }: {
+    defaultCodec: Codec;
+    isStill: boolean;
+}) => {
+    initialAudioCodec: Codec;
+    initialVideoCodec: Codec;
+    initialRenderType: RenderType;
+};

package/dist/preview-server/render-queue/get-default-video-contexts.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultCodecs = void 0;
+const client_1 = require("@remotion/renderer/client");
+const getDefaultCodecs = ({ defaultCodec, isStill, }) => {
+    const isAudioCodec = client_1.BrowserSafeApis.isAudioCodec(defaultCodec);
+    return {
+        initialAudioCodec: isAudioCodec ? defaultCodec : 'mp3',
+        initialVideoCodec: isAudioCodec ? 'h264' : defaultCodec,
+        initialRenderType: isStill ? 'still' : isAudioCodec ? 'audio' : 'video',
+    };
+};
+exports.getDefaultCodecs = getDefaultCodecs;

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

@@ -0,0 +1,138 @@
+import type { AudioCodec, Codec, makeCancelSignal, PixelFormat, ProResProfile, StillImageFormat, VideoImageFormat } from '@remotion/renderer';
+import type { AggregateRenderProgress } from '../../progress-types';
+import type { RequiredChromiumOptions } from '../../required-chromium-options';
+declare type BaseRenderProgress = {
+    message: string;
+    value: number;
+};
+declare type RenderJobDynamicStatus = {
+    status: 'done';
+    progress: BaseRenderProgress & AggregateRenderProgress;
+} | {
+    status: 'running';
+    progress: BaseRenderProgress & AggregateRenderProgress;
+} | {
+    status: 'idle';
+} | {
+    status: 'failed';
+    error: {
+        message: string;
+        stack: string | undefined;
+    };
+};
+export declare type JobProgressCallback = (options: BaseRenderProgress & AggregateRenderProgress) => void;
+declare type RenderJobDynamicFields = ({
+    type: 'still';
+    imageFormat: StillImageFormat;
+    jpegQuality: number | null;
+    frame: number;
+    scale: number;
+} & RenderJobDynamicStatus) | ({
+    type: 'video';
+    imageFormat: VideoImageFormat;
+    jpegQuality: number | null;
+    scale: number;
+    codec: Codec;
+    audioCodec: AudioCodec;
+    concurrency: number;
+    crf: number | null;
+    startFrame: number;
+    endFrame: number;
+    muted: boolean;
+    enforceAudioTrack: boolean;
+    proResProfile: ProResProfile | null;
+    pixelFormat: PixelFormat;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    disallowParallelEncoding: boolean;
+} & RenderJobDynamicStatus);
+export declare type RenderJob = {
+    startedAt: number;
+    compositionId: string;
+    id: string;
+    outName: string;
+    deletedOutputLocation: boolean;
+    verbose: boolean;
+    delayRenderTimeout: number;
+    cancelToken: ReturnType<typeof makeCancelSignal>;
+    chromiumOptions: RequiredChromiumOptions;
+    envVariables: Record<string, string>;
+    inputProps: unknown;
+} & RenderJobDynamicFields;
+export declare type RenderJobWithCleanup = RenderJob & {
+    cleanup: (() => void)[];
+};
+declare type AddRenderRequestDynamicFields = {
+    type: 'still';
+    imageFormat: StillImageFormat;
+    jpegQuality: number | null;
+    frame: number;
+    scale: number;
+    verbose: boolean;
+} | {
+    type: 'video';
+    codec: Codec;
+    audioCodec: AudioCodec;
+    imageFormat: VideoImageFormat;
+    jpegQuality: number | null;
+    scale: number;
+    verbose: boolean;
+    concurrency: number;
+    crf: number | null;
+    startFrame: number;
+    endFrame: number;
+    muted: boolean;
+    enforceAudioTrack: boolean;
+    proResProfile: ProResProfile | null;
+    pixelFormat: PixelFormat;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    disallowParallelEncoding: boolean;
+};
+export declare type CancelRenderRequest = {
+    jobId: string;
+};
+export declare type CancelRenderResponse = {};
+export declare type AddRenderRequest = {
+    compositionId: string;
+    outName: string;
+    chromiumOptions: RequiredChromiumOptions;
+    delayRenderTimeout: number;
+    envVariables: Record<string, string>;
+    inputProps: unknown;
+} & 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 declare type UpdateDefaultPropsRequest = {
+    compositionId: string;
+    defaultProps: string;
+};
+export declare type CanUpdateDefaultPropsRequest = {
+    compositionId: string;
+};
+export declare type CanUpdateDefaultPropsResponse = {
+    canUpdate: true;
+} | {
+    canUpdate: false;
+    reason: 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,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRetryPayload = void 0;
+const get_default_video_contexts_1 = require("./get-default-video-contexts");
+const makeRetryPayload = (job) => {
+    var _a, _b, _c;
+    const defaults = window.remotion_renderDefaults;
+    if (!defaults) {
+        throw new Error('defaults not set');
+    }
+    if (job.type === 'still') {
+        const { initialAudioCodec, initialRenderType, initialVideoCodec } = (0, get_default_video_contexts_1.getDefaultCodecs)({
+            defaultCodec: defaults.codec,
+            isStill: true,
+        });
+        return {
+            type: 'render',
+            compositionId: job.compositionId,
+            initialFrame: job.frame,
+            initialStillImageFormat: job.imageFormat,
+            initialVideoImageFormat: defaults.videoImageFormat,
+            initialJpegQuality: (_a = job.jpegQuality) !== null && _a !== void 0 ? _a : defaults.jpegQuality,
+            initialOutName: job.outName,
+            initialScale: job.scale,
+            initialVerbose: job.verbose,
+            initialVideoCodecForAudioTab: initialAudioCodec,
+            initialRenderType,
+            initialVideoCodecForVideoTab: initialVideoCodec,
+            initialConcurrency: defaults.concurrency,
+            maxConcurrency: defaults.maxConcurrency,
+            minConcurrency: defaults.minConcurrency,
+            initialMuted: defaults.muted,
+            initialEnforceAudioTrack: defaults.enforceAudioTrack,
+            initialProResProfile: defaults.proResProfile,
+            initialPixelFormat: defaults.pixelFormat,
+            initialAudioBitrate: defaults.audioBitrate,
+            initialVideoBitrate: defaults.videoBitrate,
+            initialEveryNthFrame: defaults.everyNthFrame,
+            initialNumberOfGifLoops: defaults.numberOfGifLoops,
+            initialDelayRenderTimeout: job.delayRenderTimeout,
+            initialAudioCodec: defaults.audioCodec,
+            initialEnvVariables: job.envVariables,
+            initialDisableWebSecurity: job.chromiumOptions.disableWebSecurity,
+            initialOpenGlRenderer: job.chromiumOptions.gl,
+            initialHeadless: job.chromiumOptions.headless,
+            initialIgnoreCertificateErrors: job.chromiumOptions.ignoreCertificateErrors,
+            defaultProps: job.inputProps,
+        };
+    }
+    if (job.type === 'video') {
+        const { initialAudioCodec, initialRenderType, initialVideoCodec } = (0, get_default_video_contexts_1.getDefaultCodecs)({
+            defaultCodec: defaults.codec,
+            isStill: false,
+        });
+        return {
+            type: 'render',
+            compositionId: job.compositionId,
+            initialStillImageFormat: defaults.stillImageFormat,
+            initialVideoImageFormat: job.imageFormat,
+            initialJpegQuality: (_b = job.jpegQuality) !== null && _b !== void 0 ? _b : defaults.jpegQuality,
+            initialOutName: job.outName,
+            initialScale: job.scale,
+            initialVerbose: job.verbose,
+            initialFrame: 0,
+            initialConcurrency: job.concurrency,
+            maxConcurrency: defaults.maxConcurrency,
+            minConcurrency: defaults.minConcurrency,
+            initialMuted: job.muted,
+            initialVideoCodecForAudioTab: initialAudioCodec,
+            initialEnforceAudioTrack: job.enforceAudioTrack,
+            initialRenderType,
+            initialVideoCodecForVideoTab: initialVideoCodec,
+            initialProResProfile: (_c = job.proResProfile) !== null && _c !== void 0 ? _c : defaults.proResProfile,
+            initialPixelFormat: job.pixelFormat,
+            initialAudioBitrate: job.audioBitrate,
+            initialVideoBitrate: job.videoBitrate,
+            initialEveryNthFrame: job.everyNthFrame,
+            initialNumberOfGifLoops: job.numberOfGifLoops,
+            initialDelayRenderTimeout: job.delayRenderTimeout,
+            initialAudioCodec: job.audioCodec,
+            initialEnvVariables: job.envVariables,
+            initialDisableWebSecurity: job.chromiumOptions.disableWebSecurity,
+            initialOpenGlRenderer: job.chromiumOptions.gl,
+            initialHeadless: job.chromiumOptions.headless,
+            initialIgnoreCertificateErrors: job.chromiumOptions.ignoreCertificateErrors,
+            defaultProps: job.inputProps,
+        };
+    }
+    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, allowedDirectory: string) => Promise<void>;

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

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openDirectoryInFinder = void 0;
+const child_process_1 = require("child_process");
+const os_1 = require("os");
+const path_1 = __importDefault(require("path"));
+const truthy_1 = require("../../truthy");
+const openDirectoryInFinder = (dirToOpen, allowedDirectory) => {
+    const resolved = path_1.default.resolve(allowedDirectory, dirToOpen);
+    const relativeToProcessCwd = path_1.default.relative(allowedDirectory, resolved);
+    if (relativeToProcessCwd.startsWith('..')) {
+        throw new Error(`Not allowed to open ${relativeToProcessCwd}`);
+    }
+    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/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: () => void) => void;
+}) => Promise<void>;

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

@@ -0,0 +1,46 @@
+"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, 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: job.chromiumOptions,
+        entryPointReason: 'same as preview',
+        envVariables: job.envVariables,
+        height: null,
+        fullEntryPoint,
+        inputProps: job.inputProps,
+        overwrite: true,
+        port,
+        publicDir,
+        puppeteerTimeout,
+        jpegQuality: (_a = job.jpegQuality) !== null && _a !== void 0 ? _a : undefined,
+        remainingArgs: [],
+        scale: job.scale,
+        stillFrame: job.frame,
+        width: null,
+        compositionIdFromUi: job.compositionId,
+        imageFormatFromUi: job.imageFormat,
+        logLevel: job.verbose ? 'verbose' : 'info',
+        onProgress,
+        indentOutput: true,
+        addCleanupCallback,
+        cancelSignal: job.cancelToken.cancelSignal,
+    });
+};
+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: () => void) => void;
+}) => Promise<void>;

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processVideoJob = 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 render_1 = require("../../render-flows/render");
+const processVideoJob = async ({ job, remotionRoot, entryPoint, onProgress, addCleanupCallback, }) => {
+    var _a, _b;
+    if (job.type !== 'video') {
+        throw new Error('Expected video job');
+    }
+    const { publicDir, browserExecutable, port, browser, ffmpegOverride } = 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, render_1.renderVideoFlow)({
+        remotionRoot,
+        browser,
+        browserExecutable,
+        chromiumOptions: job.chromiumOptions,
+        entryPointReason: 'same as preview',
+        envVariables: job.envVariables,
+        height: null,
+        fullEntryPoint,
+        inputProps: job.inputProps,
+        overwrite: true,
+        port,
+        publicDir,
+        puppeteerTimeout: job.delayRenderTimeout,
+        jpegQuality: (_a = job.jpegQuality) !== null && _a !== void 0 ? _a : undefined,
+        remainingArgs: [],
+        scale: job.scale,
+        width: null,
+        compositionIdFromUi: job.compositionId,
+        logLevel: job.verbose ? 'verbose' : 'info',
+        onProgress,
+        indent: true,
+        concurrency: job.concurrency,
+        everyNthFrame: job.everyNthFrame,
+        frameRange: [job.startFrame, job.endFrame],
+        quiet: false,
+        shouldOutputImageSequence: false,
+        addCleanupCallback,
+        outputLocationFromUI: job.outName,
+        uiCodec: job.codec,
+        uiImageFormat: job.imageFormat,
+        cancelSignal: job.cancelToken.cancelSignal,
+        crf: job.crf,
+        ffmpegOverride,
+        audioBitrate: job.audioBitrate,
+        muted: job.muted,
+        enforceAudioTrack: job.enforceAudioTrack,
+        proResProfile: (_b = job.proResProfile) !== null && _b !== void 0 ? _b : undefined,
+        pixelFormat: job.pixelFormat,
+        videoBitrate: job.videoBitrate,
+        numberOfGifLoops: job.numberOfGifLoops,
+        audioCodec: job.audioCodec,
+        disallowParallelEncoding: job.disallowParallelEncoding,
+    });
+};
+exports.processVideoJob = processVideoJob;

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

@@ -0,0 +1,9 @@
+import type { RenderJob, RenderJobWithCleanup } from './job';
+export declare const getRenderQueue: () => RenderJob[];
+export declare const addJob: ({ job, entryPoint, remotionRoot, }: {
+    job: RenderJobWithCleanup;
+    entryPoint: string;
+    remotionRoot: string;
+}) => void;
+export declare const removeJob: (jobId: string) => void;
+export declare const cancelJob: (jobId: string) => void;