@remotion/cli 4.0.0-fastlambda.8 → 4.0.0-forcepublish.7

package/dist/preview-server/dev-middleware/range-parser.js

@@ -0,0 +1,96 @@
+"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.parseRange = void 0;
+function parseRange(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
+    ranges.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) {
+        return -1;
+    }
+    return combineRanges(ranges);
+}
+exports.parseRange = parseRange;
+function combineRanges(ranges) {
+    const ordered = ranges.map(mapWithIndex).sort(sortByRangeStart);
+    let j = 0;
+    for (let i = 1; i < ordered.length; i++) {
+        const range = ordered[i];
+        const current = ordered[j];
+        if (range.start > current.end + 1) {
+            // next range
+            ordered[++j] = range;
+        }
+        else if (range.end > current.end) {
+            // extend range
+            current.end = range.end;
+            current.index = Math.min(current.index, range.index);
+        }
+    }
+    ordered.length = j + 1;
+    const combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex);
+    combined.type = ranges.type;
+    return combined;
+}
+function mapWithIndex(range, index) {
+    return {
+        start: range.start,
+        end: range.end,
+        index,
+    };
+}
+function mapWithoutIndex(range) {
+    return {
+        start: range.start,
+        end: range.end,
+    };
+}
+function sortByRangeIndex(a, b) {
+    return a.index - b.index;
+}
+function sortByRangeStart(a, b) {
+    return a.start - b.start;
+}

package/dist/preview-server/dev-middleware/ready.d.ts

@@ -0,0 +1,3 @@
+import type { webpack } from '@remotion/bundler';
+import type { DevMiddlewareContext } from './types';
+export declare function ready(context: DevMiddlewareContext, callback: (stats: webpack.Stats | undefined) => undefined | Promise<void>): void;

package/dist/preview-server/dev-middleware/ready.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ready = void 0;
+function ready(context, callback) {
+    if (context.state) {
+        callback(context.stats);
+        return;
+    }
+    context.callbacks.push(callback);
+}
+exports.ready = ready;

package/dist/preview-server/dev-middleware/setup-hooks.d.ts

@@ -0,0 +1,2 @@
+import type { DevMiddlewareContext } from './types';
+export declare function setupHooks(context: DevMiddlewareContext): void;

package/dist/preview-server/dev-middleware/setup-hooks.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupHooks = void 0;
+const log_1 = require("../../log");
+const is_color_supported_1 = require("./is-color-supported");
+function setupHooks(context) {
+    function invalid() {
+        // We are now in invalid state
+        context.state = false;
+        context.stats = undefined;
+    }
+    function done(stats) {
+        context.state = true;
+        context.stats = stats;
+        // Do the stuff in nextTick, because bundle may be invalidated if a change happened while compiling
+        process.nextTick(() => {
+            const { logger, state, callbacks } = context;
+            // Check if still in valid state
+            if (!state || !stats) {
+                return;
+            }
+            logger.log('Compilation finished');
+            const statsOptions = {
+                preset: 'normal',
+                colors: is_color_supported_1.isColorSupported,
+            };
+            const printedStats = stats.toString(statsOptions);
+            // Avoid extra empty line when `stats: 'none'`
+            if (printedStats) {
+                log_1.Log.info(printedStats);
+            }
+            context.callbacks = [];
+            callbacks.forEach((callback) => {
+                callback(stats);
+            });
+        });
+    }
+    context.compiler.hooks.watchRun.tap('remotion', invalid);
+    context.compiler.hooks.invalid.tap('remotion', invalid);
+    context.compiler.hooks.done.tap('remotion', done);
+}
+exports.setupHooks = setupHooks;

package/dist/preview-server/dev-middleware/setup-output-filesystem.d.ts

@@ -0,0 +1,2 @@
+import type { DevMiddlewareContext } from './types';
+export declare function setupOutputFileSystem(context: DevMiddlewareContext): void;

package/dist/preview-server/dev-middleware/setup-output-filesystem.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupOutputFileSystem = void 0;
+const memfs_1 = __importDefault(require("memfs"));
+function setupOutputFileSystem(context) {
+    const outputFileSystem = memfs_1.default.createFsFromVolume(new memfs_1.default.Volume());
+    context.compiler.outputFileSystem = outputFileSystem;
+    context.outputFileSystem = outputFileSystem;
+}
+exports.setupOutputFileSystem = setupOutputFileSystem;

package/dist/preview-server/dev-middleware/types.d.ts

@@ -0,0 +1,10 @@
+import type { webpack } from '@remotion/bundler';
+import type memfs from 'memfs';
+export declare type DevMiddlewareContext = {
+    state: boolean;
+    stats: webpack.Stats | undefined;
+    callbacks: ((stats: webpack.Stats) => undefined | Promise<void>)[];
+    compiler: webpack.Compiler;
+    logger: ReturnType<webpack.Compiler['getInfrastructureLogger']>;
+    outputFileSystem: memfs.IFs | undefined;
+};

package/dist/preview-server/dev-middleware/types.js

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

package/dist/preview-server/error-overlay/entry-basic.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/preview-server/error-overlay/entry-basic.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_overlay_1 = require("./react-overlay");
+const remotion_overlay_1 = require("./remotion-overlay");
+const Overlay_1 = require("./remotion-overlay/Overlay");
+(0, react_overlay_1.startReportingRuntimeErrors)(() => {
+    if (module.hot) {
+        module.hot.addStatusHandler((status) => {
+            var _a;
+            if (status === 'apply') {
+                if ((0, react_overlay_1.didUnmountReactApp)()) {
+                    return window.location.reload();
+                }
+                (_a = Overlay_1.setErrorsRef.current) === null || _a === void 0 ? void 0 : _a.setErrors({
+                    type: 'clear',
+                });
+            }
+        });
+    }
+});
+(0, remotion_overlay_1.mountRemotionOverlay)();

package/dist/preview-server/error-overlay/react-overlay/effects/format-warning.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { ReactFrame } from './proxy-console';
+export declare function massageWarning(warning: string, frames: ReactFrame[]): {
+    message: string;
+    stack: string;
+};

package/dist/preview-server/error-overlay/react-overlay/effects/format-warning.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.massageWarning = void 0;
+function stripInlineStacktrace(message) {
+    return message
+        .split('\n')
+        .filter((line) => !line.match(/^\s*in/))
+        .join('\n'); // "  in Foo"
+}
+function massageWarning(warning, frames) {
+    const message = stripInlineStacktrace(warning);
+    // Reassemble the stack with full filenames provided by React
+    let stack = '';
+    let lastFilename;
+    let lastLineNumber;
+    for (let index = 0; index < frames.length; ++index) {
+        const { fileName, lineNumber } = frames[index];
+        if (fileName === null ||
+            lineNumber === null ||
+            lineNumber === undefined ||
+            fileName === undefined) {
+            continue;
+        }
+        if (fileName === lastFilename &&
+            typeof lineNumber === 'number' &&
+            typeof lastLineNumber === 'number' &&
+            Math.abs(lineNumber - lastLineNumber) < 3) {
+            continue;
+        }
+        lastFilename = fileName;
+        lastLineNumber = lineNumber;
+        let { name } = frames[index];
+        name = name || '(anonymous function)';
+        stack += `in ${name} (at ${fileName}:${lineNumber})\n`;
+    }
+    return { message, stack };
+}
+exports.massageWarning = massageWarning;

package/dist/preview-server/error-overlay/react-overlay/effects/map-error-to-react-stack.d.ts

@@ -0,0 +1,7 @@
+export declare type ErrorLocation = {
+    fileName: string;
+    columnNumber: number;
+    lineNumber: number;
+    message: string;
+};
+export declare const getLocationFromBuildError: (err: Error) => ErrorLocation | null;

package/dist/preview-server/error-overlay/react-overlay/effects/map-error-to-react-stack.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocationFromBuildError = void 0;
+const truthy_1 = require("../../../../truthy");
+const getLocationFromBuildError = (err) => {
+    var _a;
+    if (!err.stack) {
+        return null;
+    }
+    if (!err.stack.startsWith('Error: Module build failed') &&
+        !err.stack.startsWith('Error: Cannot find module')) {
+        return null;
+    }
+    const split = err.stack.split('\n');
+    return ((_a = split
+        .map((s) => {
+        if (s.startsWith('Error')) {
+            return null;
+        }
+        const matchWebpackOrEsbuild = s.match(/(.*):([0-9]+):([0-9]+): (.*)/);
+        if (matchWebpackOrEsbuild) {
+            return {
+                fileName: matchWebpackOrEsbuild[1],
+                lineNumber: Number(matchWebpackOrEsbuild[2]),
+                columnNumber: Number(matchWebpackOrEsbuild[3]),
+                message: matchWebpackOrEsbuild[4],
+            };
+        }
+        const matchMissingModule = s.match(/\s+at(.*)\s\((.*)\)/);
+        if (!matchMissingModule) {
+            return null;
+        }
+        if (s.includes('webpackMissingModule')) {
+            return null;
+        }
+        const [, filename] = matchMissingModule;
+        return {
+            columnNumber: 0,
+            lineNumber: 1,
+            message: split[0],
+            fileName: filename.trim(),
+        };
+    })
+        .filter(truthy_1.truthy)[0]) !== null && _a !== void 0 ? _a : null);
+};
+exports.getLocationFromBuildError = getLocationFromBuildError;

package/dist/preview-server/error-overlay/react-overlay/effects/proxy-console.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare type ReactFrame = {
+    fileName: string | null;
+    lineNumber: number | null;
+    name: string | null;
+};
+declare const registerReactStack: () => void;
+declare const unregisterReactStack: () => void;
+declare type ErrorData = {
+    type: 'webpack-error';
+    message: string;
+    frames: ReactFrame[];
+} | {
+    type: 'build-error';
+    error: Error;
+};
+declare type ConsoleProxyCallback = (data: ErrorData) => void;
+declare const permanentRegister: (type: 'error', callback: ConsoleProxyCallback) => void;
+export { permanentRegister, registerReactStack, unregisterReactStack };

package/dist/preview-server/error-overlay/react-overlay/effects/proxy-console.js

@@ -0,0 +1,64 @@
+"use strict";
+/* eslint-disable no-console */
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterReactStack = exports.registerReactStack = exports.permanentRegister = void 0;
+const reactFrameStack = [];
+// This is a stripped down barebones version of this proposal:
+// https://gist.github.com/sebmarkbage/bdefa100f19345229d526d0fdd22830f
+// We're implementing just enough to get the invalid element type warnings
+// to display the component stack in React 15.6+:
+// https://github.com/facebook/react/pull/9679
+const registerReactStack = () => {
+    if (typeof console !== 'undefined') {
+        // @ts-expect-error
+        console.reactStack = (frames) => reactFrameStack.push(frames);
+        // @ts-expect-error
+        console.reactStackEnd = () => reactFrameStack.pop();
+    }
+};
+exports.registerReactStack = registerReactStack;
+const unregisterReactStack = () => {
+    if (typeof console !== 'undefined') {
+        // @ts-expect-error
+        console.reactStack = undefined;
+        // @ts-expect-error
+        console.reactStackEnd = undefined;
+    }
+};
+exports.unregisterReactStack = unregisterReactStack;
+const permanentRegister = function (type, callback) {
+    if (typeof console !== 'undefined') {
+        const orig = console[type];
+        if (typeof orig === 'function') {
+            console[type] = function (...args) {
+                try {
+                    const message = args[0];
+                    if (typeof message === 'string' && reactFrameStack.length > 0) {
+                        callback({
+                            type: 'webpack-error',
+                            message,
+                            frames: reactFrameStack[reactFrameStack.length - 1],
+                        });
+                    }
+                    if (message instanceof Error) {
+                        callback({
+                            type: 'build-error',
+                            error: message,
+                        });
+                    }
+                }
+                catch (err) {
+                    // Warnings must never crash. Rethrow with a clean stack.
+                    setTimeout(() => {
+                        throw err;
+                    });
+                }
+                return orig.apply(this, args);
+            };
+        }
+    }
+};
+exports.permanentRegister = permanentRegister;

package/dist/preview-server/error-overlay/react-overlay/effects/resolve-file-source.d.ts

@@ -0,0 +1,3 @@
+import type { SymbolicatedStackFrame } from '../utils/stack-frame';
+import type { ErrorLocation } from './map-error-to-react-stack';
+export declare const resolveFileSource: (location: ErrorLocation, contextLines: number) => Promise<SymbolicatedStackFrame>;

package/dist/preview-server/error-overlay/react-overlay/effects/resolve-file-source.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFileSource = void 0;
+const resolveFileSource = async (location, contextLines) => {
+    const res = await fetch(`/api/file-source?f=${encodeURIComponent(location.fileName)}`);
+    const text = await res.text();
+    const lines = text
+        .split('\n')
+        .map((l, i) => {
+        const oneIndexedLineNumber = i + 1;
+        return [oneIndexedLineNumber, l];
+    })
+        .filter(([oneIndexedLineNumber]) => {
+        return (Math.abs(oneIndexedLineNumber - location.lineNumber) <= contextLines);
+    });
+    const scriptCode = lines.map(([num, line]) => {
+        return {
+            content: line,
+            highlight: location.lineNumber === num,
+            lineNumber: num,
+        };
+    });
+    return {
+        originalColumnNumber: location.columnNumber,
+        originalFunctionName: null,
+        originalFileName: location.fileName,
+        originalLineNumber: location.lineNumber,
+        originalScriptCode: scriptCode,
+    };
+};
+exports.resolveFileSource = resolveFileSource;

package/dist/preview-server/error-overlay/react-overlay/effects/stack-trace-limit.d.ts

@@ -0,0 +1,3 @@
+declare function registerStackTraceLimit(limit?: number): void;
+declare function unregisterStackTraceLimit(): void;
+export { registerStackTraceLimit as register, unregisterStackTraceLimit as unregister, };

package/dist/preview-server/error-overlay/react-overlay/effects/stack-trace-limit.js

@@ -0,0 +1,43 @@
+"use strict";
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregister = exports.register = void 0;
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+let stackTraceRegistered = false;
+// Default: https://docs.microsoft.com/en-us/scripting/javascript/reference/stacktracelimit-property-error-javascript
+let restoreStackTraceValue = 10;
+const MAX_STACK_LENGTH = 50;
+function registerStackTraceLimit(limit = MAX_STACK_LENGTH) {
+    if (stackTraceRegistered) {
+        return;
+    }
+    try {
+        restoreStackTraceValue = Error.stackTraceLimit;
+        Error.stackTraceLimit = limit;
+        stackTraceRegistered = true;
+    }
+    catch (e) {
+        // Not all browsers support this so we don't care if it errors
+    }
+}
+exports.register = registerStackTraceLimit;
+function unregisterStackTraceLimit() {
+    if (!stackTraceRegistered) {
+        return;
+    }
+    try {
+        Error.stackTraceLimit = restoreStackTraceValue;
+        stackTraceRegistered = false;
+    }
+    catch (e) {
+        // Not all browsers support this so we don't care if it errors
+    }
+}
+exports.unregister = unregisterStackTraceLimit;

package/dist/preview-server/error-overlay/react-overlay/effects/unhandled-error.d.ts

@@ -0,0 +1,4 @@
+declare type ErrorCallback = (error: Error) => void;
+declare function registerUnhandledError(target: EventTarget, callback: ErrorCallback): void;
+declare function unregisterUnhandledError(target: EventTarget): void;
+export { registerUnhandledError as register, unregisterUnhandledError as unregister, };

package/dist/preview-server/error-overlay/react-overlay/effects/unhandled-error.js

@@ -0,0 +1,45 @@
+"use strict";
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregister = exports.register = void 0;
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+let boundErrorHandler = null;
+function errorHandler(callback, e) {
+    // @ts-expect-error
+    if (!e.error) {
+        return;
+    }
+    // @ts-expect-error
+    const { error } = e;
+    if (error instanceof Error) {
+        callback(error);
+    }
+    else {
+        // A non-error was thrown, we don't have a trace. :(
+        // Look in your browser's devtools for more information
+        callback(new Error(error));
+    }
+}
+function registerUnhandledError(target, callback) {
+    if (boundErrorHandler !== null) {
+        return;
+    }
+    boundErrorHandler = errorHandler.bind(undefined, callback);
+    target.addEventListener('error', boundErrorHandler);
+}
+exports.register = registerUnhandledError;
+function unregisterUnhandledError(target) {
+    if (boundErrorHandler === null) {
+        return;
+    }
+    target.removeEventListener('error', boundErrorHandler);
+    boundErrorHandler = null;
+}
+exports.unregister = unregisterUnhandledError;

package/dist/preview-server/error-overlay/react-overlay/effects/unhandled-rejection.d.ts

@@ -0,0 +1,4 @@
+declare type ErrorCallback = (error: Error) => void;
+declare function registerUnhandledRejection(target: EventTarget, callback: ErrorCallback): void;
+declare function unregisterUnhandledRejection(target: EventTarget): void;
+export { registerUnhandledRejection as register, unregisterUnhandledRejection as unregister, };

package/dist/preview-server/error-overlay/react-overlay/effects/unhandled-rejection.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+    Source code adapted from https://github.com/facebook/create-react-app/tree/main/packages/react-error-overlay and refactored in Typescript. This file is MIT-licensed.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregister = exports.register = void 0;
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+let boundRejectionHandler = null;
+function rejectionHandler(callback, e) {
+    if (!(e === null || e === void 0 ? void 0 : e.reason)) {
+        return callback(new Error('Unknown'));
+    }
+    const { reason } = e;
+    if (reason instanceof Error) {
+        return callback(reason);
+    }
+    // A non-error was rejected, we don't have a trace :(
+    // Look in your browser's devtools for more information
+    return callback(new Error(reason));
+}
+function registerUnhandledRejection(target, callback) {
+    if (boundRejectionHandler !== null) {
+        return;
+    }
+    boundRejectionHandler = rejectionHandler.bind(undefined, callback);
+    target.addEventListener('unhandledrejection', boundRejectionHandler);
+}
+exports.register = registerUnhandledRejection;
+function unregisterUnhandledRejection(target) {
+    if (boundRejectionHandler === null) {
+        return;
+    }
+    target.removeEventListener('unhandledrejection', boundRejectionHandler);
+    boundRejectionHandler = null;
+}
+exports.unregister = unregisterUnhandledRejection;

package/dist/preview-server/error-overlay/react-overlay/index.d.ts

@@ -0,0 +1,2 @@
+export declare const didUnmountReactApp: () => boolean;
+export declare function startReportingRuntimeErrors(onError: () => void): void;

package/dist/preview-server/error-overlay/react-overlay/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startReportingRuntimeErrors = exports.didUnmountReactApp = void 0;
+const remotion_1 = require("remotion");
+const listen_to_runtime_errors_1 = require("./listen-to-runtime-errors");
+let stopListeningToRuntimeErrors = null;
+const didUnmountReactApp = () => {
+    var _a;
+    return !((_a = remotion_1.Internals.getPreviewDomElement()) === null || _a === void 0 ? void 0 : _a.hasChildNodes());
+};
+exports.didUnmountReactApp = didUnmountReactApp;
+function startReportingRuntimeErrors(onError) {
+    if (stopListeningToRuntimeErrors !== null) {
+        throw new Error('Already listening');
+    }
+    const handleRuntimeError = () => {
+        onError();
+    };
+    stopListeningToRuntimeErrors = (0, listen_to_runtime_errors_1.listenToRuntimeErrors)(handleRuntimeError);
+}
+exports.startReportingRuntimeErrors = startReportingRuntimeErrors;

package/dist/preview-server/error-overlay/react-overlay/listen-to-runtime-errors.d.ts

@@ -0,0 +1,8 @@
+import type { SymbolicatedStackFrame } from './utils/stack-frame';
+export declare type ErrorRecord = {
+    error: Error;
+    contextSize: number;
+    stackFrames: SymbolicatedStackFrame[];
+};
+export declare const getErrorRecord: (error: Error) => Promise<ErrorRecord | null>;
+export declare function listenToRuntimeErrors(crash: () => void): () => void;