@modern-js/server-core 2.49.4 → 2.49.5-alpha.1

package/dist/esm/base/middlewares/renderHandler/index.js

@@ -1,14 +1,15 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { checkIsProd, sortRoutes, getRuntimeEnv } from "../../utils";
 import { initReporter } from "../monitor";
-import { CustomServer } from "../customServer";
+import { CustomServer, getLoaderCtx } from "../customServer";
 import { createRender } from "./render";
 function createRenderHandler(render) {
   return function() {
     var _ref = _async_to_generator(function(c, _) {
-      var _c_env_node, logger, reporter, templates, serverManifest, locals, metrics, request, nodeReq, res, body, status, headers, headersData;
+      var _c_env_node, logger, reporter, templates, serverManifest, locals, metrics, loaderContext, request, nodeReq, res, body, status, headers, headersData;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
@@ -18,6 +19,7 @@ function createRenderHandler(render) {
             serverManifest = c.get("serverManifest") || {};
             locals = c.get("locals");
             metrics = c.get("metrics");
+            loaderContext = getLoaderCtx(c);
             request = c.req.raw;
             nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
             return [
@@ -29,6 +31,7 @@ function createRenderHandler(render) {
                 templates,
                 metrics,
                 serverManifest,
+                loaderContext,
                 locals
               })
             ];
@@ -114,7 +117,7 @@ function bindRenderHandler(server, options) {
 }
 function _bindRenderHandler() {
   _bindRenderHandler = _async_to_generator(function(server, options) {
-    var routes, pwd, disableCustomHook, runner, customServer, cacheModuleName, ssrCache, pageRoutes, render, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, originUrlPath, entryName, urlPath, customServerHookMiddleware, customServerMiddleware;
+    var routes, pwd, disableCustomHook, runner, customServer, cacheModuleName, ssrCache, pageRoutes, render, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, originUrlPath, entryName, urlPath, customServerHookMiddleware, customServerMiddleware, _server, err;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -123,7 +126,7 @@ function _bindRenderHandler() {
           if (!(routes && routes.length > 0))
             return [
               3,
-              5
+              12
             ];
           customServer = new CustomServer(runner, server, pwd);
           if (!(getRuntimeEnv() === "node"))
@@ -156,34 +159,79 @@ function _bindRenderHandler() {
         case 4:
           render = _state.sent();
           _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-          try {
-            for (_iterator = pageRoutes[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-              route = _step.value;
-              originUrlPath = route.urlPath, entryName = route.entryName;
-              urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
-              customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
-              server.use(urlPath, initReporter(entryName));
-              !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
-              customServerMiddleware = customServer.getServerMiddleware();
+          _state.label = 5;
+        case 5:
+          _state.trys.push([
+            5,
+            10,
+            11,
+            12
+          ]);
+          _iterator = pageRoutes[Symbol.iterator]();
+          _state.label = 6;
+        case 6:
+          if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+            return [
+              3,
+              9
+            ];
+          route = _step.value;
+          originUrlPath = route.urlPath, entryName = route.entryName;
+          urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
+          customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
+          server.use(urlPath, initReporter(entryName));
+          !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
+          return [
+            4,
+            customServer.getServerMiddleware()
+          ];
+        case 7:
+          customServerMiddleware = _state.sent();
+          if (customServerMiddleware) {
+            if (Array.isArray(customServerMiddleware)) {
+              ;
+              (_server = server).use.apply(_server, [
+                urlPath
+              ].concat(_to_consumable_array(customServerMiddleware)));
+            } else {
               server.use(urlPath, customServerMiddleware);
-              render && server.all(urlPath, createRenderHandler(render));
             }
-          } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
+          }
+          render && server.all(urlPath, createRenderHandler(render));
+          _state.label = 8;
+        case 8:
+          _iteratorNormalCompletion = true;
+          return [
+            3,
+            6
+          ];
+        case 9:
+          return [
+            3,
+            12
+          ];
+        case 10:
+          err = _state.sent();
+          _didIteratorError = true;
+          _iteratorError = err;
+          return [
+            3,
+            12
+          ];
+        case 11:
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
           } finally {
-            try {
-              if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-              }
-            } finally {
-              if (_didIteratorError) {
-                throw _iteratorError;
-              }
+            if (_didIteratorError) {
+              throw _iteratorError;
             }
           }
-          _state.label = 5;
-        case 5:
+          return [
+            7
+          ];
+        case 12:
           return [
             2
           ];

package/dist/esm/base/middlewares/renderHandler/render.js

@@ -3,8 +3,8 @@ import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
+import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest } from "../../utils";
 import { REPLACE_REG } from "../../../base/constants";
-import { createErrorHtml, sortRoutes, parseQuery, transformResponse, getPathname, onError as onErrorFn, ErrorDigest } from "../../utils";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
 function getRouter(routes) {
@@ -53,11 +53,11 @@ function _createRender() {
         2,
         function() {
           var _ref = _async_to_generator(function(req, param2) {
-            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, _matchRoute, routeInfo, params, onFallback, html, renderMode, onError, renderOptions, response;
+            var logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext, _matchRoute, routeInfo, params, onFallback, html, renderMode, onError, renderOptions, response;
             return _ts_generator(this, function(_state2) {
               switch (_state2.label) {
                 case 0:
-                  logger = param2.logger, nodeReq = param2.nodeReq, reporter = param2.reporter, templates = param2.templates, serverManifest = param2.serverManifest, locals = param2.locals, metrics = param2.metrics;
+                  logger = param2.logger, nodeReq = param2.nodeReq, reporter = param2.reporter, templates = param2.templates, serverManifest = param2.serverManifest, locals = param2.locals, metrics = param2.metrics, loaderContext = param2.loaderContext;
                   _matchRoute = _sliced_to_array(matchRoute(router, req), 2), routeInfo = _matchRoute[0], params = _matchRoute[1];
                   onFallback = function() {
                     var _ref2 = _async_to_generator(function(reason, error) {
@@ -141,7 +141,8 @@ function _createRender() {
                     params,
                     locals,
                     serverManifest,
-                    metrics
+                    metrics,
+                    loaderContext: loaderContext || /* @__PURE__ */ new Map()
                   };
                   switch (renderMode) {
                     case "data":

package/dist/esm/base/middlewares/renderHandler/ssrCache.js

@@ -6,8 +6,8 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { Readable } from "stream";
 import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
 import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
-import { createReadableStreamFromReadable } from "../../adapters/node/polyfills/stream";
 import { createTransformStream, getPathname } from "../../utils";
+import { createReadableStreamFromReadable } from "../../adapters/node/polyfills/stream";
 var CacheManager = /* @__PURE__ */ function() {
   "use strict";
   function CacheManager2(container) {

package/dist/esm/base/middlewares/renderHandler/ssrRender.js

@@ -24,11 +24,11 @@ function ssrRender(request, _) {
 }
 function _ssrRender() {
   _ssrRender = _async_to_generator(function(request, param) {
-    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, host, isSpider, responseProxy, query, headers, key, ssrContext, renderBundle, runtimeEnv, ssrResult, cacheStatus, render, cacheModuleName, ssrCache, incomingMessage, cacheControl, _ref, data, status, redirection, headers1, Readable, streamModule, createReadableStreamFromReadable, _tmp, data1;
+    var routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, _serverManifest_renderBundles, entryName, loadableStats, routeManifest, host, isSpider, responseProxy, query, headers, key, ssrContext, renderBundle, runtimeEnv, ssrResult, cacheStatus, render, cacheModuleName, ssrCache, incomingMessage, cacheControl, _ref, data, status, redirection, headers1, Readable, streamModule, createReadableStreamFromReadable, _tmp, data1;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          routeInfo = param.routeInfo, html = param.html, staticGenerate = param.staticGenerate, nonce = param.nonce, metaName = param.metaName, reporter = param.reporter, logger = param.logger, nodeReq = param.nodeReq, serverManifest = param.serverManifest, locals = param.locals, params = param.params, metrics = param.metrics;
+          routeInfo = param.routeInfo, html = param.html, staticGenerate = param.staticGenerate, nonce = param.nonce, metaName = param.metaName, reporter = param.reporter, logger = param.logger, nodeReq = param.nodeReq, serverManifest = param.serverManifest, locals = param.locals, params = param.params, metrics = param.metrics, loaderContext = param.loaderContext;
           entryName = routeInfo.entryName;
           loadableStats = serverManifest.loadableStats || {};
           routeManifest = serverManifest.routeManifest || {};
@@ -66,6 +66,7 @@ function _ssrRender() {
             redirection: {},
             template: html,
             loadableStats,
+            loaderContext,
             routeManifest,
             entryName,
             staticGenerate,

package/dist/esm/base/utils/index.js

@@ -1,7 +1,7 @@
 export * from "./env";
-export * from "./request";
 export * from "./transformStream";
 export * from "./middlewareCollector";
 export * from "./error";
 export * from "./warmup";
 export * from "./entry";
+export * from "./request";

package/dist/esm/base/utils/request.js

@@ -1,12 +1,12 @@
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
-function parseQuery(request) {
-  var url = request.url;
-  var q = url.split("?")[1];
+function parseQuery(req) {
   var query = {};
+  var url = req.url;
+  var q = url.split("?")[1];
   if (q) {
-    q.split("&").forEach(function(item) {
-      var _item_split = _sliced_to_array(item.split("="), 2), key = _item_split[0], value = _item_split[1];
-      query[key] = value;
+    var search = new URLSearchParams(q);
+    search.forEach(function(v, k) {
+      query[k] = v;
     });
   }
   return query;
@@ -31,9 +31,21 @@ function getHost(request) {
   host = (host === null || host === void 0 ? void 0 : host.split(/\s*,\s*/, 1)[0]) || "undefined";
   return host;
 }
+function parseCookie(req) {
+  var _cookie = req.headers.get("Cookie");
+  var cookie = {};
+  _cookie === null || _cookie === void 0 ? void 0 : _cookie.trim().split(";").forEach(function(item) {
+    var _item_trim_split = _sliced_to_array(item.trim().split("="), 2), k = _item_trim_split[0], v = _item_trim_split[1];
+    if (k) {
+      cookie[k] = v;
+    }
+  });
+  return cookie;
+}
 export {
   getHost,
   getPathname,
+  parseCookie,
   parseHeaders,
   parseQuery
 };

package/dist/esm-node/base/adapters/node/node.js

@@ -2,7 +2,7 @@ import { ServerResponse } from "node:http";
 import { createReadableStreamFromReadable, writeReadableStreamToWritable } from "./polyfills/stream";
 import { installGlobals } from "./polyfills/install";
 installGlobals();
-const createWebRequest = (req, res) => {
+const createWebRequest = (req, res, body) => {
   var _req_url;
   const headerRecord = [];
   const len = req.rawHeaders.length;
@@ -20,8 +20,8 @@ const createWebRequest = (req, res) => {
     signal: controller.signal
   };
   res.on("close", () => controller.abort());
-  if (!(method === "GET" || method === "HEAD") && ((_req_url = req.url) === null || _req_url === void 0 ? void 0 : _req_url.includes("__loader"))) {
-    init.body = createReadableStreamFromReadable(req);
+  if (body || !(method === "GET" || method === "HEAD") && ((_req_url = req.url) === null || _req_url === void 0 ? void 0 : _req_url.includes("__loader"))) {
+    init.body = body !== null && body !== void 0 ? body : createReadableStreamFromReadable(req);
     init.duplex = "half";
   }
   const url = `http://${req.headers.host}${req.url}`;

package/dist/esm-node/base/index.js

@@ -1,6 +1,6 @@
 import { createErrorHtml, onError, ErrorDigest } from "./utils";
 import { AGGRED_DIR } from "./constants";
-import { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy } from "./middlewares";
+import { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy, getLoaderCtx } from "./middlewares";
 import { createServerBase } from "./serverBase";
 export {
   AGGRED_DIR,
@@ -9,6 +9,7 @@ export {
   createErrorHtml,
   createServerBase,
   favionFallbackMiddleware,
+  getLoaderCtx,
   getRenderHandler,
   injectLogger,
   injectReporter,

package/dist/esm-node/base/middlewares/customServer/index.js

@@ -1,8 +1,10 @@
 import { time } from "@modern-js/runtime-utils/time";
 import { transformResponse } from "../../utils";
 import { ServerReportTimings } from "../../constants";
+import { getLoaderCtx } from "./loader";
 import { getAfterMatchCtx, getAfterRenderCtx, createCustomMiddlewaresCtx, createAfterStreamingRenderContext } from "./context";
 import { createBaseHookContext } from "./base";
+import { getLoaderCtx as getLoaderCtx2 } from "./loader";
 const noop = () => {
 };
 const isHtmlResponse = (response) => {
@@ -70,13 +72,16 @@ class CustomServer {
       }
     };
   }
-  getServerMiddleware() {
+  async getServerMiddleware() {
+    const serverMiddleware = await this.serverMiddlewarePromise;
+    if (!serverMiddleware) {
+      return;
+    }
+    if (Array.isArray(serverMiddleware)) {
+      return getUnstableMiddlewares(serverMiddleware);
+    }
     return async (c, next) => {
       var _c_env;
-      const serverMiddleware = await this.serverMiddlewarePromise;
-      if (!serverMiddleware) {
-        return next();
-      }
       const reporter = c.get("reporter");
       const locals = {};
       const resArgs = {
@@ -109,7 +114,7 @@ class CustomServer {
         middleware: webExtension
       }
     }, {
-      onLast: () => null
+      onLast: () => []
     });
   }
 }
@@ -121,6 +126,40 @@ function isRedirect(headers, code) {
     308
   ].includes(code || 0) || headers.get("Location");
 }
+function getUnstableMiddlewares(serverMiddleware) {
+  return serverMiddleware.map((middleware) => {
+    return async (c, next) => {
+      const context = createMiddlewareContextFromHono(c);
+      return middleware(context, next);
+    };
+  });
+}
+function createMiddlewareContextFromHono(c) {
+  const loaderContext = getLoaderCtx(c);
+  return {
+    get request() {
+      return c.req.raw;
+    },
+    get response() {
+      return c.res;
+    },
+    set response(newRes) {
+      c.res = newRes;
+    },
+    get(key) {
+      return loaderContext.get(key);
+    },
+    set(key, value) {
+      return loaderContext.set(key, value);
+    },
+    status: c.status.bind(c),
+    header: c.header.bind(c),
+    body: c.body.bind(c),
+    html: c.html.bind(c),
+    redirect: c.redirect.bind(c)
+  };
+}
 export {
-  CustomServer
+  CustomServer,
+  getLoaderCtx2 as getLoaderCtx
 };

package/dist/esm-node/base/middlewares/customServer/loader.js

@@ -0,0 +1,13 @@
+function getLoaderCtx(c) {
+  const loaderContext = c.get("loaderContext");
+  if (loaderContext) {
+    return loaderContext;
+  } else {
+    const loaderContext2 = /* @__PURE__ */ new Map();
+    c.set("loaderContext", loaderContext2);
+    return loaderContext2;
+  }
+}
+export {
+  getLoaderCtx
+};

package/dist/esm-node/base/middlewares/index.js

@@ -3,3 +3,7 @@ export * from "./monitor";
 export * from "./renderHandler";
 export * from "./logger";
 export * from "./frameworkHeader";
+import { getLoaderCtx } from "./customServer";
+export {
+  getLoaderCtx
+};

package/dist/esm-node/base/middlewares/renderHandler/index.js

@@ -1,6 +1,6 @@
 import { checkIsProd, sortRoutes, getRuntimeEnv } from "../../utils";
 import { initReporter } from "../monitor";
-import { CustomServer } from "../customServer";
+import { CustomServer, getLoaderCtx } from "../customServer";
 import { createRender } from "./render";
 function createRenderHandler(render) {
   return async (c, _) => {
@@ -11,6 +11,7 @@ function createRenderHandler(render) {
     const serverManifest = c.get("serverManifest") || {};
     const locals = c.get("locals");
     const metrics = c.get("metrics");
+    const loaderContext = getLoaderCtx(c);
     const request = c.req.raw;
     const nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
     const res = await render(request, {
@@ -20,6 +21,7 @@ function createRenderHandler(render) {
       templates,
       metrics,
       serverManifest,
+      loaderContext,
       locals
     });
     const { body, status, headers } = res;
@@ -74,8 +76,14 @@ async function bindRenderHandler(server, options) {
       const customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
       server.use(urlPath, initReporter(entryName));
       !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
-      const customServerMiddleware = customServer.getServerMiddleware();
-      server.use(urlPath, customServerMiddleware);
+      const customServerMiddleware = await customServer.getServerMiddleware();
+      if (customServerMiddleware) {
+        if (Array.isArray(customServerMiddleware)) {
+          server.use(urlPath, ...customServerMiddleware);
+        } else {
+          server.use(urlPath, customServerMiddleware);
+        }
+      }
       render && server.all(urlPath, createRenderHandler(render));
     }
   }

package/dist/esm-node/base/middlewares/renderHandler/render.js

@@ -1,7 +1,7 @@
 import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
+import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest } from "../../utils";
 import { REPLACE_REG } from "../../../base/constants";
-import { createErrorHtml, sortRoutes, parseQuery, transformResponse, getPathname, onError as onErrorFn, ErrorDigest } from "../../utils";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
 function getRouter(routes) {
@@ -22,7 +22,7 @@ function matchRoute(router, request) {
 }
 async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallback: onFallbackFn }) {
   const router = getRouter(routes);
-  return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics }) => {
+  return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext }) => {
     const [routeInfo, params] = matchRoute(router, req);
     const onFallback = async (reason, error) => {
       return onFallbackFn === null || onFallbackFn === void 0 ? void 0 : onFallbackFn(reason, {
@@ -67,7 +67,8 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       params,
       locals,
       serverManifest,
-      metrics
+      metrics,
+      loaderContext: loaderContext || /* @__PURE__ */ new Map()
     };
     switch (renderMode) {
       case "data":

package/dist/esm-node/base/middlewares/renderHandler/ssrCache.js

@@ -1,8 +1,8 @@
 import { Readable } from "stream";
 import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
 import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
-import { createReadableStreamFromReadable } from "../../adapters/node/polyfills/stream";
 import { createTransformStream, getPathname } from "../../utils";
+import { createReadableStreamFromReadable } from "../../adapters/node/polyfills/stream";
 class CacheManager {
   async getCacheResult(req, cacheControl, render, ssrContext) {
     const key = this.computedKey(req, cacheControl);

package/dist/esm-node/base/middlewares/renderHandler/ssrRender.js

@@ -15,7 +15,7 @@ const defaultReporter = {
   reportWarn() {
   }
 };
-async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics }) {
+async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext }) {
   var _serverManifest_renderBundles;
   const { entryName } = routeInfo;
   const loadableStats = serverManifest.loadableStats || {};
@@ -54,6 +54,7 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
     redirection: {},
     template: html,
     loadableStats,
+    loaderContext,
     routeManifest,
     entryName,
     staticGenerate,

package/dist/esm-node/base/utils/index.js

@@ -1,7 +1,7 @@
 export * from "./env";
-export * from "./request";
 export * from "./transformStream";
 export * from "./middlewareCollector";
 export * from "./error";
 export * from "./warmup";
 export * from "./entry";
+export * from "./request";

package/dist/esm-node/base/utils/request.js

@@ -1,11 +1,11 @@
-function parseQuery(request) {
-  const { url } = request;
-  const q = url.split("?")[1];
+function parseQuery(req) {
   const query = {};
+  const { url } = req;
+  const q = url.split("?")[1];
   if (q) {
-    q.split("&").forEach((item) => {
-      const [key, value] = item.split("=");
-      query[key] = value;
+    const search = new URLSearchParams(q);
+    search.forEach((v, k) => {
+      query[k] = v;
     });
   }
   return query;
@@ -30,9 +30,21 @@ function getHost(request) {
   host = (host === null || host === void 0 ? void 0 : host.split(/\s*,\s*/, 1)[0]) || "undefined";
   return host;
 }
+function parseCookie(req) {
+  const _cookie = req.headers.get("Cookie");
+  const cookie = {};
+  _cookie === null || _cookie === void 0 ? void 0 : _cookie.trim().split(";").forEach((item) => {
+    const [k, v] = item.trim().split("=");
+    if (k) {
+      cookie[k] = v;
+    }
+  });
+  return cookie;
+}
 export {
   getHost,
   getPathname,
+  parseCookie,
   parseHeaders,
   parseQuery
 };

package/dist/types/base/adapters/node/node.d.ts

@@ -4,7 +4,7 @@ import { Server as NodeServer } from 'node:http';
 import type { Server as NodeHttpsServer } from 'node:https';
 import { NodeRequest, NodeResponse } from '../../../core/plugin';
 import { RequestHandler } from '../../../core/server';
-export declare const createWebRequest: (req: NodeRequest, res: NodeResponse) => Request;
+export declare const createWebRequest: (req: NodeRequest, res: NodeResponse, body?: BodyInit) => Request;
 export declare const sendResponse: (response: Response, res: NodeResponse) => Promise<void>;
 declare const getRequestListener: (handler: RequestHandler) => (req: NodeRequest, res: NodeResponse) => Promise<void>;
 type NodeServerWrapper = (NodeServer | NodeHttpsServer) & {

package/dist/types/base/index.d.ts

@@ -1,6 +1,6 @@
 export { createErrorHtml, onError, ErrorDigest } from './utils';
 export { AGGRED_DIR } from './constants';
-export { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy, } from './middlewares';
+export { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy, getLoaderCtx, } from './middlewares';
 export type { BindRenderHandleOptions } from './middlewares';
 export type { ServerBase, ServerBaseOptions } from './serverBase';
 export { createServerBase } from './serverBase';

package/dist/types/base/middlewares/customServer/index.d.ts

@@ -3,11 +3,12 @@ import { ServerBase } from '../../serverBase';
 import { ServerHookRunner } from '../../../core/plugin';
 import { Middleware, ServerEnv } from '../../../core/server';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
+export { getLoaderCtx } from './loader';
 export declare class CustomServer {
     private runner;
     private serverMiddlewarePromise;
     private serverBase;
     constructor(runner: ServerHookRunner, serverBase: ServerBase, pwd: string);
     getHookMiddleware(entryName: string, routes: ServerRoute[]): Middleware<ServerEnv>;
-    getServerMiddleware(): Middleware<ServerNodeEnv & ServerEnv>;
+    getServerMiddleware(): Promise<Middleware<ServerNodeEnv & ServerEnv> | Array<Middleware<ServerNodeEnv & ServerEnv>> | undefined>;
 }

package/dist/types/base/middlewares/customServer/loader.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '../../../core/server';
+type LoaderContext = Map<string, unknown>;
+type Var = {
+    loaderContext: LoaderContext;
+};
+interface Env {
+    Variables: Var;
+}
+export declare function getLoaderCtx(c: Context<Env>): LoaderContext;
+export {};

package/dist/types/base/middlewares/index.d.ts

@@ -3,3 +3,4 @@ export * from './monitor';
 export * from './renderHandler';
 export * from './logger';
 export * from './frameworkHeader';
+export { getLoaderCtx } from './customServer';

package/dist/types/base/middlewares/renderHandler/ssrRender.d.ts

@@ -11,6 +11,7 @@ export interface SSRRenderOptions {
     metaName: string;
     logger: Logger;
     serverManifest: ServerManifest;
+    loaderContext: Map<string, unknown>;
     params: Params;
     /** Produce by custom server hook */
     locals?: Record<string, any>;
@@ -19,5 +20,5 @@ export interface SSRRenderOptions {
     nodeReq?: IncomingMessage;
     nonce?: string;
 }
-export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, }: SSRRenderOptions): Promise<Response>;
+export declare function ssrRender(request: Request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, }: SSRRenderOptions): Promise<Response>;
 export declare function getPathnameFromNodeReq(nodeReq: IncomingMessage): string;

package/dist/types/base/utils/index.d.ts

@@ -1,7 +1,7 @@
 export * from './env';
-export * from './request';
 export * from './transformStream';
 export * from './middlewareCollector';
 export * from './error';
 export * from './warmup';
 export * from './entry';
+export * from './request';