@remotion/bundler 4.0.0-fastlambda.8 → 4.0.0-lambda.1

package/dist/json-parser.js

@@ -0,0 +1,177 @@
+/*!
+ * body-parser
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Module dependencies.
+ * @private
+ */
+const bytes = require('bytes');
+const contentType = require('content-type');
+const createError = require('http-errors');
+const debug = require('debug')('body-parser:json');
+const read = require('../read');
+const typeis = require('type-is');
+/**
+ * Module exports.
+ */
+module.exports = json;
+/**
+ * RegExp to match the first non-space in a string.
+ *
+ * Allowed whitespace is defined in RFC 7159:
+ *
+ *    ws = *(
+ *            %x20 /              ; Space
+ *            %x09 /              ; Horizontal tab
+ *            %x0A /              ; Line feed or New line
+ *            %x0D )              ; Carriage return
+ */
+const FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/; // eslint-disable-line no-control-regex
+/**
+ * Create a middleware to parse JSON bodies.
+ *
+ * @param {object} [options]
+ * @return {function}
+ * @public
+ */
+function json() {
+    const limit = 100 * 1024 * 1024;
+    const inflate = true;
+    const strict = true;
+    const type = 'application/json';
+    const verify = false;
+    if (verify !== false && typeof verify !== 'function') {
+        throw new TypeError('option verify must be function');
+    }
+    // create the appropriate type checking function
+    const shouldParse = typeof type === 'function' ? type : typeChecker(type);
+    function parse(body) {
+        if (body.length === 0) {
+            // special-case empty json body, as it's a common client-side mistake
+            // TODO: maybe make this configurable or part of "strict" option
+            return {};
+        }
+        if (strict) {
+            const first = firstchar(body);
+            if (first !== '{' && first !== '[') {
+                debug('strict violation');
+                throw createStrictSyntaxError(body, first);
+            }
+        }
+        try {
+            debug('parse json');
+            return JSON.parse(body);
+        }
+        catch (e) {
+            throw normalizeJsonSyntaxError(e, {
+                message: e.message,
+                stack: e.stack,
+            });
+        }
+    }
+    return function jsonParser(req, res) {
+        // skip requests without bodies
+        if (!typeis.hasBody(req)) {
+            return;
+        }
+        // determine if request should be parsed
+        if (!shouldParse(req)) {
+            return;
+        }
+        // assert charset per RFC 7159 sec 8.1
+        const charset = getCharset(req) || 'utf-8';
+        if (charset.slice(0, 4) !== 'utf-') {
+            return;
+        }
+        // read
+        read(req, res, parse, {
+            encoding: charset,
+            inflate,
+            limit,
+            verify,
+        });
+    };
+}
+/**
+ * Create strict violation syntax error matching native error.
+ *
+ * @param {string} str
+ * @param {string} char
+ * @return {Error}
+ * @private
+ */
+function createStrictSyntaxError(str, char) {
+    const index = str.indexOf(char);
+    const partial = index !== -1 ? str.substring(0, index) + '#' : '';
+    try {
+        JSON.parse(partial);
+        /* istanbul ignore next */ throw new SyntaxError('strict violation');
+    }
+    catch (e) {
+        return normalizeJsonSyntaxError(e, {
+            message: e.message.replace('#', char),
+            stack: e.stack,
+        });
+    }
+}
+/**
+ * Get the first non-whitespace character in a string.
+ *
+ * @param {string} str
+ * @return {function}
+ * @private
+ */
+function firstchar(str) {
+    const match = FIRST_CHAR_REGEXP.exec(str);
+    return match ? match[1] : undefined;
+}
+/**
+ * Get the charset of a request.
+ *
+ * @param {object} req
+ * @api private
+ */
+function getCharset(req) {
+    try {
+        return (contentType.parse(req).parameters.charset || '').toLowerCase();
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+/**
+ * Normalize a SyntaxError for JSON.parse.
+ *
+ * @param {SyntaxError} error
+ * @param {object} obj
+ * @return {SyntaxError}
+ */
+function normalizeJsonSyntaxError(error, obj) {
+    const keys = Object.getOwnPropertyNames(error);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (key !== 'stack' && key !== 'message') {
+            delete error[key];
+        }
+    }
+    // replace stack before message for Node.js 0.10 and below
+    error.stack = obj.stack.replace(error.message, obj.message);
+    error.message = obj.message;
+    return error;
+}
+/**
+ * Get the simple type checker.
+ *
+ * @param {string} type
+ * @return {function}
+ */
+function typeChecker(type) {
+    return function checkType(req) {
+        return Boolean(typeis(req, type));
+    };
+}

package/dist/p-limit.d.ts

@@ -0,0 +1 @@
+export declare const pLimit: (concurrency: number) => <Arguments extends unknown[], ReturnType_1>(fn: (..._arguments: Arguments) => ReturnType_1 | PromiseLike<ReturnType_1>, ...args: Arguments) => Promise<ReturnType_1>;

package/dist/p-limit.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pLimit = void 0;
+const pLimit = (concurrency) => {
+    const queue = [];
+    let activeCount = 0;
+    const next = () => {
+        var _a;
+        activeCount--;
+        if (queue.length > 0) {
+            (_a = queue.shift()) === null || _a === void 0 ? void 0 : _a();
+        }
+    };
+    const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        // eslint-disable-next-line require-await
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+            await result;
+        }
+        catch (_a) { }
+        next();
+    };
+    const enqueue = (fn, resolve, ...args) => {
+        queue.push(() => run(fn, resolve, ...args));
+        (async () => {
+            var _a;
+            // This function needs to wait until the next microtask before comparing
+            // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+            // when the run function is dequeued and called. The comparison in the if-statement
+            // needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+            await Promise.resolve();
+            if (activeCount < concurrency && queue.length > 0) {
+                (_a = queue.shift()) === null || _a === void 0 ? void 0 : _a();
+            }
+        })();
+    };
+    const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+    });
+    Object.defineProperties(generator, {
+        activeCount: {
+            get: () => activeCount,
+        },
+        pendingCount: {
+            get: () => queue.length,
+        },
+        clearQueue: {
+            value: () => {
+                queue.length = 0;
+            },
+        },
+    });
+    return generator;
+};
+exports.pLimit = pLimit;

package/dist/read.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * body-parser
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+export {};

package/dist/read.js

@@ -0,0 +1,183 @@
+/*!
+ * body-parser
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Module dependencies.
+ * @private
+ */
+const createError = require('http-errors');
+const destroy = require('destroy');
+const getBody = require('raw-body');
+const iconv = require('iconv-lite');
+const onFinished = require('on-finished');
+const unpipe = require('unpipe');
+const zlib = require('zlib');
+/**
+ * Module exports.
+ */
+module.exports = read;
+/**
+ * Read a request into a buffer and parse.
+ *
+ * @param {object} req
+ * @param {object} res
+ * @param {function} next
+ * @param {function} parse
+ * @param {function} debug
+ * @param {object} options
+ * @private
+ */
+function read(req, res, parse, debug, options) {
+    let length;
+    const opts = options;
+    let stream;
+    // flag as parsed
+    req._body = true;
+    // read options
+    const encoding = opts.encoding !== null ? opts.encoding : null;
+    const { verify } = opts;
+    try {
+        // get the content stream
+        stream = contentstream(req, debug, opts.inflate);
+        length = stream.length;
+        stream.length = undefined;
+    }
+    catch (err) {
+        return next(err);
+    }
+    // set raw-body options
+    opts.length = length;
+    opts.encoding = verify ? null : encoding;
+    // assert charset is supported
+    if (opts.encoding === null &&
+        encoding !== null &&
+        !iconv.encodingExists(encoding)) {
+        return next(createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
+            charset: encoding.toLowerCase(),
+            type: 'charset.unsupported',
+        }));
+    }
+    // read body
+    debug('read body');
+    getBody(stream, opts, (error, body) => {
+        if (error) {
+            let _error;
+            if (error.type === 'encoding.unsupported') {
+                // echo back charset
+                _error = createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
+                    charset: encoding.toLowerCase(),
+                    type: 'charset.unsupported',
+                });
+            }
+            else {
+                // set status code on error
+                _error = createError(400, error);
+            }
+            // unpipe from stream and destroy
+            if (stream !== req) {
+                unpipe(req);
+                destroy(stream, true);
+            }
+            // read off entire request
+            dump(req, function onfinished() {
+                next(createError(400, _error));
+            });
+            return;
+        }
+        // verify
+        if (verify) {
+            try {
+                debug('verify body');
+                verify(req, res, body, encoding);
+            }
+            catch (err) {
+                next(createError(403, err, {
+                    body,
+                    type: err.type || 'entity.verify.failed',
+                }));
+                return;
+            }
+        }
+        // parse
+        let str = body;
+        try {
+            debug('parse body');
+            str =
+                typeof body !== 'string' && encoding !== null
+                    ? iconv.decode(body, encoding)
+                    : body;
+            req.body = parse(str);
+        }
+        catch (err) {
+            next(createError(400, err, {
+                body: str,
+                type: err.type || 'entity.parse.failed',
+            }));
+            return;
+        }
+        next();
+    });
+}
+/**
+ * Get the content stream of the request.
+ *
+ * @param {object} req
+ * @param {function} debug
+ * @param {boolean} [inflate=true]
+ * @return {object}
+ * @api private
+ */
+function contentstream(req, debug, inflate) {
+    const encoding = (req.headers['content-encoding'] || 'identity').toLowerCase();
+    const length = req.headers['content-length'];
+    let stream;
+    debug('content-encoding "%s"', encoding);
+    if (inflate === false && encoding !== 'identity') {
+        throw createError(415, 'content encoding unsupported', {
+            encoding,
+            type: 'encoding.unsupported',
+        });
+    }
+    switch (encoding) {
+        case 'deflate':
+            stream = zlib.createInflate();
+            debug('inflate body');
+            req.pipe(stream);
+            break;
+        case 'gzip':
+            stream = zlib.createGunzip();
+            debug('gunzip body');
+            req.pipe(stream);
+            break;
+        case 'identity':
+            stream = req;
+            stream.length = length;
+            break;
+        default:
+            throw createError(415, 'unsupported content encoding "' + encoding + '"', {
+                encoding,
+                type: 'encoding.unsupported',
+            });
+    }
+    return stream;
+}
+/**
+ * Dump the contents of a request.
+ *
+ * @param {object} req
+ * @param {function} callback
+ * @api private
+ */
+function dump(req, callback) {
+    if (onFinished.isFinished(req)) {
+        callback(null);
+    }
+    else {
+        onFinished(req, callback);
+        req.resume();
+    }
+}

package/dist/renderEntry.js

@@ -15,23 +15,14 @@ const remotion_1 = require("remotion");
 const bundle_mode_1 = require("./bundle-mode");
 const homepage_1 = require("./homepage/homepage");
 remotion_1.Internals.CSSUtils.injectCSS(remotion_1.Internals.CSSUtils.makeDefaultCSS(null, '#fff'));
-const Root = remotion_1.Internals.getRoot();
-if (!Root) {
-    throw new Error('Root has not been registered.');
-}
-const handle = (0, remotion_1.delayRender)('Loading root component');
-const Fallback = () => {
-    (0, react_1.useEffect)(() => {
-        const fallback = (0, remotion_1.delayRender)('Waiting for Root component to unsuspend');
-        return () => (0, remotion_1.continueRender)(fallback);
-    }, []);
-    return null;
-};
 const GetVideo = ({ state }) => {
-    var _a;
     const video = remotion_1.Internals.useVideo();
     const compositions = (0, react_1.useContext)(remotion_1.Internals.CompositionManager);
-    const [Component, setComponent] = (0, react_1.useState)(null);
+    const portalContainer = (0, react_1.useRef)(null);
+    const [handle] = (0, react_1.useState)(() => (0, remotion_1.delayRender)('Wait for Composition' + JSON.stringify(state)));
+    (0, react_1.useEffect)(() => {
+        return () => (0, remotion_1.continueRender)(handle);
+    }, [handle]);
     (0, react_1.useEffect)(() => {
         var _a;
         if (state.type !== 'composition') {
@@ -45,35 +36,36 @@ const GetVideo = ({ state }) => {
             compositions.setCurrentComposition((_a = foundComposition === null || foundComposition === void 0 ? void 0 : foundComposition.id) !== null && _a !== void 0 ? _a : null);
         }
     }, [compositions, compositions.compositions, state, video]);
-    const fetchComponent = (0, react_1.useCallback)(() => {
-        if (!video) {
-            throw new Error('Expected to have video');
-        }
-        const Comp = video.component;
-        setComponent(Comp);
-    }, [video]);
-    (0, react_1.useEffect)(() => {
-        if (video) {
-            fetchComponent();
-        }
-    }, [fetchComponent, video]);
     (0, react_1.useEffect)(() => {
         if (state.type === 'evaluation') {
             (0, remotion_1.continueRender)(handle);
         }
-        else if (Component) {
+        else if (video) {
             (0, remotion_1.continueRender)(handle);
         }
-    }, [Component, state.type]);
+    }, [handle, state.type, video]);
+    (0, react_1.useEffect)(() => {
+        if (!video) {
+            return;
+        }
+        const { current } = portalContainer;
+        if (!current) {
+            throw new Error('portal did not render');
+        }
+        current.appendChild(remotion_1.Internals.portalNode());
+        return () => {
+            current.removeChild(remotion_1.Internals.portalNode());
+        };
+    }, [video]);
     if (!video) {
         return null;
     }
-    return ((0, jsx_runtime_1.jsx)(react_1.Suspense, { fallback: (0, jsx_runtime_1.jsx)(Fallback, {}, void 0), children: (0, jsx_runtime_1.jsx)("div", { id: "remotion-canvas", style: {
-                width: video.width,
-                height: video.height,
-                display: 'flex',
-                backgroundColor: 'transparent',
-            }, children: Component ? ((0, jsx_runtime_1.jsx)(Component, { ...((_a = video === null || video === void 0 ? void 0 : video.defaultProps) !== null && _a !== void 0 ? _a : {}), ...(0, remotion_1.getInputProps)() }, void 0)) : null }, void 0) }, void 0));
+    return ((0, jsx_runtime_1.jsx)("div", { ref: portalContainer, id: "remotion-canvas", style: {
+            width: video.width,
+            height: video.height,
+            display: 'flex',
+            backgroundColor: 'transparent',
+        } }));
 };
 const videoContainer = document.getElementById('video-container');
 const explainerContainer = document.getElementById('explainer-container');
@@ -83,10 +75,28 @@ let cleanupVideoContainer = () => {
 let cleanupExplainerContainer = () => {
     explainerContainer.innerHTML = '';
 };
+const waitForRootHandle = (0, remotion_1.delayRender)('Loading root component');
+const WaitForRoot = () => {
+    const [Root, setRoot] = (0, react_1.useState)(() => remotion_1.Internals.getRoot());
+    (0, react_1.useEffect)(() => {
+        if (Root) {
+            (0, remotion_1.continueRender)(waitForRootHandle);
+            return;
+        }
+        const cleanup = remotion_1.Internals.waitForRoot((NewRoot) => {
+            setRoot(() => NewRoot);
+        });
+        return () => cleanup();
+    }, [Root]);
+    if (Root === null) {
+        return null;
+    }
+    return (0, jsx_runtime_1.jsx)(Root, {});
+};
 const renderContent = () => {
     const bundleMode = (0, bundle_mode_1.getBundleMode)();
     if (bundleMode.type === 'composition' || bundleMode.type === 'evaluation') {
-        const markup = ((0, jsx_runtime_1.jsxs)(remotion_1.Internals.RemotionRoot, { children: [(0, jsx_runtime_1.jsx)(Root, {}, void 0), (0, jsx_runtime_1.jsx)(GetVideo, { state: bundleMode }, void 0)] }, void 0));
+        const markup = ((0, jsx_runtime_1.jsxs)(remotion_1.Internals.RemotionRoot, { children: [(0, jsx_runtime_1.jsx)(WaitForRoot, {}), (0, jsx_runtime_1.jsx)(GetVideo, { state: bundleMode })] }));
         if (client_1.default.createRoot) {
             const root = client_1.default.createRoot(videoContainer);
             root.render(markup);
@@ -110,14 +120,14 @@ const renderContent = () => {
     if (bundleMode.type === 'index' || bundleMode.type === 'evaluation') {
         if (client_1.default.createRoot) {
             const root = client_1.default.createRoot(explainerContainer);
-            root.render((0, jsx_runtime_1.jsx)(homepage_1.Homepage, {}, void 0));
+            root.render((0, jsx_runtime_1.jsx)(homepage_1.Homepage, {}));
             cleanupExplainerContainer = () => {
                 root.unmount();
             };
         }
         else {
             const root = client_1.default;
-            root.render((0, jsx_runtime_1.jsx)(homepage_1.Homepage, {}, void 0), explainerContainer);
+            root.render((0, jsx_runtime_1.jsx)(homepage_1.Homepage, {}), explainerContainer);
             cleanupExplainerContainer = () => {
                 root.unmountComponentAtNode(explainerContainer);
             };
@@ -138,6 +148,9 @@ const setBundleModeAndUpdate = (state) => {
 exports.setBundleModeAndUpdate = setBundleModeAndUpdate;
 if (typeof window !== 'undefined') {
     window.getStaticCompositions = () => {
+        if (!remotion_1.Internals.getRoot()) {
+            throw new Error('registerRoot() was never called. 1. Make sure you specified the correct entrypoint for your bundle. 2. If your registerRoot() call is deferred, use the delayRender/continueRender pattern to tell Remotion to wait.');
+        }
         if (!remotion_1.Internals.compositionsRef.current) {
             throw new Error('Unexpectedly did not have a CompositionManager');
         }
@@ -154,6 +167,6 @@ if (typeof window !== 'undefined') {
             };
         });
     };
-    window.siteVersion = '2';
+    window.siteVersion = '3';
     window.setBundleMode = exports.setBundleModeAndUpdate;
 }

package/dist/routes.d.ts

@@ -0,0 +1,8 @@
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const handleUpdate: (_: IncomingMessage, response: ServerResponse) => Promise<void>;
+export declare const handleFallback: (hash: string, _: IncomingMessage, response: ServerResponse) => Promise<void>;
+export declare const handleProjectInfo: (_: IncomingMessage, response: ServerResponse) => Promise<void>;
+export declare const handleFileSource: (search: string, _: IncomingMessage, response: ServerResponse) => Promise<void>;
+export declare const handleOpenInEditor: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+export declare const handleFavicon: (_: IncomingMessage, response: ServerResponse) => void;
+export declare const handleRoutes: (hash: string, request: IncomingMessage, response: ServerResponse) => void | Promise<void>;