@remotion/cli 3.2.27 → 3.2.29

package/dist/benchmark.d.ts

@@ -0,0 +1 @@
+export declare const benchmarkCommand: (remotionRoot: string, args: string[]) => Promise<void>;

package/dist/benchmark.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.benchmarkCommand = void 0;
+const renderer_1 = require("@remotion/renderer");
+const path_1 = __importDefault(require("path"));
+const chalk_1 = require("./chalk");
+const config_1 = require("./config");
+const get_cli_options_1 = require("./get-cli-options");
+const get_render_media_options_1 = require("./get-render-media-options");
+const log_1 = require("./log");
+const make_progress_bar_1 = require("./make-progress-bar");
+const parse_command_line_1 = require("./parse-command-line");
+const progress_bar_1 = require("./progress-bar");
+const setup_cache_1 = require("./setup-cache");
+const truthy_1 = require("./truthy");
+const DEFAULT_RUNS = 3;
+const getValidConcurrency = (renderMediaOptions) => {
+    var _a;
+    const concurrency = 'concurrency' in renderMediaOptions
+        ? (_a = renderMediaOptions.concurrency) !== null && _a !== void 0 ? _a : null
+        : null;
+    const { concurrencies } = parse_command_line_1.parsedCli;
+    if (!concurrencies) {
+        return [renderer_1.RenderInternals.getActualConcurrency(concurrency)];
+    }
+    return concurrencies
+        .split(',')
+        .map((c) => parseInt(c.trim(), 10));
+};
+const runBenchmark = async (runs, options, onProgress) => {
+    const timeTaken = [];
+    for (let run = 0; run < runs; ++run) {
+        const startTime = performance.now();
+        await (0, renderer_1.renderMedia)({
+            ...options,
+            onProgress: ({ progress }) => onProgress === null || onProgress === void 0 ? void 0 : onProgress(run, progress),
+        });
+        const endTime = performance.now();
+        timeTaken.push(endTime - startTime);
+    }
+    return timeTaken;
+};
+const formatTime = (time) => {
+    let ret = '';
+    const hours = Math.floor(time / (60 * 60 * 1000));
+    if (hours) {
+        ret = `${hours}h`;
+    }
+    time %= 60 * 60 * 1000;
+    const minutes = Math.floor(time / (60 * 1000));
+    if (minutes) {
+        ret = `${ret}${minutes}m`;
+    }
+    time %= 60 * 1000;
+    const seconds = (time / 1000).toFixed(5);
+    if (seconds) {
+        ret = `${ret}${seconds}s`;
+    }
+    return ret;
+};
+const avg = (time) => time.reduce((prev, curr) => prev + curr) / time.length;
+const stdDev = (time) => {
+    const mean = avg(time);
+    return Math.sqrt(time.map((x) => (x - mean) ** 2).reduce((a, b) => a + b) / time.length);
+};
+const getResults = (results, runs) => {
+    const mean = avg(results);
+    const dev = stdDev(results);
+    const max = Math.max(...results);
+    const min = Math.min(...results);
+    return `    Time (${chalk_1.chalk.green('mean')} ± ${chalk_1.chalk.green('σ')}):         ${chalk_1.chalk.green(formatTime(mean))} ± ${chalk_1.chalk.green(formatTime(dev))}\n    Range (${chalk_1.chalk.blue('min')} ... ${chalk_1.chalk.red('max')}):     ${chalk_1.chalk.blue(formatTime(min))} ... ${chalk_1.chalk.red(formatTime(max))} \t ${chalk_1.chalk.gray(`${runs} runs`)}
+	`;
+};
+const makeBenchmarkProgressBar = ({ totalRuns, run, progress, doneIn, }) => {
+    const totalProgress = (run + progress) / totalRuns;
+    return [
+        `Rendering (${run + 1} out of ${totalRuns} runs)`,
+        (0, make_progress_bar_1.makeProgressBar)(totalProgress),
+        doneIn === null
+            ? `${(totalProgress * 100).toFixed(2)}% `
+            : chalk_1.chalk.gray(doneIn),
+    ].join(' ');
+};
+const benchmarkCommand = async (remotionRoot, args) => {
+    var _a, _b;
+    const runs = (_a = parse_command_line_1.parsedCli.runs) !== null && _a !== void 0 ? _a : DEFAULT_RUNS;
+    const filePath = args[0];
+    if (!filePath) {
+        log_1.Log.error('No entry file passed.');
+        log_1.Log.info('Pass an additional argument specifying the entry file');
+        log_1.Log.info();
+        log_1.Log.info(`$ remotion benchmark <entry file>`);
+        process.exit(1);
+    }
+    const fullPath = path_1.default.join(process.cwd(), filePath);
+    const { inputProps, envVariables, browserExecutable, ffmpegExecutable, ffprobeExecutable, chromiumOptions, port, puppeteerTimeout, browser, scale, publicDir, } = await (0, get_cli_options_1.getCliOptions)({
+        isLambda: false,
+        type: 'series',
+        codec: 'h264',
+    });
+    const browserInstance = (0, renderer_1.openBrowser)(browser, {
+        browserExecutable,
+        shouldDumpIo: renderer_1.RenderInternals.isEqualOrBelowLogLevel(config_1.ConfigInternals.Logging.getLogLevel(), 'verbose'),
+        chromiumOptions,
+        forceDeviceScaleFactor: scale,
+    });
+    const { urlOrBundle: bundleLocation, cleanup: cleanupBundle } = await (0, setup_cache_1.bundleOnCliOrTakeServeUrl)({
+        fullPath,
+        publicDir,
+        remotionRoot,
+        steps: ['bundling'],
+    });
+    const puppeteerInstance = await browserInstance;
+    const comps = await (0, renderer_1.getCompositions)(bundleLocation, {
+        inputProps,
+        envVariables,
+        chromiumOptions,
+        timeoutInMilliseconds: puppeteerTimeout,
+        ffmpegExecutable,
+        ffprobeExecutable,
+        port,
+        puppeteerInstance,
+    });
+    const ids = ((_b = args[1]) !== null && _b !== void 0 ? _b : '')
+        .split(',')
+        .map((c) => c.trim())
+        .filter(truthy_1.truthy);
+    const compositions = ids.map((compId) => {
+        const composition = comps.find((c) => c.id === compId);
+        if (!composition) {
+            throw new Error(`No composition with the ID "${compId}" found.`);
+        }
+        return composition;
+    });
+    if (compositions.length === 0) {
+        log_1.Log.error('No composition IDs passed. Add another argument to the command specifying at least 1 composition ID.');
+    }
+    const benchmark = {};
+    let count = 1;
+    const { codec, reason: codecReason } = (0, get_cli_options_1.getFinalCodec)({
+        downloadName: null,
+        outName: null,
+    });
+    for (const composition of compositions) {
+        const renderMediaOptions = await (0, get_render_media_options_1.getRenderMediaOptions)({
+            config: composition,
+            outputLocation: undefined,
+            serveUrl: bundleLocation,
+            codec,
+        });
+        const concurrency = getValidConcurrency(renderMediaOptions);
+        benchmark[composition.id] = {};
+        for (const con of concurrency) {
+            const benchmarkProgress = (0, progress_bar_1.createOverwriteableCliOutput)((0, parse_command_line_1.quietFlagProvided)());
+            log_1.Log.info();
+            log_1.Log.info(`${chalk_1.chalk.bold(`Benchmark #${count++}:`)} ${chalk_1.chalk.gray(`composition=${composition.id} concurrency=${con} codec=${codec} (${codecReason})`)}`);
+            const timeTaken = await runBenchmark(runs, {
+                ...renderMediaOptions,
+                puppeteerInstance,
+                concurrency: con,
+            }, (run, progress) => {
+                benchmarkProgress.update(makeBenchmarkProgressBar({
+                    totalRuns: runs,
+                    run,
+                    doneIn: null,
+                    progress,
+                }));
+            });
+            benchmarkProgress.update('');
+            benchmarkProgress.update(getResults(timeTaken, runs));
+            benchmark[composition.id][`${con}`] = timeTaken;
+        }
+    }
+    log_1.Log.info();
+    await cleanupBundle();
+};
+exports.benchmarkCommand = benchmarkCommand;

package/dist/bundle.d.ts

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

package/dist/bundle.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleCommand = void 0;
+const get_cli_options_1 = require("./get-cli-options");
+const initialize_render_cli_1 = require("./initialize-render-cli");
+const log_1 = require("./log");
+const parse_command_line_1 = require("./parse-command-line");
+const prepare_entry_point_1 = require("./prepare-entry-point");
+const bundleCommand = async (remotionRoot) => {
+    const file = parse_command_line_1.parsedCli._[1];
+    if (!file) {
+        log_1.Log.error('No entry point specified. Pass more arguments:');
+        log_1.Log.error('   npx remotion bundle [entry-point]');
+        log_1.Log.error('Documentation: https://www.remotion.dev/docs/cli/bundle');
+        process.exit(1);
+    }
+    await (0, initialize_render_cli_1.initializeRenderCli)(remotionRoot, 'bundle');
+    const { publicPath, bundleOutDir } = await (0, get_cli_options_1.getCliOptions)({
+        isLambda: false,
+        type: 'get-compositions-or-bundle',
+    });
+    const { urlOrBundle } = await (0, prepare_entry_point_1.prepareEntryPoint)({
+        file,
+        otherSteps: [],
+        outDir: bundleOutDir,
+        publicPath,
+        remotionRoot,
+    });
+    log_1.Log.info();
+    log_1.Log.info(urlOrBundle);
+};
+exports.bundleCommand = bundleCommand;

package/dist/compositions.js

@@ -38,6 +38,7 @@ const listCompositionsCommand = async (remotionRoot) => {
     const { browserExecutable, ffmpegExecutable, ffprobeExecutable, chromiumOptions, envVariables, inputProps, puppeteerTimeout, port, publicDir, } = await (0, get_cli_options_1.getCliOptions)({
         isLambda: false,
         type: 'get-compositions',
+        codec: 'h264',
     });
     const { urlOrBundle: bundled, cleanup: cleanupBundle } = await (0, setup_cache_1.bundleOnCliOrTakeServeUrl)({
         remotionRoot,

package/dist/config/bundle-out-dir.d.ts

@@ -0,0 +1,2 @@
+export declare const getBundleOutDir: () => string | null;
+export declare const setBundleDir: (path: string) => void;

package/dist/config/bundle-out-dir.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setBundleDir = exports.getBundleOutDir = void 0;
+let bundleOutDir = null;
+const getBundleOutDir = () => {
+    return bundleOutDir;
+};
+exports.getBundleOutDir = getBundleOutDir;
+const setBundleDir = (path) => {
+    bundleOutDir = path;
+};
+exports.setBundleDir = setBundleDir;

package/dist/config/get-public-path.d.ts

@@ -0,0 +1,2 @@
+export declare const getPublicPath: () => string | null;
+export declare const setPublicPath: (path: string) => void;

package/dist/config/get-public-path.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPublicPath = exports.getPublicPath = void 0;
+let publicPath = null;
+const getPublicPath = () => {
+    return publicPath;
+};
+exports.getPublicPath = getPublicPath;
+const setPublicPath = (path) => {
+    publicPath = path;
+};
+exports.setPublicPath = setPublicPath;

package/dist/config/image-format.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUserPreferredImageFormat = exports.setImageFormat = void 0;
 const renderer_1 = require("@remotion/renderer");
+const truthy_1 = require("../truthy");
 let currentImageFormat;
 const setImageFormat = (format) => {
     if (typeof format === 'undefined') {
@@ -9,7 +10,13 @@ const setImageFormat = (format) => {
         return;
     }
     if (!renderer_1.RenderInternals.validImageFormats.includes(format)) {
-        throw new TypeError(`Value ${format} is not valid as an image format.`);
+        throw new TypeError([
+            `Value ${format} is not valid as an image format.`,
+            // @ts-expect-error
+            format === 'jpg' ? 'Did you mean "jpeg"?' : null,
+        ]
+            .filter(truthy_1.truthy)
+            .join(' '));
     }
     currentImageFormat = format;
 };

package/dist/config/log.d.ts

@@ -1,3 +1,3 @@
 import type { LogLevel } from '@remotion/renderer';
-export declare const getLogLevel: () => "verbose" | "info" | "warn" | "error";
+export declare const getLogLevel: () => "verbose" | "error" | "info" | "warn";
 export declare const setLogLevel: (newLogLevel: LogLevel) => void;

package/dist/determine-image-format.d.ts

@@ -0,0 +1,11 @@
+import type { ImageFormat, StillImageFormat } from '@remotion/renderer';
+export declare const determineFinalImageFormat: ({ downloadName, outName, configImageFormat, cliFlag, isLambda, }: {
+    downloadName: string | null;
+    outName: string | null;
+    configImageFormat: ImageFormat | null;
+    cliFlag: ImageFormat | null;
+    isLambda: boolean;
+}) => {
+    format: StillImageFormat;
+    source: string;
+};

package/dist/determine-image-format.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineFinalImageFormat = void 0;
+const deriveExtensionFromFilename = (filename) => {
+    if (filename === null || filename === void 0 ? void 0 : filename.endsWith('.png')) {
+        return 'png';
+    }
+    if (filename === null || filename === void 0 ? void 0 : filename.endsWith('.jpg')) {
+        return 'jpeg';
+    }
+    if (filename === null || filename === void 0 ? void 0 : filename.endsWith('.jpeg')) {
+        return 'jpeg';
+    }
+    return null;
+};
+const determineFinalImageFormat = ({ downloadName, outName, configImageFormat, cliFlag, isLambda, }) => {
+    const outNameExtension = deriveExtensionFromFilename(outName);
+    const downloadNameExtension = deriveExtensionFromFilename(downloadName);
+    const outNameDescription = isLambda ? 'S3 output key' : 'out name';
+    if (outNameExtension &&
+        downloadNameExtension &&
+        outNameExtension !== downloadNameExtension) {
+        throw new TypeError(`Image format mismatch: ${outName} was given as the ${outNameDescription} and ${downloadName} was given as the download name, but the extensions don't match.`);
+    }
+    if (downloadNameExtension) {
+        if (cliFlag && downloadNameExtension !== cliFlag) {
+            throw new TypeError(`Image format mismatch: ${downloadName} was given as the download name, but --image-format=${cliFlag} was passed. The image formats must match.`);
+        }
+        return { format: downloadNameExtension, source: 'Download name extension' };
+    }
+    if (outNameExtension) {
+        if (cliFlag && outNameExtension !== cliFlag) {
+            throw new TypeError(`Image format mismatch: ${outName} was given as the ${outNameDescription}, but --image-format=${cliFlag} was passed. The image formats must match.`);
+        }
+        return { format: outNameExtension, source: 'Out name extension' };
+    }
+    if (cliFlag === 'none') {
+        throw new TypeError('The --image-format flag must not be "none" for stills.');
+    }
+    if (cliFlag !== null) {
+        return { format: cliFlag, source: '--image-format flag' };
+    }
+    if (configImageFormat !== null && configImageFormat !== 'none') {
+        return { format: configImageFormat, source: 'Config file' };
+    }
+    return { format: 'png', source: 'Default' };
+};
+exports.determineFinalImageFormat = determineFinalImageFormat;

package/dist/editor/components/Button.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const Button: React.FC<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement> & {
+    children: React.ReactNode;
+}>;

package/dist/editor/components/Button.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Button = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const colors_1 = require("../helpers/colors");
+const layout_1 = require("./layout");
+const container = {
+    padding: 10,
+    cursor: 'pointer',
+    fontSize: 14,
+};
+const button = {
+    border: `1px solid ${colors_1.INPUT_BORDER_COLOR_UNHOVERED}`,
+    borderRadius: 4,
+    backgroundColor: colors_1.INPUT_BACKGROUND,
+    appearance: 'none',
+    fontFamily: 'inherit',
+    fontSize: 14,
+    color: 'white',
+};
+const Button = ({ children, ...props }) => {
+    return ((0, jsx_runtime_1.jsx)("button", { ...props, style: button, type: "button", children: (0, jsx_runtime_1.jsx)(layout_1.Row, { style: container, children: children }) }));
+};
+exports.Button = Button;

package/dist/editor/components/PlayPause.d.ts

@@ -1,5 +0,0 @@
-import React from 'react';
-export declare const PlayPause: React.FC<{
-    playbackRate: number;
-    loop: boolean;
-}>;

package/dist/editor/components/PreviewZoomControls.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const PreviewZoomControls: React.FC;

package/dist/editor/components/PreviewZoomControls.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreviewZoomControls = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const minus_1 = require("../icons/minus");
+const plus_1 = require("../icons/plus");
+const preview_size_1 = require("../state/preview-size");
+const ControlButton_1 = require("./ControlButton");
+const layout_1 = require("./layout");
+const container = {
+    color: 'black',
+    flexDirection: 'row',
+    display: 'flex',
+};
+const buttonStyle = {
+    fontSize: 24,
+};
+const iconStyle = {
+    color: 'white',
+    width: 14,
+};
+const PreviewZoomControls = () => {
+    const { size, setSize } = (0, react_1.useContext)(preview_size_1.PreviewSizeContext);
+    const onZoomOutClicked = (0, react_1.useCallback)(() => {
+        setSize((z) => {
+            // TODO: Don't assume 1
+            const newSize = Number((z.size === 'auto' ? 1 : z.size - preview_size_1.ZOOM_BUTTON_STEP).toFixed(2));
+            return { ...z, size: Math.max(preview_size_1.PREVIEW_MIN_ZOOM, newSize) };
+        });
+    }, [setSize]);
+    const onZoomInClicked = (0, react_1.useCallback)(() => {
+        setSize((z) => {
+            // TODO: Don't assume 1
+            if (z.size === 'auto')
+                return {
+                    size: 1 + preview_size_1.ZOOM_BUTTON_STEP,
+                    translation: {
+                        x: 0,
+                        y: 0,
+                    },
+                };
+            const newSize = Number((Number(z) + preview_size_1.ZOOM_BUTTON_STEP).toFixed(2));
+            return { ...z, size: Math.min(preview_size_1.PREVIEW_MAX_ZOOM, newSize) };
+        });
+    }, [setSize]);
+    return ((0, jsx_runtime_1.jsxs)("div", { style: container, children: [(0, jsx_runtime_1.jsx)(ControlButton_1.ControlButton, { onClick: onZoomOutClicked, style: buttonStyle, title: "Zoom out preview", role: 'ControlButton', type: "button", disabled: size.size !== 'auto' && preview_size_1.PREVIEW_MIN_ZOOM === size.size, children: (0, jsx_runtime_1.jsx)(minus_1.Minus, { style: iconStyle }) }), (0, jsx_runtime_1.jsx)(layout_1.Spacing, { x: 0.5 }), (0, jsx_runtime_1.jsx)(layout_1.Spacing, { x: 0.5 }), (0, jsx_runtime_1.jsx)(ControlButton_1.ControlButton, { onClick: onZoomInClicked, style: buttonStyle, title: "Zoom in preview", role: 'button', type: "button", disabled: size.size !== 'auto' && preview_size_1.PREVIEW_MAX_ZOOM === size.size, children: (0, jsx_runtime_1.jsx)(plus_1.Plus, { style: iconStyle }) })] }));
+};
+exports.PreviewZoomControls = PreviewZoomControls;

package/dist/editor/helpers/normalize-wheel.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeWheel(event: WheelEvent): {
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+};

package/dist/editor/helpers/normalize-wheel.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeWheel = void 0;
+// Taken from https://github.com/tldraw/tldraw/blob/254dfdfd77c4abde53240f7d8ca3558e08688493/packages/core/src/hooks/useZoomEvents.ts which is adapted from https://stackoverflow.com/a/13650579
+const MAX_ZOOM_STEP = 10;
+function normalizeWheel(event) {
+    const { deltaY, deltaX } = event;
+    let deltaZ = 0;
+    if (event.ctrlKey || event.metaKey) {
+        const signY = Math.sign(event.deltaY);
+        const absDeltaY = Math.abs(event.deltaY);
+        let dy = deltaY;
+        if (absDeltaY > MAX_ZOOM_STEP) {
+            dy = MAX_ZOOM_STEP * signY;
+        }
+        deltaZ = dy;
+    }
+    return { deltaX, deltaY, deltaZ };
+}
+exports.normalizeWheel = normalizeWheel;

package/dist/event-source-events.d.ts

@@ -3,4 +3,7 @@ export declare type EventSourceEvent = {
     newProps: object;
 } | {
     type: 'init';
+} | {
+    type: 'new-env-variables';
+    newEnvVariables: Record<string, string>;
 };

package/dist/event-source.js

@@ -7,7 +7,7 @@ const openEventSource = () => {
     source = new EventSource('/events');
     source.addEventListener('message', (event) => {
         const newEvent = JSON.parse(event.data);
-        if (newEvent.type === 'new-input-props') {
+        if (newEvent.type === 'new-input-props' || newEvent.type === 'new-env-variables') {
             window.location.reload();
         }
     });

package/dist/get-cli-options.d.ts

@@ -1,14 +1,22 @@
-import type { BrowserExecutable, ChromiumOptions, FrameRange } from '@remotion/renderer';
+import type { BrowserExecutable, ChromiumOptions, Codec, FrameRange } from '@remotion/renderer';
+export declare const validateFfmpegCanUseCodec: (codec: Codec) => Promise<void>;
+export declare const getFinalCodec: (options: {
+    downloadName: string | null;
+    outName: string | null;
+}) => {
+    codec: Codec;
+    reason: string;
+};
 export declare const getAndValidateAbsoluteOutputFile: (relativeOutputLocation: string, overwrite: boolean) => string;
 export declare const getCliOptions: (options: {
     isLambda: boolean;
     type: 'still' | 'series' | 'get-compositions';
+    codec: Codec;
 }) => Promise<{
     puppeteerTimeout: number;
     concurrency: number | null;
     frameRange: FrameRange | null;
     shouldOutputImageSequence: boolean;
-    codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
     inputProps: object;
     envVariables: Record<string, string>;
     quality: number | undefined;
@@ -23,7 +31,7 @@ export declare const getCliOptions: (options: {
     browserExecutable: BrowserExecutable;
     ffmpegExecutable: import("@remotion/renderer").FfmpegExecutable;
     ffprobeExecutable: import("@remotion/renderer").FfmpegExecutable;
-    logLevel: "verbose" | "info" | "warn" | "error";
+    logLevel: "verbose" | "error" | "info" | "warn";
     scale: number;
     chromiumOptions: ChromiumOptions;
     overwrite: boolean;

package/dist/get-cli-options.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCliOptions = exports.getAndValidateAbsoluteOutputFile = void 0;
+exports.getCliOptions = exports.getAndValidateAbsoluteOutputFile = exports.getFinalCodec = exports.validateFfmpegCanUseCodec = void 0;
 const renderer_1 = require("@remotion/renderer");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -13,7 +13,7 @@ const get_final_output_codec_1 = require("./get-final-output-codec");
 const get_input_props_1 = require("./get-input-props");
 const image_formats_1 = require("./image-formats");
 const log_1 = require("./log");
-const user_passed_output_location_1 = require("./user-passed-output-location");
+const parse_command_line_1 = require("./parse-command-line");
 const getAndValidateFrameRange = () => {
     const frameRange = config_1.ConfigInternals.getRange();
     if (typeof frameRange === 'number') {
@@ -23,20 +23,11 @@ const getAndValidateFrameRange = () => {
     }
     return frameRange;
 };
-const getFinalCodec = async (options) => {
-    const userCodec = config_1.ConfigInternals.getOutputCodecOrUndefined();
-    const codec = (0, get_final_output_codec_1.getFinalOutputCodec)({
-        codec: userCodec,
-        fileExtension: options.isLambda
-            ? null
-            : renderer_1.RenderInternals.getExtensionOfFilename((0, user_passed_output_location_1.getUserPassedOutputLocation)()),
-        emitWarning: true,
-    });
+const validateFfmpegCanUseCodec = async (codec) => {
     const ffmpegExecutable = config_1.ConfigInternals.getCustomFfmpegExecutable();
     if (codec === 'vp8' &&
         !(await renderer_1.RenderInternals.ffmpegHasFeature({
             feature: 'enable-libvpx',
-            isLambda: options.isLambda,
             ffmpegExecutable,
         }))) {
         log_1.Log.error("The Vp8 codec has been selected, but your FFMPEG binary wasn't compiled with the --enable-lipvpx flag.");
@@ -45,7 +36,6 @@ const getFinalCodec = async (options) => {
     if (codec === 'h265' &&
         !(await renderer_1.RenderInternals.ffmpegHasFeature({
             feature: 'enable-gpl',
-            isLambda: options.isLambda,
             ffmpegExecutable,
         }))) {
         log_1.Log.error("The H265 codec has been selected, but your FFMPEG binary wasn't compiled with the --enable-gpl flag.");
@@ -54,14 +44,24 @@ const getFinalCodec = async (options) => {
     if (codec === 'h265' &&
         !(await renderer_1.RenderInternals.ffmpegHasFeature({
             feature: 'enable-libx265',
-            isLambda: options.isLambda,
             ffmpegExecutable,
         }))) {
         log_1.Log.error("The H265 codec has been selected, but your FFMPEG binary wasn't compiled with the --enable-libx265 flag.");
         log_1.Log.error('This does not work, please recompile your FFMPEG binary with --enable-gpl --enable-libx265 or choose a different codec.');
     }
-    return codec;
 };
+exports.validateFfmpegCanUseCodec = validateFfmpegCanUseCodec;
+const getFinalCodec = (options) => {
+    var _a;
+    const { codec, reason } = (0, get_final_output_codec_1.getFinalOutputCodec)({
+        cliFlag: parse_command_line_1.parsedCli.codec,
+        configFile: (_a = config_1.ConfigInternals.getOutputCodecOrUndefined()) !== null && _a !== void 0 ? _a : null,
+        downloadName: options.downloadName,
+        outName: options.outName,
+    });
+    return { codec, reason };
+};
+exports.getFinalCodec = getFinalCodec;
 const getBrowser = () => { var _a; return (_a = config_1.ConfigInternals.getBrowser()) !== null && _a !== void 0 ? _a : renderer_1.RenderInternals.DEFAULT_BROWSER; };
 const getAndValidateAbsoluteOutputFile = (relativeOutputLocation, overwrite) => {
     const absoluteOutputFile = path_1.default.resolve(process.cwd(), relativeOutputLocation);
@@ -119,11 +119,6 @@ const getAndValidateBrowser = async (browserExecutable) => {
 const getCliOptions = async (options) => {
     var _a;
     const frameRange = getAndValidateFrameRange();
-    const codec = options.type === 'get-compositions'
-        ? 'h264'
-        : await getFinalCodec({
-            isLambda: options.isLambda,
-        });
     const shouldOutputImageSequence = options.type === 'still'
         ? true
         : await getAndValidateShouldOutputImageSequence({
@@ -133,14 +128,14 @@ const getCliOptions = async (options) => {
     const overwrite = config_1.ConfigInternals.getShouldOverwrite({
         defaultValue: !options.isLambda,
     });
-    const crf = getAndValidateCrf(shouldOutputImageSequence, codec);
-    const pixelFormat = getAndValidatePixelFormat(codec);
+    const crf = getAndValidateCrf(shouldOutputImageSequence, options.codec);
+    const pixelFormat = getAndValidatePixelFormat(options.codec);
     const imageFormat = getAndValidateImageFormat({
         shouldOutputImageSequence,
-        codec,
+        codec: options.codec,
         pixelFormat,
     });
-    const proResProfile = getAndValidateProResProfile(codec);
+    const proResProfile = getAndValidateProResProfile(options.codec);
     const browserExecutable = config_1.ConfigInternals.getBrowserExecutable();
     const ffmpegExecutable = config_1.ConfigInternals.getCustomFfmpegExecutable();
     const ffprobeExecutable = config_1.ConfigInternals.getCustomFfprobeExecutable();
@@ -152,8 +147,8 @@ const getCliOptions = async (options) => {
         headless: config_1.ConfigInternals.getChromiumHeadlessMode(),
         gl: (_a = config_1.ConfigInternals.getChromiumOpenGlRenderer()) !== null && _a !== void 0 ? _a : renderer_1.RenderInternals.DEFAULT_OPENGL_RENDERER,
     };
-    const everyNthFrame = config_1.ConfigInternals.getAndValidateEveryNthFrame(codec);
-    const numberOfGifLoops = config_1.ConfigInternals.getAndValidateNumberOfGifLoops(codec);
+    const everyNthFrame = config_1.ConfigInternals.getAndValidateEveryNthFrame(options.codec);
+    const numberOfGifLoops = config_1.ConfigInternals.getAndValidateNumberOfGifLoops(options.codec);
     const concurrency = config_1.ConfigInternals.getConcurrency();
     renderer_1.RenderInternals.validateConcurrency(concurrency, 'concurrency');
     return {
@@ -161,9 +156,8 @@ const getCliOptions = async (options) => {
         concurrency,
         frameRange,
         shouldOutputImageSequence,
-        codec,
         inputProps: (0, get_input_props_1.getInputProps)(() => undefined),
-        envVariables: await (0, get_env_1.getEnvironmentVariables)(),
+        envVariables: await (0, get_env_1.getEnvironmentVariables)(() => undefined),
         quality: config_1.ConfigInternals.getQuality(),
         browser: await getAndValidateBrowser(browserExecutable),
         crf,

package/dist/get-env.d.ts

@@ -1 +1 @@
-export declare const getEnvironmentVariables: () => Promise<Record<string, string>>;
+export declare const getEnvironmentVariables: (onUpdate: (newProps: Record<string, string>) => void) => Promise<Record<string, string>>;