@bleedingdev/modern-js-server-core 3.2.0-ultramodern.0

package/dist/cjs/adapters/node/node.js

@@ -0,0 +1,180 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createNodeServer: ()=>createNodeServer,
+    createWebRequest: ()=>createWebRequest,
+    sendResponse: ()=>sendResponse
+});
+const external_node_http_namespaceObject = require("node:http");
+const external_node_stream_namespaceObject = require("node:stream");
+const external_cloneable_readable_namespaceObject = require("cloneable-readable");
+var external_cloneable_readable_default = /*#__PURE__*/ __webpack_require__.n(external_cloneable_readable_namespaceObject);
+const index_js_namespaceObject = require("./helper/index.js");
+const createWebRequest = (req, res, body)=>{
+    const headerRecord = [];
+    for (const [key, value] of Object.entries(req.headers))if (!key.startsWith(':')) {
+        if (Array.isArray(value)) {
+            for (const item of value)if (void 0 !== item) headerRecord.push([
+                key,
+                item
+            ]);
+        } else if (void 0 !== value) {
+            if ('string' == typeof value) headerRecord.push([
+                key,
+                value
+            ]);
+        }
+    }
+    const { method } = req;
+    const controller = new AbortController();
+    const init = {
+        method,
+        headers: headerRecord,
+        signal: controller.signal
+    };
+    res.on('close', ()=>controller.abort('res closed'));
+    const url = `http://${req.headers.host}${req.url}`;
+    const needsRequestBody = body || !('GET' === method || 'HEAD' === method);
+    const cloneableReq = needsRequestBody ? external_cloneable_readable_default()(req) : null;
+    if (needsRequestBody) {
+        if (body) init.body = body;
+        else {
+            const stream = cloneableReq.clone();
+            init.body = external_node_stream_namespaceObject.Readable.toWeb(stream);
+        }
+        init.duplex = 'half';
+    }
+    const originalRequest = new Request(url, init);
+    if (needsRequestBody) {
+        const interceptedMethods = [
+            'json',
+            'text',
+            'blob',
+            'arrayBuffer',
+            'formData'
+        ];
+        return new Proxy(originalRequest, {
+            get (target, prop) {
+                if (interceptedMethods.includes(prop)) return (...args)=>{
+                    cloneableReq.resume();
+                    return target[prop].call(target, ...args);
+                };
+                const value = target[prop];
+                if ('body' === prop) {
+                    cloneableReq.resume();
+                    return value;
+                }
+                if ('function' == typeof value) return (...args)=>value.apply(target, args);
+                return value;
+            }
+        });
+    }
+    return originalRequest;
+};
+const sendResponse = async (response, res)=>{
+    res.statusMessage = response.statusText;
+    res.statusCode = response.status;
+    const cookies = [];
+    for (const [key, value] of response.headers.entries())if ('set-cookie' === key) cookies.push(value);
+    else res.setHeader(key, value);
+    if (cookies.length > 0) res.setHeader('set-cookie', cookies);
+    if (response.headers.get('Content-Type')?.match(/text\/event-stream/i) && res instanceof external_node_http_namespaceObject.ServerResponse) res.flushHeaders();
+    if (response.body) {
+        const writable = external_node_stream_namespaceObject.Writable.toWeb(res);
+        await response.body.pipeTo(writable);
+    } else res.end();
+};
+const handleResponseError = (e, res)=>{
+    const err = e instanceof Error ? e : new Error('unknown error', {
+        cause: e
+    });
+    if ('ABORT_ERR' === err.code || 'ERR_STREAM_PREMATURE_CLOSE' === err.code) console.info('The user aborted a request.');
+    else {
+        console.error(e);
+        if (!res.headersSent) {
+            res.statusCode = 500;
+            res.setHeader('Content-Type', 'text/plain');
+        }
+        res.end(`Error: ${err.message}`);
+        res.destroy(err);
+    }
+};
+const getRequestListener = (handler)=>async (req, res)=>{
+        try {
+            const request = createWebRequest(req, res);
+            const response = await handler(request, {
+                node: {
+                    req,
+                    res
+                }
+            });
+            if (!response.res && !(0, index_js_namespaceObject.isResFinalized)(res)) await sendResponse(response, res);
+        } catch (error) {
+            return handleResponseError(error, res);
+        }
+    };
+const createNodeServer = async (requestHandler, httpsOptions, http2)=>{
+    const requestListener = getRequestListener(requestHandler);
+    let nodeServer;
+    if (httpsOptions) if (http2) {
+        const { createSecureServer } = await import("node:http2");
+        nodeServer = createSecureServer({
+            allowHTTP1: true,
+            maxSessionMemory: 1024,
+            ...httpsOptions
+        }, (req, res)=>requestListener(req, res));
+    } else {
+        const { createServer } = await import("node:https");
+        nodeServer = createServer(httpsOptions, requestListener);
+    }
+    else {
+        const { createServer } = await import("node:http");
+        nodeServer = createServer(requestListener);
+    }
+    nodeServer.getRequestListener = ()=>requestListener;
+    nodeServer.getRequestHandler = ()=>requestHandler;
+    return nodeServer;
+};
+exports.createNodeServer = __webpack_exports__.createNodeServer;
+exports.createWebRequest = __webpack_exports__.createWebRequest;
+exports.sendResponse = __webpack_exports__.sendResponse;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNodeServer",
+    "createWebRequest",
+    "sendResponse"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/adapters/node/plugins/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_modules__ = {
+    "./nodeServer" (module) {
+        module.exports = require("./nodeServer.js");
+    },
+    "./resource" (module) {
+        module.exports = require("./resource.js");
+    },
+    "./static" (module) {
+        module.exports = require("./static.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _nodeServer__rspack_import_0 = __webpack_require__("./nodeServer");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _nodeServer__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_nodeServer__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _resource__rspack_import_1 = __webpack_require__("./resource");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _resource__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_resource__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _static__rspack_import_2 = __webpack_require__("./static");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _static__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_static__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/adapters/node/plugins/nodeServer.js

@@ -0,0 +1,43 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    injectNodeSeverPlugin: ()=>injectNodeSeverPlugin
+});
+const injectNodeSeverPlugin = ({ nodeServer })=>({
+        name: '@modern-js/plugin-inject-node-server',
+        setup (api) {
+            api.updateServerContext({
+                nodeServer
+            });
+        }
+    });
+exports.injectNodeSeverPlugin = __webpack_exports__.injectNodeSeverPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "injectNodeSeverPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/adapters/node/plugins/resource.js

@@ -0,0 +1,206 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getClientManifest: ()=>getClientManifest,
+    getHtmlTemplates: ()=>getHtmlTemplates,
+    getRscSSRManifest: ()=>getRscSSRManifest,
+    getRscServerManifest: ()=>getRscServerManifest,
+    getServerManifest: ()=>getServerManifest,
+    injectResourcePlugin: ()=>injectResourcePlugin,
+    injectRscManifestPlugin: ()=>injectRscManifestPlugin,
+    injectServerManifest: ()=>injectServerManifest,
+    injectTemplates: ()=>injectTemplates
+});
+const fileReader_namespaceObject = require("@modern-js/runtime-utils/fileReader");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const index_js_namespaceObject = require("../../../utils/index.js");
+async function getHtmlTemplates(pwd, routes) {
+    const htmlRoutes = routes.filter((route)=>route.entryName);
+    const htmls = await Promise.all(htmlRoutes.map(async (route)=>{
+        let html;
+        try {
+            const htmlPath = external_path_default().join(pwd, route.entryPath);
+            html = (await fileReader_namespaceObject.fileReader.readFile(htmlPath, 'utf-8'))?.toString();
+        } catch (e) {}
+        return [
+            (0, index_js_namespaceObject.uniqueKeyByRoute)(route),
+            html
+        ];
+    }) || []);
+    const templates = Object.fromEntries(htmls);
+    return templates;
+}
+function injectTemplates(pwd, routes, htmlTemplatePromise) {
+    return async (c, next)=>{
+        if (routes && !c.get('templates')) {
+            const templates = await (htmlTemplatePromise || getHtmlTemplates(pwd, routes));
+            c.set('templates', templates);
+        }
+        await next();
+    };
+}
+const loadBundle = async (filepath, monitors)=>{
+    if (!await utils_namespaceObject.fs.pathExists(filepath)) return;
+    try {
+        const module = await (0, utils_namespaceObject.compatibleRequire)(filepath, false);
+        return module;
+    } catch (e) {
+        if (monitors) monitors.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
+        else console.error(`Load ${filepath} bundle failed, error = ${e instanceof Error ? e.stack || e.message : e}`);
+        return;
+    }
+};
+async function getServerManifest(pwd, routes, monitors) {
+    const loaderBundles = {};
+    const renderBundles = {};
+    await Promise.all(routes.filter((route)=>Boolean(route.bundle)).map(async (route)=>{
+        const entryName = route.entryName || utils_namespaceObject.MAIN_ENTRY_NAME;
+        const renderBundlePath = external_path_default().join(pwd, route.bundle || '');
+        const loaderBundlePath = external_path_default().join(pwd, utils_namespaceObject.SERVER_BUNDLE_DIRECTORY, `${entryName}-server-loaders.js`);
+        const renderBundle = await loadBundle(renderBundlePath, monitors);
+        const loaderBundle = await loadBundle(loaderBundlePath, monitors);
+        renderBundle && (renderBundles[entryName] = renderBundle);
+        loaderBundle && (loaderBundles[entryName] = loaderBundle?.loadModules ? await loaderBundle?.loadModules() : loaderBundle);
+    }));
+    const loadableUri = external_path_default().join(pwd, utils_namespaceObject.LOADABLE_STATS_FILE);
+    const loadableStats = await (0, utils_namespaceObject.compatibleRequire)(loadableUri).catch((_)=>({}));
+    const routesManifestUri = external_path_default().join(pwd, utils_namespaceObject.ROUTE_MANIFEST_FILE);
+    const routeManifest = await (0, utils_namespaceObject.compatibleRequire)(routesManifestUri).catch((_)=>({}));
+    const nestedRoutesJsonPath = external_path_default().join(pwd, utils_namespaceObject.NESTED_ROUTE_SPEC_FILE);
+    const nestedRoutesJson = await (0, utils_namespaceObject.compatibleRequire)(nestedRoutesJsonPath).catch((_)=>({}));
+    return {
+        loaderBundles,
+        renderBundles,
+        loadableStats,
+        routeManifest,
+        nestedRoutesJson
+    };
+}
+function injectServerManifest(pwd, routes, manifestPromise) {
+    return async (c, next)=>{
+        if (routes && !c.get('serverManifest')) {
+            const monitors = c.get('monitors');
+            const serverManifest = await (manifestPromise || getServerManifest(pwd, routes, monitors));
+            c.set('serverManifest', serverManifest);
+        }
+        await next();
+    };
+}
+async function getRscServerManifest(pwd) {
+    const rscServerManifest = await (0, utils_namespaceObject.compatibleRequire)(external_path_default().join(pwd, 'bundles', 'react-server-manifest.json')).catch((_)=>void 0);
+    return rscServerManifest;
+}
+async function getClientManifest(pwd) {
+    const rscClientManifest = await (0, utils_namespaceObject.compatibleRequire)(external_path_default().join(pwd, 'react-client-manifest.json')).catch((_)=>void 0);
+    return rscClientManifest;
+}
+async function getRscSSRManifest(pwd) {
+    const rscSSRManifest = await (0, utils_namespaceObject.compatibleRequire)(external_path_default().join(pwd, 'react-ssr-manifest.json')).catch((_)=>void 0);
+    return rscSSRManifest;
+}
+const injectRscManifestPlugin = (enableRsc)=>({
+        name: '@modern-js/plugin-inject-rsc-manifest',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, distDirectory: pwd } = api.getServerContext();
+                if (!enableRsc) return;
+                middlewares.push({
+                    name: 'inject-rsc-manifest',
+                    handler: async (c, next)=>{
+                        if (!c.get('rscServerManifest')) {
+                            const rscServerManifest = await getRscServerManifest(pwd);
+                            c.set('rscServerManifest', rscServerManifest);
+                        }
+                        if (!c.get('rscClientManifest')) {
+                            const rscClientManifest = await getClientManifest(pwd);
+                            c.set('rscClientManifest', rscClientManifest);
+                        }
+                        if (!c.get('rscSSRManifest')) {
+                            const rscSSRManifest = await getRscSSRManifest(pwd);
+                            c.set('rscSSRManifest', rscSSRManifest);
+                        }
+                        await next();
+                    }
+                });
+            });
+        }
+    });
+const injectResourcePlugin = ()=>({
+        name: '@modern-js/plugin-inject-resource',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, routes, distDirectory: pwd } = api.getServerContext();
+                let htmlTemplatePromise;
+                let manifestPromise;
+                if ((0, utils_namespaceObject.isProd)()) {
+                    manifestPromise = getServerManifest(pwd, routes || [], void 0);
+                    htmlTemplatePromise = getHtmlTemplates(pwd, routes || []);
+                }
+                middlewares.push({
+                    name: 'inject-server-manifest',
+                    handler: injectServerManifest(pwd, routes, manifestPromise)
+                });
+                middlewares.push({
+                    name: 'inject-html',
+                    handler: injectTemplates(pwd, routes, htmlTemplatePromise)
+                });
+            });
+        }
+    });
+exports.getClientManifest = __webpack_exports__.getClientManifest;
+exports.getHtmlTemplates = __webpack_exports__.getHtmlTemplates;
+exports.getRscSSRManifest = __webpack_exports__.getRscSSRManifest;
+exports.getRscServerManifest = __webpack_exports__.getRscServerManifest;
+exports.getServerManifest = __webpack_exports__.getServerManifest;
+exports.injectResourcePlugin = __webpack_exports__.injectResourcePlugin;
+exports.injectRscManifestPlugin = __webpack_exports__.injectRscManifestPlugin;
+exports.injectServerManifest = __webpack_exports__.injectServerManifest;
+exports.injectTemplates = __webpack_exports__.injectTemplates;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getClientManifest",
+    "getHtmlTemplates",
+    "getRscSSRManifest",
+    "getRscServerManifest",
+    "getServerManifest",
+    "injectResourcePlugin",
+    "injectRscManifestPlugin",
+    "injectServerManifest",
+    "injectTemplates"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});