@bleedingdev/modern-js-prod-server 3.2.0-ultramodern.120 → 3.2.0-ultramodern.122

package/dist/cjs/server/modernServer.js

@@ -1,476 +0,0 @@
-"use strict";
-var __webpack_modules__ = {
-    "ignore-styles" (module) {
-        module.exports = require("ignore-styles");
-    }
-};
-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, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __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__, {
-        ModernServer: ()=>ModernServer
-    });
-    const time_namespaceObject = require("@modern-js/runtime-utils/time");
-    const utils_namespaceObject = require("@modern-js/utils");
-    const external_http_namespaceObject = require("http");
-    const external_path_namespaceObject = require("path");
-    var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
-    const external_constants_namespaceObject = require("../constants");
-    const context_namespaceObject = require("../libs/context");
-    const hook_api_namespaceObject = require("../libs/hook-api");
-    const mfCache_namespaceObject = require("../libs/mfCache");
-    const proxy_namespaceObject = require("../libs/proxy");
-    const index_js_namespaceObject = require("../libs/render/index.js");
-    const reader_namespaceObject = require("../libs/render/reader");
-    const route_namespaceObject = require("../libs/route");
-    const serveFile_namespaceObject = require("../libs/serveFile");
-    const external_utils_js_namespaceObject = require("../utils.js");
-    const SERVER_DIR = './server';
-    class ModernServer {
-        async onInit(runner, app) {
-            this.runner = runner;
-            const { distDir, conf } = this;
-            this.initReader();
-            (0, external_utils_js_namespaceObject.debug)('final server conf', this.conf);
-            if (conf.bff?.proxy) {
-                const { handlers, handleUpgrade } = (0, proxy_namespaceObject.createProxyHandler)(conf.bff.proxy);
-                app && handleUpgrade(app);
-                handlers.forEach((handler)=>{
-                    this.addHandler(handler);
-                });
-            }
-            app?.on('close', ()=>{
-                this.reader.close();
-            });
-            const usageRoutes = this.filterRoutes(this.getRoutes());
-            this.router.reset(usageRoutes);
-            this.warmupSSRBundle();
-            await this.prepareFrameHandler();
-            await this.prepareLoaderHandler(usageRoutes, distDir);
-            this.routeRenderHandler = this.getRenderHandler();
-            await this.setupBeforeProdMiddleware();
-            this.addHandler(this.setupMfAssetCacheMiddleware());
-            this.addHandler(this.setupStaticMiddleware(this.conf.output?.assetPrefix));
-            this.addHandler(serveFile_namespaceObject.faviconFallbackHandler);
-            this.addHandler(this.routeHandler.bind(this));
-            this.compose();
-        }
-        getRenderHandler() {
-            const { distDir, staticGenerate, conf, metaName } = this;
-            const ssrConfig = this.conf.server?.ssr;
-            const forceCSR = 'object' == typeof ssrConfig ? ssrConfig.forceCSR : false;
-            return (0, index_js_namespaceObject.createRenderHandler)({
-                distDir,
-                staticGenerate,
-                forceCSR,
-                conf: this.conf,
-                nonce: conf.security?.nonce,
-                metaName
-            });
-        }
-        onRepack(_) {}
-        getRequestHandler() {
-            return this.requestHandler.bind(this);
-        }
-        async render(req, res, url) {
-            req.logger = req.logger || this.logger;
-            req.metrics = req.metrics || this.metrics;
-            const context = (0, context_namespaceObject.createContext)(req, res, {
-                metaName: this.metaName
-            });
-            const matched = this.router.match(url || context.path);
-            if (!matched) return null;
-            res.statusCode = 200;
-            const route = matched.generate(context.url);
-            const result = await this.handleWeb(context, route);
-            if (!result) return null;
-            if (result.contentStream) return result.contentStream;
-            return result.content.toString();
-        }
-        async createHTTPServer(handler) {
-            return (0, external_http_namespaceObject.createServer)(handler);
-        }
-        initReader() {
-            this.reader.init();
-        }
-        async onServerChange({ filepath }) {
-            const { pwd } = this;
-            const { api, server } = external_constants_namespaceObject.AGGRED_DIR;
-            const apiPath = external_path_default().normalize(external_path_default().join(pwd, api));
-            const serverPath = external_path_default().normalize(external_path_default().join(pwd, server));
-            const onlyApi = filepath.startsWith(apiPath);
-            const onlyWeb = filepath.startsWith(serverPath);
-            await this.prepareFrameHandler({
-                onlyWeb,
-                onlyApi
-            });
-        }
-        getRoutes() {
-            if (this.presetRoutes) return this.presetRoutes;
-            const file = external_path_default().join(this.distDir, utils_namespaceObject.ROUTE_SPEC_FILE);
-            if (utils_namespaceObject.fs.existsSync(file)) {
-                const content = utils_namespaceObject.fs.readJSONSync(file);
-                return content.routes;
-            }
-            return [];
-        }
-        addHandler(handler) {
-            this.handlers.push(handler);
-        }
-        render404(context) {
-            context.error(external_constants_namespaceObject.ERROR_DIGEST.ENOTF, '404 Not Found');
-            this.renderErrorPage(context, 404);
-        }
-        async prepareLoaderHandler(specs, distDir) {
-            const { runner } = this;
-            const handler = await runner.prepareLoaderHandler({
-                serverRoutes: specs,
-                distDir
-            }, {
-                onLast: ()=>null
-            });
-            this.loaderHandler = handler;
-        }
-        async prepareFrameHandler(options) {
-            const { workDir, runner } = this;
-            const { onlyApi, onlyWeb } = options || {};
-            const { getMiddlewares, ...collector } = (0, external_utils_js_namespaceObject.createMiddlewareCollecter)();
-            await runner.gather(collector);
-            const { api: pluginAPIExt, web: pluginWebExt } = getMiddlewares();
-            const serverDir = external_path_default().join(workDir, SERVER_DIR);
-            if (await utils_namespaceObject.fs.pathExists(external_path_default().join(serverDir)) && !onlyApi) {
-                const webExtension = (0, external_utils_js_namespaceObject.mergeExtension)(pluginWebExt);
-                this.frameWebHandler = await this.prepareWebHandler(webExtension);
-            }
-            if (!onlyWeb) {
-                const apiExtension = (0, external_utils_js_namespaceObject.mergeExtension)(pluginAPIExt);
-                this.frameAPIHandler = await this.prepareAPIHandler(apiExtension);
-            }
-        }
-        async prepareWebHandler(extension) {
-            const { workDir, runner } = this;
-            const handler = await runner.prepareWebServer({
-                pwd: workDir,
-                config: extension
-            }, {
-                onLast: ()=>null
-            });
-            return handler;
-        }
-        async prepareAPIHandler(extension) {
-            const { workDir, runner, conf } = this;
-            const { bff } = conf;
-            const prefix = bff?.prefix || '/api';
-            const webOnly = await (0, utils_namespaceObject.isWebOnly)();
-            if (webOnly && 'development' === process.env.NODE_ENV) return (req, res)=>{
-                res.setHeader('Content-Type', 'text/plain');
-                res.end(JSON.stringify(''));
-            };
-            return runner.prepareApiServer({
-                pwd: workDir,
-                config: extension,
-                prefix: Array.isArray(prefix) ? prefix[0] : prefix,
-                httpMethodDecider: bff?.httpMethodDecider,
-                render: this.render.bind(this)
-            }, {
-                onLast: ()=>null
-            });
-        }
-        filterRoutes(routes) {
-            return routes;
-        }
-        async setupBeforeProdMiddleware() {
-            const { conf, runner } = this;
-            const preMiddleware = await runner.beforeProdServer(conf);
-            preMiddleware.flat().forEach((mid)=>{
-                this.addHandler(mid);
-            });
-        }
-        setupStaticMiddleware(prefix) {
-            const staticPathRegExp = (0, external_utils_js_namespaceObject.getStaticReg)(this.conf.output, this.conf.html, prefix);
-            return (0, serveFile_namespaceObject.createStaticFileHandler)([
-                {
-                    path: staticPathRegExp,
-                    target: this.distDir
-                }
-            ], prefix);
-        }
-        setupMfAssetCacheMiddleware() {
-            return async (context, next)=>{
-                const headers = (0, mfCache_namespaceObject.resolveMfAssetCacheHeaders)(context.url, context.query);
-                if (headers) for (const [key, value] of Object.entries(headers))context.res.setHeader(key, value);
-                await next();
-            };
-        }
-        async handleAPI(context) {
-            const { req, res } = context;
-            if (!this.frameAPIHandler) throw new Error('can not found api handler');
-            await this.frameAPIHandler(req, res);
-        }
-        async handleWeb(context, route) {
-            const { res } = context;
-            if (this.loaderHandler) {
-                await this.loaderHandler(context);
-                if (this.isSend(res)) return null;
-            }
-            context.setParams(route.params);
-            context.setServerData('router', {
-                baseUrl: route.urlPath,
-                params: route.params
-            });
-            if (route.responseHeaders) Object.keys(route.responseHeaders).forEach((key)=>{
-                const value = route.responseHeaders[key];
-                if (value) context.res.setHeader(key, value);
-            });
-            const renderResult = await this.routeRenderHandler({
-                ctx: context,
-                route,
-                runner: this.runner
-            });
-            if (!renderResult) {
-                this.render404(context);
-                return null;
-            }
-            if (renderResult.redirect) {
-                this.redirect(res, renderResult.content, renderResult.statusCode);
-                return null;
-            }
-            if (this.isSend(res)) return null;
-            res.set('content-type', renderResult.contentType);
-            return renderResult;
-        }
-        async proxy() {
-            return null;
-        }
-        warmupSSRBundle() {
-            const { distDir } = this;
-            const bundles = this.router.getBundles();
-            bundles.forEach((bundle)=>{
-                const filepath = external_path_default().join(distDir, bundle);
-                if (utils_namespaceObject.fs.existsSync(filepath)) require(filepath);
-            });
-        }
-        createContext(req, res, options = {}) {
-            return (0, context_namespaceObject.createContext)(req, res, options);
-        }
-        async routeHandler(context) {
-            const { res, reporter } = context;
-            const matched = this.router.match(context.path);
-            if (!matched) return void this.render404(context);
-            await reporter.init({
-                match: matched
-            });
-            const end = (0, time_namespaceObject.time)();
-            res.on('finish', ()=>{
-                const cost = end();
-                reporter.reportTiming(external_constants_namespaceObject.ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
-            });
-            let route = matched.generate(context.url);
-            if (route.isApi) return void await this.handleAPI(context);
-            if (route.entryName && this.runMode === external_constants_namespaceObject.RUN_MODE.FULL) {
-                const afterMatchContext = (0, hook_api_namespaceObject.createAfterMatchContext)(context, route.entryName);
-                const end = (0, time_namespaceObject.time)();
-                await this.runner.afterMatch(afterMatchContext, {
-                    onLast: external_utils_js_namespaceObject.noop
-                });
-                const cost = end();
-                cost && reporter.reportTiming(external_constants_namespaceObject.ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost);
-                if (this.isSend(res)) return;
-                const { current, url, status } = afterMatchContext.router;
-                if (url) return void this.redirect(res, url, status);
-                if (route.entryName !== current) {
-                    const matched = this.router.matchEntry(current);
-                    if (!matched) return void this.render404(context);
-                    route = matched.generate(context.url);
-                }
-            }
-            if (this.frameWebHandler) {
-                res.locals = res.locals || {};
-                const middlewareContext = (0, hook_api_namespaceObject.createMiddlewareContext)(context);
-                const end = (0, time_namespaceObject.time)();
-                await this.frameWebHandler(middlewareContext);
-                const cost = end();
-                cost && reporter.reportTiming(external_constants_namespaceObject.ServerReportTimings.SERVER_MIDDLEWARE, cost);
-                res.locals = {
-                    ...res.locals,
-                    ...middlewareContext.response.locals
-                };
-                if (this.isSend(res)) return;
-            }
-            const renderResult = await this.handleWeb(context, route);
-            if (!renderResult) return;
-            const { contentStream: responseStream } = renderResult;
-            let { content: response } = renderResult;
-            if (route.entryName && responseStream) return void responseStream.pipe(res);
-            if (route.entryName && this.runMode === external_constants_namespaceObject.RUN_MODE.FULL) {
-                const afterRenderContext = (0, hook_api_namespaceObject.createAfterRenderContext)(context, response.toString());
-                const end = (0, time_namespaceObject.time)();
-                await this.runner.afterRender(afterRenderContext, {
-                    onLast: external_utils_js_namespaceObject.noop
-                });
-                const cost = end();
-                cost && reporter.reportTiming(external_constants_namespaceObject.ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost);
-                if (this.isSend(res)) return;
-                response = afterRenderContext.template.get();
-            }
-            res.end(response);
-        }
-        isSend(res) {
-            if (res.modernFlushedHeaders) {
-                if (res.writableFinished) return true;
-            } else if (res.headersSent) return true;
-            if (res.getHeader('Location') && (0, external_utils_js_namespaceObject.isRedirect)(res.statusCode)) {
-                res.end();
-                return true;
-            }
-            return false;
-        }
-        compose() {
-            const { handlers } = this;
-            if (!Array.isArray(handlers)) throw new TypeError('Middleware stack must be an array!');
-            for (const fn of handlers)if ('function' != typeof fn) throw new TypeError('Middleware must be composed of functions!');
-            this._handler = (context, next)=>{
-                let i = 0;
-                const dispatch = (error)=>{
-                    if (error) return this.onError(context, error);
-                    const handler = handlers[i++];
-                    if (!handler) return next();
-                    try {
-                        const result = handler(context, dispatch);
-                        if ((0, utils_namespaceObject.isPromise)(result)) return result.catch(onError);
-                    } catch (e) {
-                        return onError(e);
-                    }
-                };
-                const onError = (err)=>{
-                    this.onError(context, err);
-                };
-                return dispatch();
-            };
-        }
-        requestHandler(req, res, next = ()=>{}) {
-            res.statusCode = 200;
-            req.logger = req.logger || this.logger;
-            req.metrics = req.metrics || this.metrics;
-            let context;
-            try {
-                context = this.createContext(req, res, {
-                    metaName: this.metaName
-                });
-            } catch (e) {
-                this.logger.error(e);
-                res.statusCode = 500;
-                res.setHeader('content-type', utils_namespaceObject.mime.contentType('html'));
-                return res.end((0, external_utils_js_namespaceObject.createErrorDocument)(500, external_constants_namespaceObject.ERROR_PAGE_TEXT["500"]));
-            }
-            try {
-                return this._handler(context, next);
-            } catch (err) {
-                return this.onError(context, err);
-            }
-        }
-        redirect(res, url, status = 302) {
-            res.set('Location', url);
-            res.statusCode = status;
-            res.end();
-        }
-        onError(context, err) {
-            context.error(external_constants_namespaceObject.ERROR_DIGEST.EINTER, err);
-            this.renderErrorPage(context, 500);
-        }
-        async renderErrorPage(context, status) {
-            const { res } = context;
-            context.status = status;
-            res.set('content-type', utils_namespaceObject.mime.contentType('html'));
-            const statusPage = `/${status}`;
-            const customErrorPage = "/_error";
-            const matched = this.router.match(statusPage) || this.router.match(customErrorPage);
-            if (matched) {
-                const route = matched.generate(context.url);
-                const { entryName } = route;
-                if (entryName === status.toString() || '_error' === entryName) try {
-                    const file = await this.routeRenderHandler({
-                        route,
-                        ctx: context,
-                        runner: this.runner
-                    });
-                    if (file) return void context.res.end(file.content);
-                } catch (e) {}
-            }
-            const text = external_constants_namespaceObject.ERROR_PAGE_TEXT[status] || external_constants_namespaceObject.ERROR_PAGE_TEXT["500"];
-            context.res.end((0, external_utils_js_namespaceObject.createErrorDocument)(status, text));
-        }
-        constructor({ pwd, config, routes, staticGenerate, logger, metrics, runMode, proxyTarget, appContext }){
-            this.handlers = [];
-            this.reader = reader_namespaceObject;
-            this.loaderHandler = null;
-            this.frameWebHandler = null;
-            this.frameAPIHandler = null;
-            __webpack_require__("ignore-styles");
-            this.pwd = pwd;
-            this.distDir = external_path_default().resolve(pwd, config.output.path || 'dist');
-            this.workDir = this.distDir;
-            this.conf = config;
-            (0, external_utils_js_namespaceObject.debug)('server conf', this.conf);
-            this.logger = logger;
-            this.metrics = metrics;
-            this.router = new route_namespaceObject.RouteMatchManager();
-            this.presetRoutes = routes;
-            this.proxyTarget = proxyTarget;
-            this.staticGenerate = staticGenerate || false;
-            this.runMode = runMode || external_constants_namespaceObject.RUN_MODE.FULL;
-            this.metaName = appContext?.metaName;
-        }
-    }
-})();
-exports.ModernServer = __webpack_exports__.ModernServer;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "ModernServer"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/server/modernServerSplit.js

@@ -1,42 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __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__);
-const createProdServer = ()=>{
-    throw new Error('createProdServer from modernServerSplit is not available in this source runtime.');
-};
-__webpack_require__.d(__webpack_exports__, {}, {
-    createProdServer: createProdServer
-});
-exports.createProdServer = __webpack_exports__.createProdServer;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createProdServer"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/utils.js

@@ -1,42 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __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__);
-const debug = (...args)=>{
-    if (process.env.MODERN_DEBUG || process.env.DEBUG) console.log('[prod-server]', ...args);
-};
-__webpack_require__.d(__webpack_exports__, {}, {
-    debug: debug
-});
-exports.debug = __webpack_exports__.debug;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "debug"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/esm/libs/contractGateAutopilot.mjs

@@ -1 +0,0 @@
-export { ContractGateAutopilot } from "@modern-js/server-core";

package/dist/esm/libs/loadConfig.mjs

@@ -1,22 +0,0 @@
-import { compatibleRequire, fs, lodash } from "@modern-js/utils";
-import { parse } from "flatted";
-import path from "path";
-const getServerConfigPath = (distDirectory, serverConfigFile)=>{
-    const fileName = serverConfigFile || 'server.js';
-    return path.join(distDirectory, fileName);
-};
-const requireConfig = (serverConfigPath)=>{
-    if (fs.pathExistsSync(serverConfigPath)) return compatibleRequire(serverConfigPath) || {};
-    return {};
-};
-const loadConfig = ({ cliConfig, serverConfig, resolvedConfigPath })=>{
-    let outputConfig = {};
-    if (fs.pathExistsSync(resolvedConfigPath)) try {
-        const content = fs.readFileSync(resolvedConfigPath, 'utf8');
-        outputConfig = parse(content) || {};
-    } catch (_error) {
-        outputConfig = {};
-    }
-    return lodash.merge({}, outputConfig, serverConfig || {}, cliConfig || {});
-};
-export { getServerConfigPath, loadConfig, requireConfig };

package/dist/esm/libs/metrics.mjs

@@ -1,7 +0,0 @@
-const noop = ()=>{};
-const metrics = {
-    emitCounter: noop,
-    emitTimer: noop,
-    gauges: noop
-};
-export { metrics };

package/dist/esm/libs/render/index.mjs

@@ -1,81 +0,0 @@
-import { cutNameByHyphen, mime } from "@modern-js/utils";
-import path from "path";
-import { ERROR_DIGEST } from "../../constants";
-import { shouldFlushServerHeader } from "../preload/shouldFlushServerHeader";
-import { readFile } from "./reader";
-import { handleDirectory } from "./static";
-import { injectServerData } from "./utils.mjs";
-import * as __rspack_external__ssr_mjs_81ad94dd from "./ssr.mjs";
-const calcFallback = (metaName)=>`x-${cutNameByHyphen(metaName)}-ssr-fallback`;
-const readUnsafeHeaders = (ssrConfig)=>{
-    if (!ssrConfig || 'object' != typeof ssrConfig) return;
-    const unsafeHeaders = ssrConfig.unsafeHeaders;
-    if (!Array.isArray(unsafeHeaders)) return;
-    return unsafeHeaders.filter((header)=>'string' == typeof header && header.trim().length > 0);
-};
-const resolveUnsafeHeaders = (conf, entryName)=>{
-    if (!entryName) return readUnsafeHeaders(conf.server?.ssr);
-    const entrySSRConfig = conf.server?.ssrByEntries?.[entryName];
-    return readUnsafeHeaders(entrySSRConfig) ?? readUnsafeHeaders(conf.server?.ssr);
-};
-const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, ssrRender, metaName = 'modern-js' })=>async function({ ctx, route, runner }) {
-        if (ctx.resHasHandled()) return null;
-        const { entryPath, urlPath } = route;
-        const unsafeHeaders = resolveUnsafeHeaders(conf, route.entryName);
-        const entry = path.join(distDir, entryPath);
-        if (!route.isSPA) {
-            const result = await handleDirectory(ctx, entry, urlPath);
-            return result;
-        }
-        const templatePath = entry;
-        const content = await readFile(templatePath);
-        if (!content) return null;
-        const useCSR = forceCSR && (ctx.query.csr || ctx.headers[calcFallback(metaName)]);
-        if (route.isSSR && !useCSR) try {
-            const userAgent = ctx.getReqHeader('User-Agent');
-            const disablePreload = Boolean(ctx.headers[`x-${cutNameByHyphen(metaName)}-disable-preload`]);
-            if (shouldFlushServerHeader(conf.server, userAgent, disablePreload)) {
-                const { flushServerHeader } = await import("../preload");
-                flushServerHeader({
-                    serverConf: conf.server,
-                    ctx,
-                    distDir,
-                    template: content.toString(),
-                    headers: {
-                        'Content-Type': mime.contentType(path.extname(templatePath))
-                    }
-                });
-            }
-            const ssrRenderOptions = {
-                distDir,
-                entryName: route.entryName,
-                urlPath: route.urlPath,
-                bundle: route.bundle,
-                template: content.toString(),
-                staticGenerate,
-                unsafeHeaders,
-                nonce
-            };
-            const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : __rspack_external__ssr_mjs_81ad94dd.render(ctx, {
-                distDir,
-                entryName: route.entryName,
-                urlPath: route.urlPath,
-                bundle: route.bundle,
-                template: content.toString(),
-                staticGenerate,
-                unsafeHeaders,
-                nonce
-            }, runner));
-            return result;
-        } catch (err) {
-            ctx.error(ERROR_DIGEST.ERENDER, err.stack || err.message);
-            ctx.res.set(calcFallback(metaName), '1');
-        }
-        return {
-            content: route.entryName ? injectServerData(content.toString(), ctx, {
-                unsafeHeaders
-            }) : content,
-            contentType: mime.contentType(path.extname(templatePath))
-        };
-    };
-export { createRenderHandler };