@remotion/renderer 4.0.0-webhook.26 → 4.1.0-alpha1

package/dist/get-compositions.js

@@ -1,32 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCompositions = void 0;
-const download_map_1 = require("./assets/download-map");
+exports.getCompositions = exports.internalGetCompositions = void 0;
+const TimeoutSettings_1 = require("./browser/TimeoutSettings");
 const handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
+const find_closest_package_json_1 = require("./find-closest-package-json");
 const get_browser_instance_1 = require("./get-browser-instance");
 const prepare_server_1 = require("./prepare-server");
 const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const seek_to_frame_1 = require("./seek-to-frame");
 const set_props_and_env_1 = require("./set-props-and-env");
 const validate_puppeteer_timeout_1 = require("./validate-puppeteer-timeout");
-const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
-    if (config === null || config === void 0 ? void 0 : config.onBrowserLog) {
+const innerGetCompositions = async ({ envVariables, inputProps, onBrowserLog, page, proxyPort, serveUrl, timeoutInMilliseconds, }) => {
+    if (onBrowserLog) {
         page.on('console', (log) => {
-            var _a;
-            (_a = config.onBrowserLog) === null || _a === void 0 ? void 0 : _a.call(config, {
+            onBrowserLog({
                 stackTrace: log.stackTrace(),
                 text: log.text,
                 type: log.type,
             });
         });
     }
-    (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(config === null || config === void 0 ? void 0 : config.timeoutInMilliseconds);
+    (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(timeoutInMilliseconds);
     await (0, set_props_and_env_1.setPropsAndEnv)({
-        inputProps: config === null || config === void 0 ? void 0 : config.inputProps,
-        envVariables: config === null || config === void 0 ? void 0 : config.envVariables,
+        inputProps,
+        envVariables,
         page,
         serveUrl,
         initialFrame: 0,
-        timeoutInMilliseconds: config === null || config === void 0 ? void 0 : config.timeoutInMilliseconds,
+        timeoutInMilliseconds,
         proxyPort,
         retriesRemaining: 2,
         audioEnabled: false,
@@ -35,14 +36,14 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         page,
         pageFunction: () => {
-            window.setBundleMode({
+            window.remotion_setBundleMode({
                 type: 'evaluation',
             });
         },
         frame: null,
         args: [],
     });
-    await page.waitForFunction(page.browser, 'window.ready === true');
+    await (0, seek_to_frame_1.waitForReady)(page);
     const result = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
         pageFunction: () => {
             return window.getStaticCompositions();
@@ -53,49 +54,81 @@ const innerGetCompositions = async (serveUrl, page, config, proxyPort) => {
     });
     return result;
 };
-const getCompositions = async (serveUrlOrWebpackUrl, config) => {
-    var _a, _b, _c;
-    const downloadMap = (_a = config === null || config === void 0 ? void 0 : config.downloadMap) !== null && _a !== void 0 ? _a : (0, download_map_1.makeDownloadMap)();
-    const { page, cleanup } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
-        passedInInstance: config === null || config === void 0 ? void 0 : config.puppeteerInstance,
-        browserExecutable: (_b = config === null || config === void 0 ? void 0 : config.browserExecutable) !== null && _b !== void 0 ? _b : null,
-        chromiumOptions: (_c = config === null || config === void 0 ? void 0 : config.chromiumOptions) !== null && _c !== void 0 ? _c : {},
+const internalGetCompositions = async ({ browserExecutable, chromiumOptions, envVariables, indent, inputProps, onBrowserLog, port, puppeteerInstance, serveUrlOrWebpackUrl, server, timeoutInMilliseconds, verbose, }) => {
+    const { page, cleanup: cleanupPage } = await (0, get_browser_instance_1.getPageAndCleanupFn)({
+        passedInInstance: puppeteerInstance,
+        browserExecutable,
+        chromiumOptions,
+        context: null,
+        forceDeviceScaleFactor: undefined,
+        indent,
+        shouldDumpIo: verbose,
     });
+    const cleanup = [cleanupPage];
     return new Promise((resolve, reject) => {
-        var _a, _b, _c;
         const onError = (err) => reject(err);
-        const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
+        cleanup.push((0, handle_javascript_exception_1.handleJavascriptException)({
             page,
             frame: null,
             onError,
-        });
-        let close = null;
-        (0, prepare_server_1.prepareServer)({
+        }));
+        (0, prepare_server_1.makeOrReuseServer)(server, {
             webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
+            port,
+            remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
+            concurrency: 1,
+            verbose,
+            indent,
+        }, {
             onDownload: () => undefined,
             onError,
-            ffmpegExecutable: (_a = config === null || config === void 0 ? void 0 : config.ffmpegExecutable) !== null && _a !== void 0 ? _a : null,
-            ffprobeExecutable: (_b = config === null || config === void 0 ? void 0 : config.ffprobeExecutable) !== null && _b !== void 0 ? _b : null,
-            port: (_c = config === null || config === void 0 ? void 0 : config.port) !== null && _c !== void 0 ? _c : null,
-            downloadMap,
         })
-            .then(({ serveUrl, closeServer, offthreadPort }) => {
-            close = closeServer;
-            return innerGetCompositions(serveUrl, page, config !== null && config !== void 0 ? config : {}, offthreadPort);
+            .then(({ server: { serveUrl, offthreadPort, sourceMap }, cleanupServer }) => {
+            page.setBrowserSourceMapContext(sourceMap);
+            cleanup.push(() => cleanupServer(true));
+            return innerGetCompositions({
+                envVariables,
+                inputProps,
+                onBrowserLog,
+                page,
+                proxyPort: offthreadPort,
+                serveUrl,
+                timeoutInMilliseconds,
+            });
+        })
+            .then((comp) => {
+            return resolve(comp);
         })
-            .then((comp) => resolve(comp))
             .catch((err) => {
             reject(err);
         })
             .finally(() => {
-            cleanup();
-            close === null || close === void 0 ? void 0 : close();
-            cleanupPageError();
-            // Clean download map if it was not passed in
-            if (!(config === null || config === void 0 ? void 0 : config.downloadMap)) {
-                (0, download_map_1.cleanDownloadMap)(downloadMap);
-            }
+            cleanup.forEach((c) => {
+                c();
+            });
         });
     });
 };
+exports.internalGetCompositions = internalGetCompositions;
+/**
+ * @description Gets the compositions defined in a Remotion project based on a Webpack bundle.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/get-compositions)
+ */
+const getCompositions = (serveUrlOrWebpackUrl, config) => {
+    const { browserExecutable, chromiumOptions, envVariables, inputProps, onBrowserLog, port, puppeteerInstance, timeoutInMilliseconds, verbose, } = config !== null && config !== void 0 ? config : {};
+    return (0, exports.internalGetCompositions)({
+        browserExecutable: browserExecutable !== null && browserExecutable !== void 0 ? browserExecutable : null,
+        chromiumOptions: chromiumOptions !== null && chromiumOptions !== void 0 ? chromiumOptions : {},
+        envVariables: envVariables !== null && envVariables !== void 0 ? envVariables : {},
+        inputProps: inputProps !== null && inputProps !== void 0 ? inputProps : {},
+        indent: false,
+        onBrowserLog: onBrowserLog !== null && onBrowserLog !== void 0 ? onBrowserLog : null,
+        port: port !== null && port !== void 0 ? port : null,
+        puppeteerInstance: puppeteerInstance !== null && puppeteerInstance !== void 0 ? puppeteerInstance : undefined,
+        serveUrlOrWebpackUrl,
+        server: undefined,
+        timeoutInMilliseconds: timeoutInMilliseconds !== null && timeoutInMilliseconds !== void 0 ? timeoutInMilliseconds : TimeoutSettings_1.DEFAULT_TIMEOUT,
+        verbose: verbose !== null && verbose !== void 0 ? verbose : false,
+    });
+};
 exports.getCompositions = getCompositions;

package/dist/get-concurrency.d.ts

@@ -1 +1 @@
-export declare const getActualConcurrency: (userPreference: number | null) => number;
+export declare const getActualConcurrency: (userPreference: number | string | null) => number;

package/dist/get-concurrency.js

@@ -4,14 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getActualConcurrency = void 0;
-const os_1 = __importDefault(require("os"));
+const node_os_1 = __importDefault(require("node:os"));
 const getActualConcurrency = (userPreference) => {
     if (userPreference === null) {
-        return Math.round(Math.min(8, Math.max(1, os_1.default.cpus().length / 2)));
+        return Math.round(Math.min(8, Math.max(1, node_os_1.default.cpus().length / 2)));
     }
-    const rounded = Math.floor(userPreference);
-    const max = os_1.default.cpus().length;
+    const max = node_os_1.default.cpus().length;
     const min = 1;
+    let rounded;
+    if (typeof userPreference === 'string') {
+        const percentage = parseInt(userPreference.slice(0, -1), 10);
+        rounded = Math.floor((percentage / 100) * max);
+    }
+    else {
+        rounded = Math.floor(userPreference);
+    }
     if (rounded > max) {
         throw new Error(`Maximum for --concurrency is ${max} (number of cores on this system)`);
     }

package/dist/get-extension-from-codec.d.ts

@@ -1,2 +1,6 @@
+import type { AudioCodec } from './audio-codec';
 import type { Codec } from './codec';
-export declare const getFileExtensionFromCodec: (codec: Codec, type: 'chunk' | 'final') => "mp3" | "aac" | "wav" | "gif" | "webm" | "mp4" | "mov" | "mkv";
+import type { FileExtension } from './file-extensions';
+export declare const getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: AudioCodec | null) => FileExtension;
+export declare const makeFileExtensionMap: () => Record<string, ("h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif")[]>;
+export declare const defaultCodecsForFileExtension: Record<FileExtension, Codec>;

package/dist/get-extension-from-codec.js

@@ -1,37 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFileExtensionFromCodec = void 0;
-const getFileExtensionFromCodec = (codec, type) => {
-    switch (codec) {
-        case 'aac':
-            return 'aac';
-        case 'h264':
-            return 'mp4';
-        // The chunks will be rendered as mkv, but the final output will still be MP4
-        case 'h264-mkv':
-            if (type === 'chunk') {
-                return 'mkv';
-            }
-            return 'mp4';
-        case 'h265':
-            return 'mp4';
-        case 'mp3':
-            return 'mp3';
-        case 'prores':
-            return 'mov';
-        case 'vp8':
-            return 'webm';
-        case 'vp9':
-            return 'webm';
-        case 'gif':
-            if (type === 'chunk') {
-                return 'mkv';
-            }
-            return 'gif';
-        case 'wav':
-            return 'wav';
-        default:
-            throw new Error("Don't know which file extension to use for codec " + codec);
+exports.defaultCodecsForFileExtension = exports.makeFileExtensionMap = exports.getFileExtensionFromCodec = void 0;
+const codec_1 = require("./codec");
+const file_extensions_1 = require("./file-extensions");
+const getFileExtensionFromCodec = (codec, audioCodec) => {
+    if (!codec_1.validCodecs.includes(codec)) {
+        throw new Error(`Codec must be one of the following: ${codec_1.validCodecs.join(', ')}, but got ${codec}`);
+    }
+    const map = file_extensions_1.defaultFileExtensionMap[codec];
+    if (audioCodec === null) {
+        return map.default;
+    }
+    const typedAudioCodec = audioCodec;
+    if (!(typedAudioCodec in map.forAudioCodec)) {
+        throw new Error(`Audio codec ${typedAudioCodec} is not supported for codec ${codec}`);
     }
+    return map.forAudioCodec[audioCodec]
+        .default;
 };
 exports.getFileExtensionFromCodec = getFileExtensionFromCodec;
+const makeFileExtensionMap = () => {
+    const map = {};
+    Object.keys(file_extensions_1.defaultFileExtensionMap).forEach((_codec) => {
+        const codec = _codec;
+        const fileExtMap = file_extensions_1.defaultFileExtensionMap[codec];
+        const audioCodecs = Object.keys(fileExtMap.forAudioCodec);
+        const possibleExtensionsForAudioCodec = audioCodecs.map((audioCodec) => fileExtMap.forAudioCodec[audioCodec].possible);
+        const allPossibleExtensions = [
+            fileExtMap.default,
+            ...possibleExtensionsForAudioCodec.flat(1),
+        ];
+        for (const extension of allPossibleExtensions) {
+            if (!map[extension]) {
+                map[extension] = [];
+            }
+            if (!map[extension].includes(codec)) {
+                map[extension].push(codec);
+            }
+        }
+    });
+    return map;
+};
+exports.makeFileExtensionMap = makeFileExtensionMap;
+exports.defaultCodecsForFileExtension = {
+    '3gp': 'aac',
+    aac: 'aac',
+    gif: 'gif',
+    hevc: 'h265',
+    m4a: 'aac',
+    m4b: 'aac',
+    mkv: 'h264-mkv',
+    mov: 'prores',
+    mp3: 'mp3',
+    mp4: 'h264',
+    mpeg: 'aac',
+    mpg: 'aac',
+    mxf: 'prores',
+    wav: 'wav',
+    webm: 'vp8',
+};

package/dist/get-extension-of-filename.js

@@ -1,11 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExtensionOfFilename = void 0;
+const node_path_1 = __importDefault(require("node:path"));
 const getExtensionOfFilename = (filename) => {
     if (filename === null) {
         return null;
     }
-    const filenameArr = filename.split('.');
+    const filenameArr = node_path_1.default.normalize(filename).split('.');
     const hasExtension = filenameArr.length >= 2;
     const filenameArrLength = filenameArr.length;
     const extension = hasExtension ? filenameArr[filenameArrLength - 1] : null;

package/dist/get-frame-padded-index.d.ts

@@ -1,8 +1,9 @@
-export declare type CountType = 'from-zero' | 'actual-frames';
+import type { VideoImageFormat } from './image-format';
+export type CountType = 'from-zero' | 'actual-frames';
 export declare const getFrameOutputFileName: ({ index, frame, imageFormat, countType, lastFrame, totalFrames, }: {
     index: number;
     frame: number;
-    imageFormat: 'png' | 'jpeg';
+    imageFormat: VideoImageFormat;
     countType: CountType;
     lastFrame: number;
     totalFrames: number;

package/dist/get-frame-padded-index.js

@@ -10,13 +10,14 @@ const padIndex = ({ num, filePadLength, }) => {
 };
 const getFrameOutputFileName = ({ index, frame, imageFormat, countType, lastFrame, totalFrames, }) => {
     const filePadLength = (0, exports.getFilePadLength)({ lastFrame, countType, totalFrames });
+    const prefix = 'element';
     if (countType === 'actual-frames') {
         const paddedIndex = padIndex({ filePadLength, num: frame });
-        return `element-${paddedIndex}.${imageFormat}`;
+        return `${prefix}-${paddedIndex}.${imageFormat}`;
     }
     if (countType === 'from-zero') {
         const paddedIndex = padIndex({ filePadLength, num: index });
-        return `element-${paddedIndex}.${imageFormat}`;
+        return `${prefix}-${paddedIndex}.${imageFormat}`;
     }
     throw new TypeError('Unknown count type');
 };

package/dist/get-frame-to-render.js

@@ -12,7 +12,7 @@ const getRealFrameRange = (durationInFrames, frameRange) => {
         return [frameRange, frameRange];
     }
     if (frameRange[1] >= durationInFrames || frameRange[0] < 0) {
-        throw new Error(`Frame range ${frameRange.join('-')} is not in between 0-${durationInFrames - 1}`);
+        throw new Error(`Frame range ${frameRange.join('-')} is not inbetween 0-${durationInFrames - 1}`);
     }
     return frameRange;
 };

package/dist/get-local-browser-executable.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalBrowserExecutable = exports.ensureLocalBrowser = void 0;
-const fs_1 = __importDefault(require("fs"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const BrowserFetcher_1 = require("./browser/BrowserFetcher");
 const create_browser_fetcher_1 = require("./browser/create-browser-fetcher");
-const node_1 = require("./browser/node");
 const revisions_1 = require("./browser/revisions");
 const getSearchPathsForProduct = (product) => {
     var _a;
@@ -18,6 +18,7 @@ const getSearchPathsForProduct = (product) => {
                 : null,
             process.platform === 'linux' ? '/usr/bin/google-chrome' : null,
             process.platform === 'linux' ? '/usr/bin/chromium-browser' : null,
+            process.platform === 'linux' ? '/usr/bin/chromium' : null,
             process.platform === 'linux'
                 ? '/app/.apt/usr/bin/google-chrome-stable'
                 : null,
@@ -37,24 +38,15 @@ const getSearchPathsForProduct = (product) => {
 const mapBrowserToProduct = (browser) => browser;
 const getLocalBrowser = (product) => {
     for (const p of getSearchPathsForProduct(product)) {
-        if (fs_1.default.existsSync(p)) {
+        if (node_fs_1.default.existsSync(p)) {
             return p;
         }
     }
     return null;
 };
-const getBrowserRevision = (product) => {
-    const browserFetcher = node_1.puppeteer.createBrowserFetcher({
-        product,
-        path: null,
-        platform: null,
-    });
-    const revisionInfo = browserFetcher.revisionInfo(revisions_1.PUPPETEER_REVISIONS.chromium);
-    return revisionInfo;
-};
 const getBrowserStatus = (product, browserExecutablePath) => {
     if (browserExecutablePath) {
-        if (!fs_1.default.existsSync(browserExecutablePath)) {
+        if (!node_fs_1.default.existsSync(browserExecutablePath)) {
             console.warn(`Browser executable was specified as '${browserExecutablePath}' but the path doesn't exist.`);
         }
         return { path: browserExecutablePath, type: 'user-defined-path' };
@@ -63,8 +55,8 @@ const getBrowserStatus = (product, browserExecutablePath) => {
     if (localBrowser !== null) {
         return { path: localBrowser, type: 'local-browser' };
     }
-    const revision = getBrowserRevision(product);
-    if (revision.local !== null && fs_1.default.existsSync(revision.executablePath)) {
+    const revision = (0, BrowserFetcher_1.getRevisionInfo)(revisions_1.PUPPETEER_REVISIONS.chromium, product);
+    if (revision.local && node_fs_1.default.existsSync(revision.executablePath)) {
         return { path: revision.executablePath, type: 'local-puppeteer-browser' };
     }
     return { type: 'no-browser' };

package/dist/get-port.d.ts

@@ -1 +1,4 @@
-export declare const getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<number>;
+export declare const getDesiredPort: (desiredPort: number | undefined, from: number, to: number) => Promise<{
+    port: number;
+    didUsePort: () => void;
+}>;

package/dist/get-port.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDesiredPort = void 0;
 const net_1 = __importDefault(require("net"));
-const p_limit_1 = require("./p-limit");
+const locks_1 = require("./locks");
 const getAvailablePort = (portToTry) => new Promise((resolve) => {
     let status = 'unavailable';
     const host = '127.0.0.1';
@@ -35,21 +35,21 @@ const getPort = async (from, to) => {
     }
     throw new Error('No available ports found');
 };
-const getDesiredPortUnlimited = async (desiredPort, from, to) => {
+const portLocks = (0, locks_1.createLock)({ timeout: 10000 });
+const getDesiredPort = async (desiredPort, from, to) => {
+    await portLocks.waitForAllToBeDone();
+    const lockPortSelection = portLocks.lock();
+    const didUsePort = () => portLocks.unlock(lockPortSelection);
     if (typeof desiredPort !== 'undefined' &&
         (await getAvailablePort(desiredPort)) === 'available') {
-        return desiredPort;
+        return { port: desiredPort, didUsePort };
     }
     const actualPort = await getPort(from, to);
     // If did specify a port but did not get that one, fail hard.
     if (desiredPort && desiredPort !== actualPort) {
         throw new Error(`You specified port ${desiredPort} to be used for the HTTP server, but it is not available. Choose a different port or remove the setting to let Remotion automatically select a free port.`);
     }
-    return actualPort;
-};
-const limit = (0, p_limit_1.pLimit)(1);
-const getDesiredPort = (desiredPort, from, to) => {
-    return limit(() => getDesiredPortUnlimited(desiredPort, from, to));
+    return { port: actualPort, didUsePort };
 };
 exports.getDesiredPort = getDesiredPort;
 const makeRange = (from, to) => {

package/dist/get-video-threads-flag.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIdealVideoThreadsFlag = void 0;
-const os_1 = __importDefault(require("os"));
+const node_os_1 = __importDefault(require("node:os"));
 const MEMORY_USAGE_PER_THREAD = 400000000; // 400MB
 const RESERVED_MEMORY = 2000000000;
 const getIdealVideoThreadsFlag = () => {
-    const freeMemory = os_1.default.freemem();
-    const cpus = os_1.default.cpus().length;
+    const freeMemory = node_os_1.default.freemem();
+    const cpus = node_os_1.default.cpus().length;
     const maxRecommendedBasedOnCpus = (cpus * 2) / 3;
     const maxRecommendedBasedOnMemory = (freeMemory - RESERVED_MEMORY) / MEMORY_USAGE_PER_THREAD;
     const maxRecommended = Math.min(maxRecommendedBasedOnCpus, maxRecommendedBasedOnMemory);

package/dist/guess-extension-for-media.d.ts

@@ -1 +1,3 @@
-export declare const guessExtensionForVideo: (src: string) => Promise<"mp3" | "wav" | "webm" | "mp4">;
+export declare const guessExtensionForVideo: ({ src }: {
+    src: string;
+}) => Promise<"mp3" | "wav" | "mp4" | "webm">;

package/dist/guess-extension-for-media.js

@@ -1,13 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.guessExtensionForVideo = void 0;
-const execa_1 = __importDefault(require("execa"));
-const guessExtensionForVideo = async (src) => {
-    const { stderr } = await (0, execa_1.default)('ffprobe', [src]);
-    if (stderr.includes('mp3,')) {
+const call_ffmpeg_1 = require("./call-ffmpeg");
+const guessExtensionForVideo = async ({ src }) => {
+    const { stderr } = await (0, call_ffmpeg_1.callFf)('ffprobe', [src]);
+    if (stderr.includes('Audio: mp3,')) {
         return 'mp3';
     }
     if (stderr.includes('Video: vp9')) {

package/dist/image-format.d.ts

@@ -1,7 +1,13 @@
 import type { PixelFormat } from './pixel-format';
-export declare const validImageFormats: readonly ["png", "jpeg", "none"];
-export declare type ImageFormat = typeof validImageFormats[number];
-export declare type StillImageFormat = 'png' | 'jpeg';
-export declare const DEFAULT_IMAGE_FORMAT: ImageFormat;
-export declare const validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: PixelFormat, imageFormat: ImageFormat) => 'none' | 'valid';
-export declare const validateNonNullImageFormat: (imageFormat: ImageFormat) => void;
+export declare const validVideoImageFormats: readonly ["png", "jpeg", "none"];
+export declare const validStillImageFormats: readonly ["png", "jpeg", "pdf", "webp"];
+export type VideoImageFormat = typeof validVideoImageFormats[number];
+export type StillImageFormat = typeof validStillImageFormats[number];
+/**
+ * @deprecated Use VideoImageFormat or StillImageFormat instead
+ */
+export type ImageFormat = 'This type is deprecated, use VideoImageFormat or StillImageFormat instead';
+export declare const DEFAULT_VIDEO_IMAGE_FORMAT: VideoImageFormat;
+export declare const DEFAULT_STILL_IMAGE_FORMAT: StillImageFormat;
+export declare const validateSelectedPixelFormatAndImageFormatCombination: (pixelFormat: PixelFormat | undefined, videoImageFormat: VideoImageFormat) => 'none' | 'valid';
+export declare const validateStillImageFormat: (imageFormat: StillImageFormat) => void;

package/dist/image-format.js

@@ -2,30 +2,36 @@
 // Keeping the default image format PNG if you don't pass a
 // value to the renderer for backwards compatibility.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateNonNullImageFormat = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.DEFAULT_IMAGE_FORMAT = exports.validImageFormats = void 0;
-exports.validImageFormats = ['png', 'jpeg', 'none'];
-// However, the CLI will override it and use JPEG if suitable.
-exports.DEFAULT_IMAGE_FORMAT = 'png';
+exports.validateStillImageFormat = exports.validateSelectedPixelFormatAndImageFormatCombination = exports.DEFAULT_STILL_IMAGE_FORMAT = exports.DEFAULT_VIDEO_IMAGE_FORMAT = exports.validStillImageFormats = exports.validVideoImageFormats = void 0;
+exports.validVideoImageFormats = ['png', 'jpeg', 'none'];
+exports.validStillImageFormats = ['png', 'jpeg', 'pdf', 'webp'];
+exports.DEFAULT_VIDEO_IMAGE_FORMAT = 'jpeg';
+exports.DEFAULT_STILL_IMAGE_FORMAT = 'png';
 // By returning a value, we improve testability as we can specifically test certain branches
-const validateSelectedPixelFormatAndImageFormatCombination = (pixelFormat, imageFormat) => {
-    if (imageFormat === 'none') {
+const validateSelectedPixelFormatAndImageFormatCombination = (pixelFormat, videoImageFormat) => {
+    if (videoImageFormat === 'none') {
         return 'none';
     }
-    if (!exports.validImageFormats.includes(imageFormat)) {
-        throw new TypeError(`Value ${imageFormat} is not valid as an image format.`);
+    if (typeof pixelFormat === 'undefined') {
+        return 'valid';
+    }
+    if (!exports.validVideoImageFormats.includes(videoImageFormat)) {
+        throw new TypeError(`Value ${videoImageFormat} is not valid as an image format.`);
     }
     if (pixelFormat !== 'yuva420p' && pixelFormat !== 'yuva444p10le') {
         return 'valid';
     }
-    if (imageFormat !== 'png') {
+    if (videoImageFormat !== 'png') {
         throw new TypeError(`Pixel format was set to '${pixelFormat}' but the image format is not PNG. To render transparent videos, you need to set PNG as the image format.`);
     }
     return 'valid';
 };
 exports.validateSelectedPixelFormatAndImageFormatCombination = validateSelectedPixelFormatAndImageFormatCombination;
-const validateNonNullImageFormat = (imageFormat) => {
-    if (imageFormat !== 'jpeg' && imageFormat !== 'png') {
-        throw new TypeError('Image format should be either "png" or "jpeg"');
+const validateStillImageFormat = (imageFormat) => {
+    if (!exports.validStillImageFormats.includes(imageFormat)) {
+        throw new TypeError(String(`Image format should be one of: ${exports.validStillImageFormats
+            .map((v) => `"${v}"`)
+            .join(', ')}`));
     }
 };
-exports.validateNonNullImageFormat = validateNonNullImageFormat;
+exports.validateStillImageFormat = validateStillImageFormat;