@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/select-composition.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectComposition = exports.internalSelectComposition = exports.internalSelectCompositionRaw = void 0;
+const no_react_1 = require("remotion/no-react");
+const _1 = require(".");
+const TimeoutSettings_1 = require("./browser/TimeoutSettings");
+const browser_download_progress_bar_1 = require("./browser/browser-download-progress-bar");
+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 logger_1 = require("./logger");
+const get_available_memory_1 = require("./memory/get-available-memory");
+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 wrap_with_error_handling_1 = require("./wrap-with-error-handling");
+const innerSelectComposition = async ({ page, serializedInputPropsWithCustomSchema, envVariables, serveUrl, timeoutInMilliseconds, port, id, indent, logLevel, onServeUrlVisited, mediaCacheSizeInBytes, }) => {
+    (0, validate_puppeteer_timeout_1.validatePuppeteerTimeout)(timeoutInMilliseconds);
+    await (0, set_props_and_env_1.setPropsAndEnv)({
+        serializedInputPropsWithCustomSchema,
+        envVariables,
+        page,
+        serveUrl,
+        initialFrame: 0,
+        timeoutInMilliseconds,
+        proxyPort: port,
+        retriesRemaining: 2,
+        audioEnabled: false,
+        videoEnabled: false,
+        indent,
+        logLevel,
+        onServeUrlVisited,
+        isMainTab: true,
+        mediaCacheSizeInBytes,
+        initialMemoryAvailable: (0, get_available_memory_1.getAvailableMemory)(logLevel),
+    });
+    await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+        page,
+        pageFunction: () => {
+            window.remotion_setBundleMode({
+                type: 'evaluation',
+            });
+        },
+        frame: null,
+        args: [],
+        timeoutInMilliseconds,
+    });
+    await (0, seek_to_frame_1.waitForReady)({
+        page,
+        timeoutInMilliseconds,
+        frame: null,
+        logLevel,
+        indent,
+    });
+    logger_1.Log.verbose({
+        indent,
+        tag: 'selectComposition()',
+        logLevel,
+    }, 'Running calculateMetadata()...');
+    const time = Date.now();
+    const { value: result, size } = await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+        pageFunction: (_id) => {
+            return window.remotion_calculateComposition(_id);
+        },
+        frame: null,
+        page,
+        args: [id],
+        timeoutInMilliseconds,
+    });
+    logger_1.Log.verbose({
+        indent,
+        tag: 'selectComposition()',
+        logLevel,
+    }, `calculateMetadata() took ${Date.now() - time}ms`);
+    const res = result;
+    const { width, durationInFrames, fps, height, defaultCodec, defaultOutName, defaultVideoImageFormat, defaultPixelFormat, } = res;
+    return {
+        metadata: {
+            id,
+            width,
+            height,
+            fps,
+            durationInFrames,
+            props: no_react_1.NoReactInternals.deserializeJSONWithSpecialTypes(res.serializedResolvedPropsWithCustomSchema),
+            defaultProps: no_react_1.NoReactInternals.deserializeJSONWithSpecialTypes(res.serializedDefaultPropsWithCustomSchema),
+            defaultCodec,
+            defaultOutName,
+            defaultVideoImageFormat,
+            defaultPixelFormat,
+        },
+        propsSize: size,
+    };
+};
+const internalSelectCompositionRaw = async (options) => {
+    const cleanup = [];
+    const { puppeteerInstance, browserExecutable, chromiumOptions, serveUrl: serveUrlOrWebpackUrl, logLevel, indent, port, envVariables, id, serializedInputPropsWithCustomSchema, onBrowserLog, server, timeoutInMilliseconds, offthreadVideoCacheSizeInBytes, binariesDirectory, onBrowserDownload, onServeUrlVisited, chromeMode, mediaCacheSizeInBytes, } = options;
+    const [{ page, cleanupPage }, serverUsed] = await Promise.all([
+        (0, get_browser_instance_1.getPageAndCleanupFn)({
+            passedInInstance: puppeteerInstance,
+            browserExecutable,
+            chromiumOptions,
+            forceDeviceScaleFactor: undefined,
+            indent,
+            logLevel,
+            onBrowserDownload,
+            chromeMode,
+            pageIndex: 0,
+            onBrowserLog,
+            onLog: _1.RenderInternals.defaultOnLog,
+        }),
+        (0, prepare_server_1.makeOrReuseServer)(options.server, {
+            webpackConfigOrServeUrl: serveUrlOrWebpackUrl,
+            port,
+            remotionRoot: (0, find_closest_package_json_1.findRemotionRoot)(),
+            offthreadVideoThreads: 0,
+            logLevel,
+            indent,
+            offthreadVideoCacheSizeInBytes,
+            binariesDirectory,
+            forceIPv4: false,
+        }, {
+            onDownload: () => undefined,
+        }).then((result) => {
+            cleanup.push(() => result.cleanupServer(true));
+            return result;
+        }),
+    ]);
+    cleanup.push(() => cleanupPage());
+    return new Promise((resolve, reject) => {
+        const onError = (err) => reject(err);
+        cleanup.push((0, handle_javascript_exception_1.handleJavascriptException)({
+            page,
+            frame: null,
+            onError,
+        }));
+        page.setBrowserSourceMapGetter(serverUsed.server.sourceMap);
+        innerSelectComposition({
+            serveUrl: serverUsed.server.serveUrl,
+            page,
+            port: serverUsed.server.offthreadPort,
+            browserExecutable,
+            chromiumOptions,
+            envVariables,
+            id,
+            serializedInputPropsWithCustomSchema,
+            timeoutInMilliseconds,
+            logLevel,
+            indent,
+            puppeteerInstance,
+            server,
+            offthreadVideoCacheSizeInBytes,
+            binariesDirectory,
+            onBrowserDownload,
+            onServeUrlVisited,
+            chromeMode,
+            mediaCacheSizeInBytes,
+        })
+            .then((data) => {
+            return resolve(data);
+        })
+            .catch((err) => {
+            reject(err);
+        })
+            .finally(() => {
+            cleanup.forEach((c) => {
+                // Must prevent unhandled exception in cleanup function.
+                // Promise has already been resolved, so we can't reject it.
+                c().catch((err) => {
+                    logger_1.Log.error({ indent, logLevel }, 'Cleanup error:', err);
+                });
+            });
+        });
+    });
+};
+exports.internalSelectCompositionRaw = internalSelectCompositionRaw;
+exports.internalSelectComposition = (0, wrap_with_error_handling_1.wrapWithErrorHandling)(exports.internalSelectCompositionRaw);
+/*
+ * @description Evaluates the list of compositions from a Remotion Bundle by evaluating the Remotion Root and evaluating `calculateMetadata()` on the specified composition.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/select-composition)
+ */
+const selectComposition = async (options) => {
+    const { id, serveUrl, browserExecutable, chromiumOptions, envVariables, inputProps, onBrowserLog, port, puppeteerInstance, timeoutInMilliseconds, verbose, logLevel: passedLogLevel, offthreadVideoCacheSizeInBytes, binariesDirectory, onBrowserDownload, chromeMode, offthreadVideoThreads, mediaCacheSizeInBytes, } = options;
+    const indent = false;
+    const logLevel = passedLogLevel !== null && passedLogLevel !== void 0 ? passedLogLevel : (verbose ? 'verbose' : 'info');
+    const data = await (0, exports.internalSelectComposition)({
+        id,
+        serveUrl,
+        browserExecutable: browserExecutable !== null && browserExecutable !== void 0 ? browserExecutable : null,
+        chromiumOptions: chromiumOptions !== null && chromiumOptions !== void 0 ? chromiumOptions : {},
+        envVariables: envVariables !== null && envVariables !== void 0 ? envVariables : {},
+        serializedInputPropsWithCustomSchema: no_react_1.NoReactInternals.serializeJSONWithSpecialTypes({
+            indent: undefined,
+            staticBase: null,
+            data: inputProps !== null && inputProps !== void 0 ? inputProps : {},
+        }).serializedString,
+        onBrowserLog: onBrowserLog !== null && onBrowserLog !== void 0 ? onBrowserLog : null,
+        port: port !== null && port !== void 0 ? port : null,
+        puppeteerInstance,
+        timeoutInMilliseconds: timeoutInMilliseconds !== null && timeoutInMilliseconds !== void 0 ? timeoutInMilliseconds : TimeoutSettings_1.DEFAULT_TIMEOUT,
+        logLevel,
+        indent,
+        server: undefined,
+        offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes !== null && offthreadVideoCacheSizeInBytes !== void 0 ? offthreadVideoCacheSizeInBytes : null,
+        binariesDirectory: binariesDirectory !== null && binariesDirectory !== void 0 ? binariesDirectory : null,
+        onBrowserDownload: onBrowserDownload !== null && onBrowserDownload !== void 0 ? onBrowserDownload : (0, browser_download_progress_bar_1.defaultBrowserDownloadProgress)({
+            indent,
+            logLevel,
+            api: 'selectComposition()',
+        }),
+        onServeUrlVisited: () => undefined,
+        chromeMode: chromeMode !== null && chromeMode !== void 0 ? chromeMode : 'headless-shell',
+        offthreadVideoThreads: offthreadVideoThreads !== null && offthreadVideoThreads !== void 0 ? offthreadVideoThreads : null,
+        mediaCacheSizeInBytes: mediaCacheSizeInBytes !== null && mediaCacheSizeInBytes !== void 0 ? mediaCacheSizeInBytes : null,
+    });
+    return data.metadata;
+};
+exports.selectComposition = selectComposition;

package/package/dist/serialize-artifact.d.ts

@@ -0,0 +1,7 @@
+import type { DownloadBehavior } from 'remotion';
+export type EmittedArtifact = {
+    filename: string;
+    content: string | Uint8Array;
+    frame: number;
+    downloadBehavior: DownloadBehavior | null;
+};

package/package/dist/serialize-artifact.js

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

package/package/dist/serve-handler/index.d.ts

@@ -0,0 +1,4 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare const serveHandler: (request: IncomingMessage, response: ServerResponse, config: {
+    public: string;
+}) => Promise<void>;

package/package/dist/serve-handler/index.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveHandler = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const mime_types_1 = require("../mime-types");
+// Packages
+const is_path_inside_1 = require("./is-path-inside");
+const range_parser_1 = require("./range-parser");
+const getHeaders = (absolutePath, stats) => {
+    const { base } = node_path_1.default.parse(absolutePath);
+    let defaultHeaders = {};
+    if (stats) {
+        defaultHeaders = {
+            'Content-Length': String(stats.size),
+            'Accept-Ranges': 'bytes',
+        };
+        defaultHeaders['Last-Modified'] = stats.mtime.toUTCString();
+        const _contentType = (0, mime_types_1.mimeContentType)(base);
+        if (_contentType) {
+            defaultHeaders['Content-Type'] = _contentType;
+        }
+    }
+    return defaultHeaders;
+};
+const getPossiblePaths = (relativePath, extension) => [
+    node_path_1.default.join(relativePath, `index${extension}`),
+    relativePath.endsWith('/')
+        ? relativePath.replace(/\/$/g, extension)
+        : relativePath + extension,
+].filter((item) => node_path_1.default.basename(item) !== extension);
+const findRelated = async (current, relativePath) => {
+    const possible = getPossiblePaths(relativePath, '.html');
+    let stats = null;
+    for (let index = 0; index < possible.length; index++) {
+        const related = possible[index];
+        const absolutePath = node_path_1.default.join(current, related);
+        try {
+            stats = await node_fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                throw err;
+            }
+        }
+        if (stats) {
+            return {
+                stats,
+                absolutePath,
+            };
+        }
+    }
+    return null;
+};
+const sendError = (absolutePath, response, spec) => {
+    const { message, statusCode } = spec;
+    const headers = getHeaders(absolutePath, null);
+    response.writeHead(statusCode, {
+        ...headers,
+        'Content-Type': 'application/json',
+    });
+    response.end(JSON.stringify({ statusCode, message }));
+};
+const internalError = (absolutePath, response) => {
+    return sendError(absolutePath, response, {
+        statusCode: 500,
+        code: 'internal_server_error',
+        message: 'A server error has occurred',
+    });
+};
+const serveHandler = async (request, response, config) => {
+    const cwd = process.cwd();
+    const current = node_path_1.default.resolve(cwd, config.public);
+    let relativePath = null;
+    try {
+        const parsedUrl = new URL(request.url, `http://${request.headers.host}`);
+        relativePath = decodeURIComponent(parsedUrl.pathname);
+    }
+    catch (_a) {
+        return sendError('/', response, {
+            statusCode: 400,
+            code: 'bad_request',
+            message: 'Bad Request',
+        });
+    }
+    let absolutePath = node_path_1.default.join(current, relativePath);
+    // Prevent path traversal vulnerabilities. We could do this
+    // by ourselves, but using the package covers all the edge cases.
+    if (!(0, is_path_inside_1.isPathInside)(absolutePath, current)) {
+        return sendError(absolutePath, response, {
+            statusCode: 400,
+            code: 'bad_request',
+            message: 'Bad Request',
+        });
+    }
+    let stats = null;
+    // It's extremely important that we're doing multiple stat calls. This one
+    // right here could technically be removed, but then the program
+    // would be slower. Because for directories, we always want to see if a related file
+    // exists and then (after that), fetch the directory itself if no
+    // related file was found. However (for files, of which most have extensions), we should
+    // always stat right away.
+    //
+    // When simulating a file system without directory indexes, calculating whether a
+    // directory exists requires loading all the file paths and then checking if
+    // one of them includes the path of the directory. As that's a very
+    // performance-expensive thing to do, we need to ensure it's not happening if not really necessary.
+    if (node_path_1.default.extname(relativePath) !== '') {
+        try {
+            stats = await node_fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+    }
+    if (!stats) {
+        try {
+            const related = await findRelated(current, relativePath);
+            if (related) {
+                stats = related.stats;
+                absolutePath = related.absolutePath;
+            }
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+        try {
+            stats = await node_fs_1.promises.lstat(absolutePath);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT' &&
+                err.code !== 'ENOTDIR') {
+                return internalError(absolutePath, response);
+            }
+        }
+    }
+    if (stats === null || stats === void 0 ? void 0 : stats.isDirectory()) {
+        const directory = null;
+        const singleFile = null;
+        if (directory) {
+            const _contentType = 'text/html; charset=utf-8';
+            response.statusCode = 200;
+            response.setHeader('Content-Type', _contentType);
+            response.end('Is a directory');
+            return;
+        }
+        if (!singleFile) {
+            // The directory listing is disabled, so we want to
+            // render a 404 error.
+            stats = null;
+        }
+    }
+    const isSymLink = stats === null || stats === void 0 ? void 0 : stats.isSymbolicLink();
+    // There are two scenarios in which we want to reply with
+    // a 404 error: Either the path does not exist, or it is a
+    // symlink while the `symlinks` option is disabled (which it is by default).
+    if (!stats || isSymLink) {
+        // allow for custom 404 handling
+        return sendError(absolutePath, response, {
+            statusCode: 404,
+            code: 'not_found',
+            message: 'The requested path (' + absolutePath + ') could not be found',
+        });
+    }
+    let streamOpts = null;
+    if (request.headers.range && stats.size) {
+        const range = (0, range_parser_1.rangeParser)(stats.size, request.headers.range);
+        if (typeof range === 'object' && range.type === 'bytes') {
+            const { start, end } = range.ranges[0];
+            streamOpts = {
+                start,
+                end,
+            };
+            response.statusCode = 206;
+        }
+        else {
+            response.statusCode = 416;
+            response.setHeader('Content-Range', `bytes */${stats.size}`);
+        }
+    }
+    let stream = null;
+    try {
+        stream = (0, node_fs_1.createReadStream)(absolutePath, streamOpts !== null && streamOpts !== void 0 ? streamOpts : {});
+    }
+    catch (_b) {
+        return internalError(absolutePath, response);
+    }
+    const headers = getHeaders(absolutePath, stats);
+    if (streamOpts !== null) {
+        headers['Content-Range'] =
+            `bytes ${streamOpts.start}-${streamOpts.end}/${stats.size}`;
+        headers['Content-Length'] = String(streamOpts.end - streamOpts.start + 1);
+    }
+    headers['Cache-Control'] = 'no-cache, no-store, must-revalidate';
+    response.writeHead(response.statusCode || 200, headers);
+    stream.pipe(response);
+};
+exports.serveHandler = serveHandler;

package/package/dist/serve-handler/is-path-inside.d.ts

@@ -0,0 +1 @@
+export declare const isPathInside: (thePath: string, potentialParent: string) => boolean;

package/package/dist/serve-handler/is-path-inside.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathInside = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const isPathInside = function (thePath, potentialParent) {
+    // For inside-directory checking, we want to allow trailing slashes, so normalize.
+    thePath = stripTrailingSep(thePath);
+    potentialParent = stripTrailingSep(potentialParent);
+    // Node treats only Windows as case-insensitive in its path module; we follow those conventions.
+    if (process.platform === 'win32') {
+        thePath = thePath.toLowerCase();
+        potentialParent = potentialParent.toLowerCase();
+    }
+    return (thePath.lastIndexOf(potentialParent, 0) === 0 &&
+        (thePath[potentialParent.length] === node_path_1.default.sep ||
+            thePath[potentialParent.length] === undefined));
+};
+exports.isPathInside = isPathInside;
+function stripTrailingSep(thePath) {
+    if (thePath[thePath.length - 1] === node_path_1.default.sep) {
+        return thePath.slice(0, -1);
+    }
+    return thePath;
+}

package/package/dist/serve-handler/range-parser.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+export declare const rangeParser: (size: number, str: string) => {
+    type: string;
+    ranges: {
+        start: number;
+        end: number;
+    }[];
+} | -1 | -2;

package/package/dist/serve-handler/range-parser.js

@@ -0,0 +1,57 @@
+"use strict";
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rangeParser = void 0;
+const rangeParser = (size, str) => {
+    if (typeof str !== 'string') {
+        throw new TypeError('argument str must be a string');
+    }
+    const index = str.indexOf('=');
+    if (index === -1) {
+        return -2;
+    }
+    // split the range string
+    const arr = str.slice(index + 1).split(',');
+    const ranges = [];
+    // add ranges type
+    const type = str.slice(0, index);
+    // parse all ranges
+    for (let i = 0; i < arr.length; i++) {
+        const range = arr[i].split('-');
+        let start = parseInt(range[0], 10);
+        let end = parseInt(range[1], 10);
+        // -nnn
+        if (isNaN(start)) {
+            start = size - end;
+            end = size - 1;
+            // nnn-
+        }
+        else if (isNaN(end)) {
+            end = size - 1;
+        }
+        // limit last-byte-pos to current length
+        if (end > size - 1) {
+            end = size - 1;
+        }
+        // invalid or unsatisifiable
+        if (isNaN(start) || isNaN(end) || start > end || start < 0) {
+            continue;
+        }
+        // add range
+        ranges.push({
+            start,
+            end,
+        });
+    }
+    if (ranges.length < 1) {
+        // unsatisifiable
+        return -1;
+    }
+    return { ranges, type };
+};
+exports.rangeParser = rangeParser;

package/package/dist/serve-static.d.ts

@@ -0,0 +1,18 @@
+import type { DownloadMap } from './assets/download-map';
+import type { Compositor } from './compositor/compositor';
+import type { LogLevel } from './log-level';
+export declare const serveStatic: (path: string | null, options: {
+    port: number | null;
+    downloadMap: DownloadMap;
+    remotionRoot: string;
+    offthreadVideoThreads: number;
+    logLevel: LogLevel;
+    indent: boolean;
+    offthreadVideoCacheSizeInBytes: number | null;
+    binariesDirectory: string | null;
+    forceIPv4: boolean;
+}) => Promise<{
+    port: number;
+    close: () => Promise<void>;
+    compositor: Compositor;
+}>;