@modern-js/server-core 2.69.7 → 3.0.0-alpha.1

package/dist/cjs/plugins/render/render.js

@@ -1,287 +1,260 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var render_exports = {};
-__export(render_exports, {
-  createRender: () => createRender
-});
-module.exports = __toCommonJS(render_exports);
-var import_universal = require("@modern-js/utils/universal");
-var import_trie_router = require("hono/router/trie-router");
-var import_constants = require("../../constants");
-var import_utils = require("../../utils");
-var import_utils2 = require("../../utils");
-var import_csrRscRender = require("./csrRscRender");
-var import_dataHandler = require("./dataHandler");
-var import_renderRscHandler = require("./renderRscHandler");
-var import_serverActionHandler = require("./serverActionHandler");
-var import_ssrRender = require("./ssrRender");
-const DYNAMIC_ROUTE_REG = /\/:./;
-function getRouter(routes) {
-  const dynamicRoutes = [];
-  const normalRoutes = [];
-  routes.forEach((route) => {
-    if (DYNAMIC_ROUTE_REG.test(route.urlPath)) {
-      dynamicRoutes.push(route);
-    } else {
-      normalRoutes.push(route);
+var __webpack_modules__ = {
+    "@modern-js/runtime-utils/router" (module) {
+        module.exports = require("@modern-js/runtime-utils/router");
     }
-  });
-  const finalRoutes = [
-    ...normalRoutes.sort(import_utils2.sortRoutes),
-    ...dynamicRoutes.sort(import_utils2.sortRoutes)
-  ];
-  const router = new import_trie_router.TrieRouter();
-  for (const route of finalRoutes) {
-    const { urlPath: originUrlPath } = route;
-    const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
-    router.add("*", urlPath, route);
-  }
-  return router;
-}
-function matchRoute(router, pathname, entryName) {
-  const matched = router.match("*", pathname);
-  if (entryName && matched[0].length > 1) {
-    const matches = matched[0];
-    const result = matches.find(([route]) => route.entryName === entryName);
-    return result || [];
-  } else {
-    const result = matched[0][0];
-    return result || [];
-  }
-}
-function getHeadersWithoutCookie(headers) {
-  const _headers = {
-    ...headers,
-    cookie: void 0
-  };
-  delete _headers.cookie;
-  return _headers;
+};
+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;
 }
-async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config, onFallback }) {
-  const router = getRouter(routes);
-  return async (req, { logger, reporter, metrics, monitors, nodeReq, templates, serverManifest, rscClientManifest, rscSSRManifest, rscServerManifest, locals, matchEntryName, matchPathname, loaderContext }) => {
-    const forMatchpathname = matchPathname !== null && matchPathname !== void 0 ? matchPathname : (0, import_utils2.getPathname)(req);
-    const [routeInfo, params] = matchRoute(router, forMatchpathname, matchEntryName);
-    const framework = (0, import_universal.cutNameByHyphen)(metaName || "modern-js");
-    const fallbackHeader = `x-${framework}-ssr-fallback`;
-    let fallbackReason = null;
-    const fallbackWrapper = async (reason, error) => {
-      fallbackReason = reason;
-      return onFallback === null || onFallback === void 0 ? void 0 : onFallback(reason, {
-        logger,
-        reporter,
-        metrics
-      }, error);
+(()=>{
+    __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
+        });
     };
-    if (!routeInfo) {
-      return new Response((0, import_utils2.createErrorHtml)(404), {
-        status: 404,
-        headers: {
-          "content-type": "text/html; charset=UTF-8"
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        createRender: ()=>createRender
+    });
+    const universal_namespaceObject = require("@modern-js/utils/universal");
+    const trie_router_namespaceObject = require("hono/router/trie-router");
+    const external_constants_js_namespaceObject = require("../../constants.js");
+    const index_js_namespaceObject = require("../../utils/index.js");
+    const external_csrRscRender_js_namespaceObject = require("./csrRscRender.js");
+    const external_dataHandler_js_namespaceObject = require("./dataHandler.js");
+    const external_renderRscHandler_js_namespaceObject = require("./renderRscHandler.js");
+    const external_serverActionHandler_js_namespaceObject = require("./serverActionHandler.js");
+    const external_ssrRender_js_namespaceObject = require("./ssrRender.js");
+    const DYNAMIC_ROUTE_REG = /\/:./;
+    function getRouter(routes) {
+        const dynamicRoutes = [];
+        const normalRoutes = [];
+        routes.forEach((route)=>{
+            if (DYNAMIC_ROUTE_REG.test(route.urlPath)) dynamicRoutes.push(route);
+            else normalRoutes.push(route);
+        });
+        const finalRoutes = [
+            ...normalRoutes.sort(index_js_namespaceObject.sortRoutes),
+            ...dynamicRoutes.sort(index_js_namespaceObject.sortRoutes)
+        ];
+        const router = new trie_router_namespaceObject.TrieRouter();
+        for (const route of finalRoutes){
+            const { urlPath: originUrlPath } = route;
+            const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;
+            router.add('*', urlPath, route);
         }
-      });
+        return router;
     }
-    const html = templates[(0, import_utils.uniqueKeyByRoute)(routeInfo)];
-    if (!html) {
-      return new Response((0, import_utils2.createErrorHtml)(404), {
-        status: 404,
-        headers: {
-          "content-type": "text/html; charset=UTF-8"
+    function matchRoute(router, pathname, entryName) {
+        const matched = router.match('*', pathname);
+        if (entryName && matched[0].length > 1) {
+            const matches = matched[0];
+            const result = matches.find(([route])=>route.entryName === entryName);
+            return result || [];
+        }
+        {
+            const result = matched[0][0];
+            return result || [];
         }
-      });
-    }
-    var _forceCSRMap_get;
-    const finalForceCSR = routeInfo.entryName ? (_forceCSRMap_get = forceCSRMap === null || forceCSRMap === void 0 ? void 0 : forceCSRMap.get(routeInfo.entryName)) !== null && _forceCSRMap_get !== void 0 ? _forceCSRMap_get : forceCSR : forceCSR;
-    const renderMode = await getRenderMode(req, fallbackHeader, routeInfo.isSSR, finalForceCSR, nodeReq, fallbackWrapper);
-    const headerData = (0, import_utils2.parseHeaders)(req);
-    const onError = (e, key) => {
-      monitors === null || monitors === void 0 ? void 0 : monitors.error(`SSR Error - ${key || (e instanceof Error ? e.name : e)}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, forMatchpathname, getHeadersWithoutCookie(headerData));
-    };
-    const onTiming = (name, dur) => {
-      monitors === null || monitors === void 0 ? void 0 : monitors.timing(name, dur, "SSR");
-    };
-    const renderOptions = {
-      pwd,
-      html,
-      routeInfo,
-      staticGenerate: staticGenerate || false,
-      config,
-      nodeReq,
-      cacheConfig,
-      reporter,
-      serverRoutes: routes,
-      params,
-      logger,
-      metrics,
-      monitors,
-      locals,
-      rscClientManifest,
-      rscSSRManifest,
-      rscServerManifest,
-      serverManifest,
-      loaderContext: loaderContext || /* @__PURE__ */ new Map(),
-      onError,
-      onTiming
-    };
-    if (fallbackReason) {
-      renderOptions.html = injectFallbackReasonToHtml({
-        html: renderOptions.html,
-        reason: fallbackReason,
-        framework
-      });
     }
-    let response;
-    switch (renderMode) {
-      case "data":
-        response = await (0, import_dataHandler.dataHandler)(req, renderOptions) || await renderHandler(req, renderOptions, "ssr", fallbackWrapper, framework);
-        break;
-      case "rsc-tree":
-        response = await (0, import_renderRscHandler.renderRscHandler)(req, renderOptions);
-        break;
-      case "rsc-action":
-        response = await (0, import_serverActionHandler.serverActionHandler)(req, renderOptions);
-        break;
-      case "ssr":
-      case "csr":
-        response = await renderHandler(req, renderOptions, renderMode, fallbackWrapper, framework);
-        break;
-      default:
-        throw new Error(`Unknown render mode: ${renderMode}`);
+    function getHeadersWithoutCookie(headers) {
+        const _headers = {
+            ...headers,
+            cookie: void 0
+        };
+        delete _headers.cookie;
+        return _headers;
     }
-    if (fallbackReason) {
-      response.headers.set(fallbackHeader, `1;reason=${fallbackReason}`);
+    async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config, onFallback }) {
+        const router = getRouter(routes);
+        return async (req, { monitors, nodeReq, templates, serverManifest, rscClientManifest, rscSSRManifest, rscServerManifest, locals, matchEntryName, matchPathname, loaderContext, contextForceCSR, reporter })=>{
+            const forMatchpathname = matchPathname ?? (0, index_js_namespaceObject.getPathname)(req);
+            const [routeInfo, params] = matchRoute(router, forMatchpathname, matchEntryName);
+            const framework = (0, universal_namespaceObject.cutNameByHyphen)(metaName || 'modern-js');
+            const fallbackHeader = `x-${framework}-ssr-fallback`;
+            let fallbackReason = null;
+            const fallbackWrapper = async (reason, error)=>{
+                fallbackReason = reason;
+                return onFallback?.(reason, error);
+            };
+            if (!routeInfo) return new Response((0, index_js_namespaceObject.createErrorHtml)(404), {
+                status: 404,
+                headers: {
+                    'content-type': 'text/html; charset=UTF-8'
+                }
+            });
+            const html = templates[(0, index_js_namespaceObject.uniqueKeyByRoute)(routeInfo)];
+            if (!html) return new Response((0, index_js_namespaceObject.createErrorHtml)(404), {
+                status: 404,
+                headers: {
+                    'content-type': 'text/html; charset=UTF-8'
+                }
+            });
+            const finalForceCSR = routeInfo.entryName ? forceCSRMap?.get(routeInfo.entryName) ?? forceCSR : forceCSR;
+            const renderMode = await getRenderMode(req, fallbackHeader, routeInfo.isSSR, finalForceCSR, nodeReq, fallbackWrapper, contextForceCSR);
+            const headerData = (0, index_js_namespaceObject.parseHeaders)(req);
+            const onError = (e, key)=>{
+                monitors?.error(`SSR Error - ${key || (e instanceof Error ? e.name : e)}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, forMatchpathname, getHeadersWithoutCookie(headerData));
+            };
+            const onTiming = (name, dur)=>{
+                monitors?.timing(name, dur, 'SSR');
+            };
+            const renderOptions = {
+                pwd,
+                html,
+                routeInfo,
+                staticGenerate: staticGenerate || false,
+                config,
+                nodeReq,
+                cacheConfig,
+                serverRoutes: routes,
+                params,
+                monitors,
+                locals,
+                rscClientManifest,
+                rscSSRManifest,
+                rscServerManifest,
+                serverManifest,
+                loaderContext: loaderContext || new Map(),
+                onError,
+                onTiming,
+                reporter
+            };
+            if (fallbackReason) renderOptions.html = injectFallbackReasonToHtml({
+                html: renderOptions.html,
+                reason: fallbackReason,
+                framework
+            });
+            let response;
+            switch(renderMode){
+                case 'data':
+                    response = await (0, external_dataHandler_js_namespaceObject.dataHandler)(req, renderOptions) || await renderHandler(req, renderOptions, 'ssr', fallbackWrapper, framework);
+                    break;
+                case 'rsc-tree':
+                    response = await (0, external_renderRscHandler_js_namespaceObject.renderRscHandler)(req, renderOptions);
+                    break;
+                case 'rsc-action':
+                    response = await (0, external_serverActionHandler_js_namespaceObject.serverActionHandler)(req, renderOptions);
+                    break;
+                case 'ssr':
+                case 'csr':
+                    response = await renderHandler(req, renderOptions, renderMode, fallbackWrapper, framework);
+                    break;
+                default:
+                    throw new Error(`Unknown render mode: ${renderMode}`);
+            }
+            if (fallbackReason) response.headers.set(fallbackHeader, `1;reason=${fallbackReason}`);
+            return response;
+        };
     }
-    return response;
-  };
-}
-async function renderHandler(request, options, mode, fallbackWrapper, framework) {
-  var _options_config_server;
-  let response = null;
-  const { serverManifest } = options;
-  const ssrByRouteIds = (_options_config_server = options.config.server) === null || _options_config_server === void 0 ? void 0 : _options_config_server.ssrByRouteIds;
-  const runtimeEnv = (0, import_utils2.getRuntimeEnv)();
-  if (serverManifest.nestedRoutesJson && ssrByRouteIds && (ssrByRouteIds === null || ssrByRouteIds === void 0 ? void 0 : ssrByRouteIds.length) > 0 && runtimeEnv === "node") {
-    const { nestedRoutesJson } = serverManifest;
-    const routes = nestedRoutesJson === null || nestedRoutesJson === void 0 ? void 0 : nestedRoutesJson[options.routeInfo.entryName];
-    if (routes) {
-      const urlPath = "node:url";
-      const { pathToFileURL } = await import(urlPath);
-      const { matchRoutes } = await import(pathToFileURL(require.resolve("@modern-js/runtime-utils/remix-router")).href);
-      const url = new URL(request.url);
-      const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
-      if (!matchedRoutes) {
-        response = await csrRender(request, options);
-      } else {
-        var _lastMatch_route;
-        const lastMatch = matchedRoutes[matchedRoutes.length - 1];
-        if (!(lastMatch === null || lastMatch === void 0 ? void 0 : (_lastMatch_route = lastMatch.route) === null || _lastMatch_route === void 0 ? void 0 : _lastMatch_route.id) || !ssrByRouteIds.includes(lastMatch.route.id)) {
-          response = await csrRender(request, options);
+    async function renderHandler(request, options, mode, fallbackWrapper, framework) {
+        let response = null;
+        const { serverManifest } = options;
+        const ssrByRouteIds = options.config.server?.ssrByRouteIds;
+        const runtimeEnv = (0, index_js_namespaceObject.getRuntimeEnv)();
+        if (serverManifest.nestedRoutesJson && ssrByRouteIds && ssrByRouteIds?.length > 0 && 'node' === runtimeEnv) {
+            const { nestedRoutesJson } = serverManifest;
+            const routes = nestedRoutesJson?.[options.routeInfo.entryName];
+            if (routes) {
+                const { matchRoutes } = __webpack_require__("@modern-js/runtime-utils/router");
+                const url = new URL(request.url);
+                const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
+                if (matchedRoutes) {
+                    const lastMatch = matchedRoutes[matchedRoutes.length - 1];
+                    if (!lastMatch?.route?.id || !ssrByRouteIds.includes(lastMatch.route.id)) response = await csrRender(request, options);
+                } else response = await csrRender(request, options);
+            }
+        }
+        if ('ssr' !== mode || response) response = await csrRender(request, options);
+        else try {
+            response = await (0, external_ssrRender_js_namespaceObject.ssrRender)(request, options);
+        } catch (e) {
+            options.onError(e, index_js_namespaceObject.ErrorDigest.ERENDER);
+            await fallbackWrapper('error', e);
+            response = await csrRender(request, {
+                ...options,
+                html: injectFallbackReasonToHtml({
+                    html: options.html,
+                    reason: 'error',
+                    framework
+                })
+            });
+        }
+        const { routeInfo } = options;
+        applyExtendHeaders(response, routeInfo);
+        return response;
+        function applyExtendHeaders(r, route) {
+            Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
+                r.headers.set(k, v);
+            });
         }
-      }
     }
-  }
-  if (mode === "ssr" && !response) {
-    try {
-      response = await (0, import_ssrRender.ssrRender)(request, options);
-    } catch (e) {
-      options.onError(e, import_utils2.ErrorDigest.ERENDER);
-      await fallbackWrapper("error", e);
-      response = await csrRender(request, {
-        ...options,
-        html: injectFallbackReasonToHtml({
-          html: options.html,
-          reason: "error",
-          framework
-        })
-      });
+    async function getRenderMode(req, fallbackHeader, isSSR, forceCSR, nodeReq, onFallback, contextForceCSR) {
+        const query = (0, index_js_namespaceObject.parseQuery)(req);
+        if (req.headers.get('x-rsc-action')) return 'rsc-action';
+        if (req.headers.get('x-rsc-tree')) return 'rsc-tree';
+        if (!isSSR) return 'csr';
+        {
+            if (query.__loader) return 'data';
+            const fallbackHeaderValue = req.headers.get(fallbackHeader) || nodeReq?.headers[fallbackHeader];
+            if (forceCSR && (query.csr || fallbackHeaderValue || contextForceCSR)) {
+                if (query.csr) await onFallback?.('query');
+                else {
+                    const reason = fallbackHeaderValue?.split(';')[1]?.split('=')[1];
+                    await onFallback?.(reason ? `header,${reason}` : 'header');
+                }
+                return 'csr';
+            }
+            return 'ssr';
+        }
     }
-  } else {
-    response = await csrRender(request, options);
-  }
-  const { routeInfo } = options;
-  applyExtendHeaders(response, routeInfo);
-  return response;
-  function applyExtendHeaders(r, route) {
-    Object.entries(route.responseHeaders || {}).forEach(([k, v]) => {
-      r.headers.set(k, v);
-    });
-  }
-}
-async function getRenderMode(req, fallbackHeader, isSSR, forceCSR, nodeReq, onFallback) {
-  const query = (0, import_utils2.parseQuery)(req);
-  if (req.headers.get("x-rsc-action")) {
-    return "rsc-action";
-  }
-  if (req.headers.get("x-rsc-tree")) {
-    return "rsc-tree";
-  }
-  if (isSSR) {
-    if (query.__loader) {
-      return "data";
+    function injectFallbackReasonToHtml({ html, reason, framework }) {
+        const tag = `<script id="__${framework}_ssr_fallback_reason__" type="application/json">${JSON.stringify({
+            reason
+        })}</script>`;
+        return html.replace(/<\/head>/, `${tag}</head>`);
     }
-    const fallbackHeaderValue = req.headers.get(fallbackHeader) || (nodeReq === null || nodeReq === void 0 ? void 0 : nodeReq.headers[fallbackHeader]);
-    if (forceCSR && (query.csr || fallbackHeaderValue)) {
-      if (query.csr) {
-        await (onFallback === null || onFallback === void 0 ? void 0 : onFallback("query"));
-      } else {
-        var _fallbackHeaderValue_split_;
-        const reason = fallbackHeaderValue === null || fallbackHeaderValue === void 0 ? void 0 : (_fallbackHeaderValue_split_ = fallbackHeaderValue.split(";")[1]) === null || _fallbackHeaderValue_split_ === void 0 ? void 0 : _fallbackHeaderValue_split_.split("=")[1];
-        await (onFallback === null || onFallback === void 0 ? void 0 : onFallback(reason ? `header,${reason}` : "header"));
-      }
-      return "csr";
+    async function csrRender(request, options) {
+        const { html, rscClientManifest } = options;
+        if (!rscClientManifest || process.env.MODERN_DISABLE_INJECT_RSC_DATA || !options.routeInfo.isRSC) return new Response(html, {
+            status: 200,
+            headers: new Headers({
+                'content-type': 'text/html; charset=UTF-8',
+                [external_constants_js_namespaceObject.X_MODERNJS_RENDER]: 'client'
+            })
+        });
+        return (0, external_csrRscRender_js_namespaceObject.csrRscRender)(request, options);
     }
-    return "ssr";
-  } else {
-    return "csr";
-  }
-}
-function injectFallbackReasonToHtml({ html, reason, framework }) {
-  const tag = `<script id="__${framework}_ssr_fallback_reason__" type="application/json">${JSON.stringify({
-    reason
-  })}</script>`;
-  return html.replace(/<\/head>/, `${tag}</head>`);
-}
-async function csrRender(request, options) {
-  const { html, rscClientManifest } = options;
-  if (!rscClientManifest || process.env.MODERN_DISABLE_INJECT_RSC_DATA || !options.routeInfo.isRSC) {
-    return new Response(html, {
-      status: 200,
-      headers: new Headers({
-        "content-type": "text/html; charset=UTF-8",
-        [import_constants.X_MODERNJS_RENDER]: "client"
-      })
-    });
-  } else {
-    return (0, import_csrRscRender.csrRscRender)(request, options);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createRender
+})();
+exports.createRender = __webpack_exports__.createRender;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRender"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });