@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/repro.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReproEnabled = exports.disableRepro = exports.enableRepro = exports.writeInRepro = exports.getReproWriter = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importStar(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const version_1 = require("remotion/version");
+const chalk_1 = require("./chalk");
+const find_closest_package_json_1 = require("./find-closest-package-json");
+const is_serve_url_1 = require("./is-serve-url");
+const logger_1 = require("./logger");
+const REPRO_DIR = '.remotionrepro';
+const LOG_FILE_NAME = 'logs.txt';
+const INPUT_DIR = 'bundle';
+const OUTPUT_DIR = 'output';
+const LINE_SPLIT = '\n';
+const getZipFileName = (name) => `remotion-repro-${name}-${Date.now()}.zip`;
+const readyDirSync = (dir) => {
+    let items;
+    try {
+        items = node_fs_1.default.readdirSync(dir);
+    }
+    catch (_a) {
+        return node_fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    items.forEach((item) => {
+        item = node_path_1.default.join(dir, item);
+        node_fs_1.default.rmSync(item, { recursive: true, force: true });
+    });
+};
+const zipFolder = ({ sourceFolder, targetZip, indent, logLevel, }) => {
+    const platform = node_os_1.default.platform();
+    try {
+        logger_1.Log.info({ indent, logLevel }, '+ Creating reproduction ZIP');
+        if (platform === 'win32') {
+            (0, node_child_process_1.execSync)(`powershell.exe Compress-Archive -Path "${sourceFolder}" -DestinationPath "${targetZip}"`);
+        }
+        else {
+            (0, node_child_process_1.execSync)(`zip -r "${targetZip}" "${sourceFolder}"`);
+        }
+        (0, node_fs_1.rmSync)(sourceFolder, { recursive: true });
+        logger_1.Log.info({ indent, logLevel }, `${chalk_1.chalk.blue(`+ Repro: ${targetZip}`)}`);
+    }
+    catch (error) {
+        logger_1.Log.error({ indent, logLevel }, `Failed to zip repro folder, The repro folder is ${sourceFolder}. You can try manually zip it.`);
+        logger_1.Log.error({ indent, logLevel }, error);
+    }
+};
+const reproWriter = (name) => {
+    const root = (0, find_closest_package_json_1.findRemotionRoot)();
+    const reproFolder = node_path_1.default.join(root, REPRO_DIR);
+    const logPath = node_path_1.default.join(reproFolder, LOG_FILE_NAME);
+    const zipFile = node_path_1.default.join(root, getZipFileName(name));
+    readyDirSync(reproFolder);
+    const reproLogWriteStream = node_fs_1.default.createWriteStream(logPath, { flags: 'a' });
+    const serializeArgs = (args) => JSON.stringify(args);
+    const writeLine = (level, ...args) => {
+        if (!args.length)
+            return;
+        const startTime = new Date().toISOString();
+        const line = `[${startTime}] ${level} ${serializeArgs(args)}`;
+        reproLogWriteStream.write(line + LINE_SPLIT);
+    };
+    const start = ({ serveUrl, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema, }) => {
+        const isServe = (0, is_serve_url_1.isServeUrl)(serveUrl);
+        if (!isServe) {
+            const inputDir = node_path_1.default.resolve(reproFolder, INPUT_DIR);
+            readyDirSync(inputDir);
+            node_fs_1.default.cpSync(serveUrl, inputDir, { recursive: true });
+        }
+        const serializedProps = node_path_1.default.resolve(reproFolder, 'input-props.json');
+        node_fs_1.default.writeFileSync(serializedProps, serializedInputPropsWithCustomSchema);
+        const serializedResolvedProps = node_path_1.default.resolve(reproFolder, 'resolved-props.json');
+        node_fs_1.default.writeFileSync(serializedResolvedProps, serializedResolvedPropsWithCustomSchema);
+        writeLine('info', [`Args: ${JSON.stringify(process.argv)}`]);
+        writeLine('info', [`Node/Bun version: ${process.version}`]);
+        writeLine('info', [`OS: ${process.platform}-${process.arch}`]);
+        writeLine('info', [`Serve URL: ${serveUrl}`]);
+        writeLine('info', [`Remotion version: ${version_1.VERSION}`]);
+    };
+    const onRenderSucceed = ({ indent, logLevel, output, }) => {
+        return new Promise((resolve, reject) => {
+            try {
+                if (output) {
+                    const outputDir = node_path_1.default.resolve(reproFolder, OUTPUT_DIR);
+                    readyDirSync(outputDir);
+                    const fileName = node_path_1.default.basename(output);
+                    const targetPath = node_path_1.default.join(outputDir, fileName);
+                    node_fs_1.default.copyFileSync(output, targetPath);
+                }
+                (0, exports.disableRepro)();
+                reproLogWriteStream.end(() => {
+                    reproLogWriteStream.close(() => {
+                        zipFolder({
+                            sourceFolder: reproFolder,
+                            targetZip: zipFile,
+                            indent,
+                            logLevel,
+                        });
+                        resolve();
+                    });
+                });
+            }
+            catch (error) {
+                logger_1.Log.error({ indent: false, logLevel }, `repro render success error:`);
+                logger_1.Log.error({ indent: false, logLevel }, error);
+                reject(error);
+            }
+        });
+    };
+    return {
+        start,
+        writeLine,
+        onRenderSucceed,
+    };
+};
+let reproWriteInstance = null;
+const getReproWriter = () => {
+    if (!reproWriteInstance) {
+        throw new Error('reproWriteInstance is not initialized');
+    }
+    return reproWriteInstance;
+};
+exports.getReproWriter = getReproWriter;
+const writeInRepro = (level, ...args) => {
+    if ((0, exports.isReproEnabled)()) {
+        (0, exports.getReproWriter)().writeLine(level, ...args);
+    }
+};
+exports.writeInRepro = writeInRepro;
+let shouldRepro = false;
+const enableRepro = ({ serveUrl, compositionName, serializedInputPropsWithCustomSchema, serializedResolvedPropsWithCustomSchema, }) => {
+    shouldRepro = true;
+    reproWriteInstance = reproWriter(compositionName);
+    (0, exports.getReproWriter)().start({
+        serveUrl,
+        serializedInputPropsWithCustomSchema,
+        serializedResolvedPropsWithCustomSchema,
+    });
+};
+exports.enableRepro = enableRepro;
+const disableRepro = () => {
+    shouldRepro = false;
+};
+exports.disableRepro = disableRepro;
+const isReproEnabled = () => shouldRepro;
+exports.isReproEnabled = isReproEnabled;

package/package/dist/resolve-asset-src.d.ts

@@ -0,0 +1 @@
+export declare const resolveAssetSrc: (src: string) => string;

package/package/dist/resolve-asset-src.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAssetSrc = void 0;
+const node_url_1 = __importDefault(require("node:url"));
+const resolveAssetSrc = (src) => {
+    if (!src.startsWith('file:')) {
+        return src;
+    }
+    const { protocol } = new URL(src);
+    if (protocol === 'file:')
+        return node_url_1.default.fileURLToPath(src);
+    throw new TypeError(`Unexpected src ${src}`);
+};
+exports.resolveAssetSrc = resolveAssetSrc;

package/package/dist/sample-rate.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_SAMPLE_RATE = 48000;

package/package/dist/sample-rate.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SAMPLE_RATE = void 0;
+exports.DEFAULT_SAMPLE_RATE = 48000;

package/package/dist/screenshot-task.d.ts

@@ -0,0 +1,12 @@
+import type { Page } from './browser/BrowserPage';
+import type { StillImageFormat } from './image-format';
+export declare const screenshotTask: ({ format, height, omitBackground, page, width, path, jpegQuality, scale, }: {
+    page: Page;
+    format: StillImageFormat;
+    path?: string;
+    jpegQuality?: number;
+    omitBackground: boolean;
+    width: number;
+    height: number;
+    scale: number;
+}) => Promise<Buffer>;

package/package/dist/screenshot-task.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.screenshotTask = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const perf_1 = require("./perf");
+const screenshotTask = async ({ format, height, omitBackground, page, width, path, jpegQuality, scale, }) => {
+    var _a;
+    const client = page._client();
+    const target = page.target();
+    await client.send('Target.activateTarget', {
+        targetId: target._targetId,
+    });
+    if (omitBackground) {
+        await client.send('Emulation.setDefaultBackgroundColorOverride', {
+            color: { r: 0, g: 0, b: 0, a: 0 },
+        });
+    }
+    const cap = (0, perf_1.startPerfMeasure)('capture');
+    try {
+        let result;
+        if (format === 'pdf') {
+            const res = await client.send('Page.printToPDF', {
+                paperWidth: width / 96, // Convert to Inch
+                paperHeight: height / 96, // Convert to Inch
+                marginTop: 0,
+                marginBottom: 0,
+                marginLeft: 0,
+                marginRight: 0,
+                scale: 1,
+                printBackground: true,
+            });
+            result = res.value;
+        }
+        else {
+            // We find that there is a 0.1% framedrop when rendering under memory pressure
+            // which can be circumvented by disabling this option on Lambda.
+            // To be determined: Is this a problem with Lambda, or the Chrome version
+            // we are using on Lambda?
+            // We already found out that the problem is not a general Linux problem.
+            // However, if `fromSurface` is false, the screenshot is limited to 8192x8192 pixels.
+            // If the image is larger, always use `fromSurface: true`.
+            const fromSurface = !process.env.DISABLE_FROM_SURFACE || height > 8192 || width > 8192;
+            const scaleFactor = fromSurface ? 1 : scale;
+            const { value } = await client.send('Page.captureScreenshot', {
+                format,
+                quality: jpegQuality,
+                clip: {
+                    x: 0,
+                    y: 0,
+                    height: height * scaleFactor,
+                    scale: 1,
+                    width: width * scaleFactor,
+                },
+                captureBeyondViewport: true,
+                optimizeForSpeed: true,
+                fromSurface,
+            });
+            result = value;
+        }
+        (0, perf_1.stopPerfMeasure)(cap);
+        if (omitBackground) {
+            await client.send('Emulation.setDefaultBackgroundColorOverride');
+        }
+        const buffer = Buffer.from(result.data, 'base64');
+        if (path) {
+            await node_fs_1.default.promises.writeFile(path, buffer);
+        }
+        return buffer;
+    }
+    catch (err) {
+        if (err.message.includes('Unable to capture screenshot')) {
+            const errMessage = [
+                'Could not take a screenshot because Google Chrome ran out of memory or disk space.',
+                ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.__RESERVED_IS_INSIDE_REMOTION_LAMBDA)
+                    ? 'Deploy a new Lambda function with more memory or disk space.'
+                    : 'Decrease the concurrency to use less RAM.',
+            ].join(' ');
+            throw new Error(errMessage);
+        }
+        throw err;
+    }
+};
+exports.screenshotTask = screenshotTask;

package/package/dist/seamless-aac-trim.d.ts

@@ -0,0 +1,12 @@
+export declare const getActualTrimLeft: ({ fps, trimLeftOffset, seamless, assetDuration, audioStartFrame, trimLeft, playbackRate, }: {
+    trimLeft: number;
+    audioStartFrame: number;
+    fps: number;
+    trimLeftOffset: number;
+    seamless: boolean;
+    assetDuration: number | null;
+    playbackRate: number;
+}) => {
+    trimLeft: number;
+    maxTrim: number | null;
+};

package/package/dist/seamless-aac-trim.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActualTrimLeft = void 0;
+const getActualTrimLeft = ({ fps, trimLeftOffset, seamless, assetDuration, audioStartFrame, trimLeft, playbackRate, }) => {
+    const sinceStart = trimLeft - audioStartFrame;
+    if (!seamless) {
+        return {
+            trimLeft: audioStartFrame / fps +
+                (sinceStart / fps) * playbackRate +
+                trimLeftOffset,
+            maxTrim: assetDuration,
+        };
+    }
+    if (seamless) {
+        return {
+            trimLeft: audioStartFrame / fps / playbackRate +
+                sinceStart / fps +
+                trimLeftOffset,
+            maxTrim: assetDuration ? assetDuration / playbackRate : null,
+        };
+    }
+    throw new Error('This should never happen');
+};
+exports.getActualTrimLeft = getActualTrimLeft;

package/package/dist/seek-to-frame.d.ts

@@ -0,0 +1,18 @@
+import type { Page } from './browser/BrowserPage';
+import type { LogLevel } from './log-level';
+export declare const waitForReady: ({ page, timeoutInMilliseconds, frame, indent, logLevel, }: {
+    page: Page;
+    timeoutInMilliseconds: number;
+    frame: number | null;
+    indent: boolean;
+    logLevel: LogLevel;
+}) => Promise<unknown>;
+export declare const seekToFrame: ({ frame, page, composition, timeoutInMilliseconds, logLevel, indent, attempt, }: {
+    frame: number;
+    composition: string;
+    page: Page;
+    timeoutInMilliseconds: number;
+    logLevel: LogLevel;
+    indent: boolean;
+    attempt: number;
+}) => Promise<void>;

package/package/dist/seek-to-frame.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seekToFrame = exports.waitForReady = void 0;
+const symbolicateable_error_1 = require("./error-handling/symbolicateable-error");
+const logger_1 = require("./logger");
+const parse_browser_error_stack_1 = require("./parse-browser-error-stack");
+const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const cancelledToken = 'cancelled';
+const readyToken = 'ready';
+const waitForReady = ({ page, timeoutInMilliseconds, frame, indent, logLevel, }) => {
+    const cleanups = [];
+    const retrieveCancelledErrorAndReject = () => {
+        return new Promise((_, reject) => {
+            (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+                pageFunction: () => window.remotion_cancelledError,
+                args: [],
+                frame: null,
+                page,
+                timeoutInMilliseconds,
+            })
+                .then(({ value: val }) => {
+                if (typeof val !== 'string') {
+                    reject(val);
+                    return;
+                }
+                reject(new symbolicateable_error_1.SymbolicateableError({
+                    frame: null,
+                    stack: val,
+                    name: 'CancelledError',
+                    message: val.split('\n')[0],
+                    stackFrame: (0, parse_browser_error_stack_1.parseStack)(val.split('\n')),
+                    chunk: null,
+                }));
+            })
+                .catch((err) => {
+                logger_1.Log.verbose({ indent, logLevel }, 'Could not get cancelled error', err);
+                reject(new Error('Render was cancelled using cancelRender()'));
+            });
+        });
+    };
+    const waitForReadyProm = new Promise((resolve, reject) => {
+        const waitTask = page.mainFrame()._mainWorld.waitForFunction({
+            browser: page.browser,
+            // Increase timeout so the delayRender() timeout fires earlier
+            timeout: timeoutInMilliseconds + 3000,
+            pageFunction: `window.remotion_renderReady === true ? "${readyToken}" : window.remotion_cancelledError !== undefined ? "${cancelledToken}" : false`,
+            title: frame === null
+                ? 'the page to render the React component'
+                : `the page to render the React component at frame ${frame}`,
+        });
+        cleanups.push(() => {
+            waitTask.terminate(new Error('cleanup'));
+        });
+        waitTask.promise
+            .then((a) => {
+            const token = a.toString();
+            if (token === cancelledToken) {
+                return retrieveCancelledErrorAndReject();
+            }
+            if (token === readyToken) {
+                return resolve(a);
+            }
+            reject(new Error('Unexpected token ' + token));
+        })
+            .catch((err) => {
+            if (err.message.includes('timeout') &&
+                err.message.includes('exceeded')) {
+                (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatchAndTimeout)({
+                    pageFunction: () => {
+                        return Object.keys(window.remotion_delayRenderTimeouts)
+                            .map((id, i) => {
+                            const { label } = window.remotion_delayRenderTimeouts[id];
+                            if (label === null) {
+                                return `${i + 1}. (no label)`;
+                            }
+                            return `"${i + 1}. ${label}"`;
+                        })
+                            .join(', ');
+                    },
+                    args: [],
+                    frame,
+                    page,
+                    timeoutInMilliseconds: 5000,
+                })
+                    .then((res) => {
+                    reject(new Error(`Timeout (${timeoutInMilliseconds}ms) exceeded rendering the component${frame ? ' at frame ' + frame : ' initially'}. ${res.value ? `Open delayRender() handles: ${res.value}` : ''}. You can increase the timeout using the "timeoutInMilliseconds" / "--timeout" option of the function or command you used to trigger this render.`));
+                })
+                    .catch((newErr) => {
+                    logger_1.Log.warn({ indent, logLevel }, 'Tried to get delayRender() handles for timeout, but could not do so because of', newErr);
+                    // Ignore, use prev error
+                    reject(err);
+                });
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+    const onDisposedPromise = new Promise((_, reject) => {
+        const onDispose = () => {
+            reject(new Error('Target closed (page disposed)'));
+        };
+        page.on("disposed" /* PageEmittedEvents.Disposed */, onDispose);
+        cleanups.push(() => {
+            page.off("disposed" /* PageEmittedEvents.Disposed */, onDispose);
+        });
+    });
+    const onClosedSilentPromise = new Promise((_, reject) => {
+        const onClosedSilent = () => {
+            reject(new Error('Target closed'));
+        };
+        page.browser.on("closed-silent" /* BrowserEmittedEvents.ClosedSilent */, onClosedSilent);
+        cleanups.push(() => {
+            page.browser.off("closed-silent" /* BrowserEmittedEvents.ClosedSilent */, onClosedSilent);
+        });
+    });
+    return Promise.race([
+        onDisposedPromise,
+        onClosedSilentPromise,
+        waitForReadyProm,
+    ]).finally(() => {
+        cleanups.forEach((cleanup) => {
+            cleanup();
+        });
+    });
+};
+exports.waitForReady = waitForReady;
+const seekToFrame = async ({ frame, page, composition, timeoutInMilliseconds, logLevel, indent, attempt, }) => {
+    await (0, exports.waitForReady)({
+        page,
+        timeoutInMilliseconds,
+        frame: null,
+        indent,
+        logLevel,
+    });
+    await (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatchAndTimeout)({
+        pageFunction: (f, c, a) => {
+            window.remotion_setFrame(f, c, a);
+        },
+        args: [frame, composition, attempt],
+        frame,
+        page,
+        timeoutInMilliseconds,
+    });
+    await (0, exports.waitForReady)({ page, timeoutInMilliseconds, frame, indent, logLevel });
+    await page.evaluateHandle('document.fonts.ready');
+};
+exports.seekToFrame = seekToFrame;

package/package/dist/select-composition.d.ts

@@ -0,0 +1,45 @@
+import type { VideoConfig } from 'remotion/no-react';
+import type { BrowserExecutable } from './browser-executable';
+import type { BrowserLog } from './browser-log';
+import type { HeadlessBrowser } from './browser/Browser';
+import type { ChromiumOptions } from './open-browser';
+import type { ToOptions } from './options/option';
+import type { optionsMap } from './options/options-map';
+import type { RemotionServer } from './prepare-server';
+import type { RequiredInputPropsInV5 } from './v5-required-input-props';
+type InternalSelectCompositionsConfig = {
+    serializedInputPropsWithCustomSchema: string;
+    envVariables: Record<string, string>;
+    puppeteerInstance: HeadlessBrowser | undefined;
+    onBrowserLog: null | ((log: BrowserLog) => void);
+    browserExecutable: BrowserExecutable | null;
+    chromiumOptions: ChromiumOptions;
+    port: number | null;
+    indent: boolean;
+    server: RemotionServer | undefined;
+    serveUrl: string;
+    id: string;
+    onServeUrlVisited: () => void;
+} & ToOptions<typeof optionsMap.selectComposition>;
+export type SelectCompositionOptions = RequiredInputPropsInV5 & {
+    envVariables?: Record<string, string>;
+    puppeteerInstance?: HeadlessBrowser;
+    onBrowserLog?: (log: BrowserLog) => void;
+    browserExecutable?: BrowserExecutable;
+    chromiumOptions?: ChromiumOptions;
+    port?: number | null;
+    /**
+     * @deprecated Use `logLevel` instead.
+     */
+    verbose?: boolean;
+    serveUrl: string;
+    id: string;
+} & Partial<ToOptions<typeof optionsMap.selectComposition>>;
+type InternalReturnType = {
+    metadata: VideoConfig;
+    propsSize: number;
+};
+export declare const internalSelectCompositionRaw: (options: InternalSelectCompositionsConfig) => Promise<InternalReturnType>;
+export declare const internalSelectComposition: (options: InternalSelectCompositionsConfig) => Promise<InternalReturnType>;
+export declare const selectComposition: (options: SelectCompositionOptions) => Promise<VideoConfig>;
+export {};