@remotion/renderer 4.0.357 → 4.0.358

package/package/dist/ensure-browser.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureBrowser = exports.internalEnsureBrowser = void 0;
+const fs_1 = __importDefault(require("fs"));
+const BrowserFetcher_1 = require("./browser/BrowserFetcher");
+const browser_download_progress_bar_1 = require("./browser/browser-download-progress-bar");
+let currentEnsureBrowserOperation = Promise.resolve();
+const internalEnsureBrowserUncapped = async ({ indent, logLevel, browserExecutable, onBrowserDownload, chromeMode, }) => {
+    const status = getBrowserStatus({ browserExecutable, chromeMode });
+    if (status.type === 'no-browser') {
+        const { onProgress, version } = onBrowserDownload({ chromeMode });
+        await (0, BrowserFetcher_1.downloadBrowser)({ indent, logLevel, onProgress, version, chromeMode });
+    }
+    const newStatus = getBrowserStatus({ browserExecutable, chromeMode });
+    return newStatus;
+};
+const internalEnsureBrowser = (options) => {
+    currentEnsureBrowserOperation = currentEnsureBrowserOperation.then(() => internalEnsureBrowserUncapped(options));
+    return currentEnsureBrowserOperation;
+};
+exports.internalEnsureBrowser = internalEnsureBrowser;
+const getBrowserStatus = ({ browserExecutable, chromeMode, }) => {
+    if (browserExecutable) {
+        if (!fs_1.default.existsSync(browserExecutable)) {
+            throw new Error(`"browserExecutable" was specified as '${browserExecutable}' but the path doesn't exist. Pass "null" for "browserExecutable" to download a browser automatically.`);
+        }
+        return { path: browserExecutable, type: 'user-defined-path' };
+    }
+    const revision = (0, BrowserFetcher_1.getRevisionInfo)(chromeMode);
+    if (revision.local && fs_1.default.existsSync(revision.executablePath)) {
+        return { path: revision.executablePath, type: 'local-puppeteer-browser' };
+    }
+    return { type: 'no-browser' };
+};
+/*
+ * @description Ensures a browser is locally installed so a Remotion render can be executed.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-browser)
+ */
+const ensureBrowser = (options) => {
+    var _a, _b, _c, _d, _e;
+    const indent = false;
+    const logLevel = (_a = options === null || options === void 0 ? void 0 : options.logLevel) !== null && _a !== void 0 ? _a : 'info';
+    return (0, exports.internalEnsureBrowser)({
+        browserExecutable: (_b = options === null || options === void 0 ? void 0 : options.browserExecutable) !== null && _b !== void 0 ? _b : null,
+        indent,
+        logLevel: (_c = options === null || options === void 0 ? void 0 : options.logLevel) !== null && _c !== void 0 ? _c : 'info',
+        onBrowserDownload: (_d = options === null || options === void 0 ? void 0 : options.onBrowserDownload) !== null && _d !== void 0 ? _d : (0, browser_download_progress_bar_1.defaultBrowserDownloadProgress)({
+            api: 'ensureBrowser()',
+            indent: false,
+            logLevel,
+        }),
+        chromeMode: (_e = options === null || options === void 0 ? void 0 : options.chromeMode) !== null && _e !== void 0 ? _e : 'headless-shell',
+    });
+};
+exports.ensureBrowser = ensureBrowser;

package/package/dist/ensure-frames-in-order.d.ts

@@ -0,0 +1,5 @@
+export declare const ensureFramesInOrder: (framesToRender: number[]) => {
+    waitForRightTimeOfFrameToBeInserted: (frameToBe: number) => Promise<void>;
+    setFrameToStitch: (f: number) => void;
+    waitForFinish: () => Promise<void>;
+};

package/package/dist/ensure-frames-in-order.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFramesInOrder = void 0;
+const ensureFramesInOrder = (framesToRender) => {
+    let [frameToStitch] = framesToRender;
+    const finalFrame = framesToRender[framesToRender.length - 1];
+    let waiters = [];
+    const resolveWaiters = () => {
+        for (const waiter of waiters.slice(0)) {
+            if (frameToStitch === waiter.forFrame) {
+                waiter.resolve();
+                waiters = waiters.filter((w) => w.id !== waiter.id);
+            }
+        }
+    };
+    const waitForRightTimeOfFrameToBeInserted = (frameToBe) => {
+        return new Promise((resolve) => {
+            waiters.push({
+                id: String(Math.random()),
+                forFrame: frameToBe,
+                resolve,
+            });
+            resolveWaiters();
+        });
+    };
+    const setFrameToStitch = (f) => {
+        frameToStitch = f;
+        resolveWaiters();
+    };
+    const waitForFinish = async () => {
+        await waitForRightTimeOfFrameToBeInserted(finalFrame + 1);
+    };
+    return {
+        waitForRightTimeOfFrameToBeInserted,
+        setFrameToStitch,
+        waitForFinish,
+    };
+};
+exports.ensureFramesInOrder = ensureFramesInOrder;

package/package/dist/ensure-output-directory.d.ts

@@ -0,0 +1 @@
+export declare const ensureOutputDirectory: (outputLocation: string) => void;

package/package/dist/ensure-output-directory.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.ensureOutputDirectory = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const ensureOutputDirectory = (outputLocation) => {
+    const dirName = node_path_1.default.dirname(outputLocation);
+    if (!node_fs_1.default.existsSync(dirName)) {
+        node_fs_1.default.mkdirSync(dirName, {
+            recursive: true,
+        });
+    }
+};
+exports.ensureOutputDirectory = ensureOutputDirectory;

package/package/dist/error-handling/handle-javascript-exception.d.ts

@@ -0,0 +1,23 @@
+import type { Page } from '../browser/BrowserPage';
+import type { SymbolicatedStackFrame } from '../symbolicate-stacktrace';
+export declare class ErrorWithStackFrame extends Error {
+    symbolicatedStackFrames: SymbolicatedStackFrame[] | null;
+    frame: number | null;
+    chunk: number | null;
+    name: string;
+    delayRenderCall: SymbolicatedStackFrame[] | null;
+    constructor({ message, symbolicatedStackFrames, frame, name, delayRenderCall, stack, chunk, }: {
+        message: string;
+        symbolicatedStackFrames: SymbolicatedStackFrame[] | null;
+        frame: number | null;
+        chunk: number | null;
+        name: string;
+        delayRenderCall: SymbolicatedStackFrame[] | null;
+        stack: string | undefined;
+    });
+}
+export declare const handleJavascriptException: ({ page, onError, frame, }: {
+    page: Page;
+    frame: number | null;
+    onError: (err: Error) => void;
+}) => () => Promise<void>;

package/package/dist/error-handling/handle-javascript-exception.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleJavascriptException = exports.ErrorWithStackFrame = void 0;
+const no_react_1 = require("remotion/no-react");
+const symbolicateable_error_1 = require("./symbolicateable-error");
+class ErrorWithStackFrame extends Error {
+    constructor({ message, symbolicatedStackFrames, frame, name, delayRenderCall, stack, chunk, }) {
+        super(message);
+        this.symbolicatedStackFrames = symbolicatedStackFrames;
+        this.frame = frame;
+        this.chunk = chunk;
+        this.name = name;
+        this.delayRenderCall = delayRenderCall;
+        // If error symbolication did not yield any stack frames, we print the original stack
+        this.stack = stack;
+    }
+}
+exports.ErrorWithStackFrame = ErrorWithStackFrame;
+const cleanUpErrorMessage = (exception) => {
+    var _a, _b, _c, _d;
+    let errorMessage = (_a = exception.exceptionDetails.exception) === null || _a === void 0 ? void 0 : _a.description;
+    if (!errorMessage) {
+        return null;
+    }
+    const errorType = (_b = exception.exceptionDetails.exception) === null || _b === void 0 ? void 0 : _b.className;
+    const prefix = `${errorType}: `;
+    if (errorMessage.startsWith(prefix)) {
+        errorMessage = errorMessage.substring(prefix.length);
+    }
+    const frames = (_d = (_c = exception.exceptionDetails.stackTrace) === null || _c === void 0 ? void 0 : _c.callFrames.length) !== null && _d !== void 0 ? _d : 0;
+    const split = errorMessage.split('\n');
+    return split.slice(0, Math.max(1, split.length - frames)).join('\n');
+};
+const removeDelayRenderStack = (message) => {
+    const index = message.indexOf(no_react_1.NoReactInternals.DELAY_RENDER_CALLSTACK_TOKEN);
+    if (index === -1) {
+        return message;
+    }
+    return message.substring(0, index);
+};
+const callFrameToStackFrame = (callFrame) => {
+    return {
+        columnNumber: callFrame.columnNumber,
+        fileName: callFrame.url,
+        functionName: callFrame.functionName,
+        lineNumber: callFrame.lineNumber,
+    };
+};
+const handleJavascriptException = ({ page, onError, frame, }) => {
+    const client = page._client();
+    const handler = (exception) => {
+        var _a, _b, _c;
+        const rawErrorMessage = (_a = exception.exceptionDetails.exception) === null || _a === void 0 ? void 0 : _a.description;
+        const cleanErrorMessage = cleanUpErrorMessage(exception);
+        if (!cleanErrorMessage) {
+            // eslint-disable-next-line no-console
+            console.error(exception);
+            const err = new Error(rawErrorMessage);
+            err.stack = rawErrorMessage;
+            onError(err);
+            return;
+        }
+        if (!exception.exceptionDetails.stackTrace) {
+            const err = new Error(removeDelayRenderStack(cleanErrorMessage));
+            err.stack = rawErrorMessage;
+            onError(err);
+            return;
+        }
+        const errorType = (_b = exception.exceptionDetails.exception) === null || _b === void 0 ? void 0 : _b.className;
+        const symbolicatedErr = new symbolicateable_error_1.SymbolicateableError({
+            message: removeDelayRenderStack(cleanErrorMessage),
+            stackFrame: exception.exceptionDetails.stackTrace.callFrames.map((f) => callFrameToStackFrame(f)),
+            frame,
+            name: errorType,
+            stack: (_c = exception.exceptionDetails.exception) === null || _c === void 0 ? void 0 : _c.description,
+            chunk: null,
+        });
+        onError(symbolicatedErr);
+    };
+    client.on('Runtime.exceptionThrown', handler);
+    return () => {
+        client.off('Runtime.exceptionThrown', handler);
+        return Promise.resolve();
+    };
+};
+exports.handleJavascriptException = handleJavascriptException;

package/package/dist/error-handling/symbolicate-error.d.ts

@@ -0,0 +1,3 @@
+import { ErrorWithStackFrame } from './handle-javascript-exception';
+import type { SymbolicateableError } from './symbolicateable-error';
+export declare const symbolicateError: (symbolicateableError: SymbolicateableError) => Promise<ErrorWithStackFrame>;

package/package/dist/error-handling/symbolicate-error.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.symbolicateError = void 0;
+const symbolicate_stacktrace_1 = require("../symbolicate-stacktrace");
+const truthy_1 = require("../truthy");
+const handle_javascript_exception_1 = require("./handle-javascript-exception");
+const symbolicateError = async (symbolicateableError) => {
+    const { delayRenderCall, stackFrame } = symbolicateableError;
+    const [mainErrorFrames, delayRenderFrames] = await Promise.all([
+        stackFrame ? (0, symbolicate_stacktrace_1.symbolicateStackTraceFromRemoteFrames)(stackFrame) : null,
+        delayRenderCall
+            ? (0, symbolicate_stacktrace_1.symbolicateStackTraceFromRemoteFrames)(delayRenderCall)
+            : null,
+    ].filter(truthy_1.truthy));
+    const symbolicatedErr = new handle_javascript_exception_1.ErrorWithStackFrame({
+        message: symbolicateableError.message,
+        symbolicatedStackFrames: mainErrorFrames,
+        frame: symbolicateableError.frame,
+        name: symbolicateableError.name,
+        delayRenderCall: delayRenderFrames,
+        stack: symbolicateableError.stack,
+        chunk: symbolicateableError.chunk,
+    });
+    return symbolicatedErr;
+};
+exports.symbolicateError = symbolicateError;

package/package/dist/error-handling/symbolicateable-error.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A symbolicateable error is an error that can be symolicated by fetching the original sources. By throwing a symbolicateable error, Remotion CLI will attempt to symplicate it
+ */
+import type { UnsymbolicatedStackFrame } from '../parse-browser-error-stack';
+export declare class SymbolicateableError extends Error {
+    stackFrame: UnsymbolicatedStackFrame[] | null;
+    delayRenderCall: UnsymbolicatedStackFrame[] | null;
+    frame: number | null;
+    chunk: number | null;
+    constructor({ message, stack, stackFrame, frame, name, chunk, }: {
+        message: string;
+        stack: string | undefined;
+        frame: number | null;
+        name: string;
+        stackFrame: UnsymbolicatedStackFrame[] | null;
+        chunk: number | null;
+    });
+}

package/package/dist/error-handling/symbolicateable-error.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * A symbolicateable error is an error that can be symolicated by fetching the original sources. By throwing a symbolicateable error, Remotion CLI will attempt to symplicate it
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolicateableError = void 0;
+const delay_render_embedded_stack_1 = require("../delay-render-embedded-stack");
+class SymbolicateableError extends Error {
+    constructor({ message, stack, stackFrame, frame, name, chunk, }) {
+        super(message);
+        this.stack = stack;
+        this.stackFrame = stackFrame;
+        this.frame = frame;
+        this.chunk = chunk;
+        this.name = name;
+        this.delayRenderCall = stack ? (0, delay_render_embedded_stack_1.parseDelayRenderEmbeddedStack)(stack) : null;
+    }
+}
+exports.SymbolicateableError = SymbolicateableError;

package/package/dist/error-handling.d.ts

@@ -0,0 +1 @@
+export { wrapWithErrorHandling } from './wrap-with-error-handling';

package/package/dist/error-handling.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapWithErrorHandling = void 0;
+var wrap_with_error_handling_1 = require("./wrap-with-error-handling");
+Object.defineProperty(exports, "wrapWithErrorHandling", { enumerable: true, get: function () { return wrap_with_error_handling_1.wrapWithErrorHandling; } });