@modern-js/plugin-data-loader 2.35.1 → 2.36.0

package/dist/cjs/cli/createRequest.js

@@ -1,49 +1,55 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
   for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  getRequestUrl: function() {
-    return getRequestUrl;
-  },
-  createRequest: function() {
-    return createRequest;
+    __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createRequest_exports = {};
+__export(createRequest_exports, {
+  createActionRequest: () => createActionRequest,
+  createRequest: () => createRequest,
+  getRequestUrl: () => getRequestUrl
 });
-const _pathtoregexp = require("path-to-regexp");
-const _router = require("@modern-js/runtime-utils/router");
-const _constants = require("../common/constants");
-const _data = require("./data");
+module.exports = __toCommonJS(createRequest_exports);
+var import_path_to_regexp = require("path-to-regexp");
+var import_router = require("@modern-js/runtime-utils/router");
+var import_constants = require("../common/constants");
+var import_data = require("./data");
 const getRequestUrl = ({ params, request, routeId }) => {
   const url = new URL(request.url);
-  const toPath = (0, _pathtoregexp.compile)(url.pathname, {
+  const toPath = (0, import_path_to_regexp.compile)(url.pathname, {
     encode: encodeURIComponent
   });
   const newPathName = toPath(params);
   url.pathname = newPathName;
-  url.searchParams.append(_constants.LOADER_ID_PARAM, routeId);
-  url.searchParams.append(_constants.DIRECT_PARAM, "true");
+  url.searchParams.append(import_constants.LOADER_ID_PARAM, routeId);
+  url.searchParams.append(import_constants.DIRECT_PARAM, "true");
   return url;
 };
 const handleRedirectResponse = (res) => {
   const { headers } = res;
   const location = headers.get("X-Modernjs-Redirect");
   if (location) {
-    throw (0, _router.redirect)(location);
+    throw (0, import_router.redirect)(location);
   }
   return res;
 };
 const handleDeferredResponse = async (res) => {
   var _res_headers_get;
-  if (((_res_headers_get = res.headers.get("Content-Type")) === null || _res_headers_get === void 0 ? void 0 : _res_headers_get.match(_constants.CONTENT_TYPE_DEFERRED)) && res.body) {
-    return await (0, _data.parseDeferredReadableStream)(res.body);
+  if (((_res_headers_get = res.headers.get("Content-Type")) === null || _res_headers_get === void 0 ? void 0 : _res_headers_get.match(import_constants.CONTENT_TYPE_DEFERRED)) && res.body) {
+    return await (0, import_data.parseDeferredReadableStream)(res.body);
   }
   return res;
 };
@@ -67,3 +73,45 @@ const createRequest = (routeId, method = "get") => {
     return res;
   };
 };
+const createActionRequest = (routeId) => {
+  return async ({ params, request }) => {
+    const url = getRequestUrl({
+      params,
+      request,
+      routeId
+    });
+    const init = {
+      signal: request.signal
+    };
+    if (request.method !== "GET") {
+      init.method = request.method;
+      const contentType = request.headers.get("Content-Type");
+      if (contentType && /\bapplication\/json\b/.test(contentType)) {
+        init.headers = {
+          "Content-Type": contentType
+        };
+        init.body = JSON.stringify(await request.json());
+      } else if (contentType && /\btext\/plain\b/.test(contentType)) {
+        init.headers = {
+          "Content-Type": contentType
+        };
+        init.body = await request.text();
+      } else if (contentType && /\bapplication\/x-www-form-urlencoded\b/.test(contentType)) {
+        init.body = new URLSearchParams(await request.text());
+      } else {
+        init.body = await request.formData();
+      }
+    }
+    const res = await fetch(url, init);
+    if (!res.ok) {
+      throw res;
+    }
+    return res;
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createActionRequest,
+  createRequest,
+  getRequestUrl
+});

package/dist/cjs/cli/data.js

@@ -1,14 +1,27 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "parseDeferredReadableStream", {
-  enumerable: true,
-  get: function() {
-    return parseDeferredReadableStream;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var data_exports = {};
+__export(data_exports, {
+  parseDeferredReadableStream: () => parseDeferredReadableStream
 });
-const _remixrouter = require("@modern-js/runtime-utils/remix-router");
+module.exports = __toCommonJS(data_exports);
+var import_remix_router = require("@modern-js/runtime-utils/remix-router");
 const DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
 async function parseDeferredReadableStream(stream) {
   if (!stream) {
@@ -67,7 +80,7 @@ async function parseDeferredReadableStream(stream) {
           }
         }
         for (const [key, resolver] of Object.entries(deferredResolvers)) {
-          resolver.reject(new _remixrouter.AbortedDeferredError(`Deferred ${key} will never resolved`));
+          resolver.reject(new import_remix_router.AbortedDeferredError(`Deferred ${key} will never resolved`));
         }
       } catch (error) {
         for (const resolver of Object.values(deferredResolvers)) {
@@ -75,7 +88,7 @@ async function parseDeferredReadableStream(stream) {
         }
       }
     })();
-    return new _remixrouter.UNSAFE_DeferredData({
+    return new import_remix_router.UNSAFE_DeferredData({
       ...criticalData,
       ...deferredData
     });
@@ -145,3 +158,7 @@ function mergeArrays(...arrays) {
   }
   return out;
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseDeferredReadableStream
+});

package/dist/cjs/cli/generateClient.js

@@ -1,47 +1,66 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "generateClient", {
-  enumerable: true,
-  get: function() {
-    return generateClient;
+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 generateClient_exports = {};
+__export(generateClient_exports, {
+  generateClient: () => generateClient
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const generateClient = ({ mapFile, loaderId }) => {
-  delete require.cache[mapFile];
-  const loadersMap = require(mapFile);
+module.exports = __toCommonJS(generateClient_exports);
+var import_path = __toESM(require("path"));
+const generateClient = ({ inline, action, routeId }) => {
   let requestCode = ``;
-  let exportsCode = ``;
-  const requestCreatorPath = _path.default.join(__dirname, "./createRequest").replace("/cjs/cli/", "/esm/cli/").replace(/\\/g, "/");
+  const requestCreatorPath = import_path.default.join(__dirname, "./createRequest").replace("/cjs/cli/", "/esm/cli/").replace(/\\/g, "/");
   const importCode = `
-    import { createRequest } from '${requestCreatorPath}';
+    import { createRequest, createActionRequest } from '${requestCreatorPath}';
   `;
-  if (!loaderId) {
-    requestCode = Object.keys(loadersMap).map((loaderId2) => {
-      const { routeId } = loadersMap[loaderId2];
-      return `
-      const ${loaderId2} = createRequest('${routeId}');
+  if (inline) {
+    if (action) {
+      requestCode = `
+      export const loader = createRequest('${routeId}');
+      export const action = createActionRequest('${routeId}')
+    `;
+    } else {
+      requestCode = `
+      export const loader = createRequest('${routeId}');
     `;
-    }).join("");
-    exportsCode = `export {`;
-    for (const loader of Object.keys(loadersMap)) {
-      exportsCode += `${loader},`;
     }
-    exportsCode += "}";
   } else {
-    const loader = loadersMap[loaderId];
     requestCode = `
-      const loader = createRequest('${loader.routeId}');
-    `;
-    exportsCode = `export default loader;`;
+    export default createRequest('${routeId}');
+  `;
   }
   const generatedCode = `
     ${importCode}
     ${requestCode}
-    ${exportsCode}
   `;
   return generatedCode;
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateClient
+});

package/dist/cjs/cli/loader.js

@@ -1,16 +1,29 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function() {
-    return loader;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loader_exports = {};
+__export(loader_exports, {
+  default: () => loader
 });
-const _util = require("util");
-const _logger = require("@modern-js/utils/logger");
-const _generateClient = require("./generateClient");
+module.exports = __toCommonJS(loader_exports);
+var import_util = require("util");
+var import_logger = require("@modern-js/utils/logger");
+var import_generateClient = require("./generateClient");
 async function loader(source) {
   var _this__compiler;
   this.cacheable();
@@ -22,34 +35,32 @@ async function loader(source) {
     return source;
   }
   const { resourceQuery } = this;
-  const options = resourceQuery.slice(1).split("&").map((item) => {
-    return item.split("=");
-  }).reduce((pre, cur) => {
-    const [key, value] = cur;
-    if (!key || !value) {
-      return pre;
+  const options = resourceQuery.slice(1).split("&").reduce((pre, cur) => {
+    const [key, value] = cur.split("=");
+    if (key && value) {
+      pre[key] = value === "true" ? true : value === "false" ? false : value;
     }
-    pre[key] = value;
     return pre;
   }, {});
-  if (!options.mapFile) {
+  if (!options.loaderId) {
     return source;
   }
   if (options.clientData) {
-    const readFile = (0, _util.promisify)(this.fs.readFile);
+    const readFile = (0, import_util.promisify)(this.fs.readFile);
     try {
       const clientDataPath = this.resourcePath.includes(".loader.") ? this.resourcePath.replace(".loader.", ".data.client.") : this.resourcePath.replace(".data.", ".data.client.");
       const clientDataContent = await readFile(clientDataPath);
       return clientDataContent;
     } catch (error) {
       if (process.env.NODE_ENV === "development") {
-        _logger.logger.error(`Failed to read the clientData file ${options.clientData}`);
+        import_logger.logger.error(`Failed to read the clientData file ${options.clientData}`);
       }
     }
   }
-  const code = (0, _generateClient.generateClient)({
-    mapFile: options.mapFile,
-    loaderId: options.loaderId
+  const code = (0, import_generateClient.generateClient)({
+    inline: options.inline,
+    action: options.action,
+    routeId: options.routeId
   });
   return code;
 }

package/dist/cjs/common/constants.js

@@ -1,25 +1,34 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
   for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  LOADER_ID_PARAM: function() {
-    return LOADER_ID_PARAM;
-  },
-  DIRECT_PARAM: function() {
-    return DIRECT_PARAM;
-  },
-  CONTENT_TYPE_DEFERRED: function() {
-    return CONTENT_TYPE_DEFERRED;
+    __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  CONTENT_TYPE_DEFERRED: () => CONTENT_TYPE_DEFERRED,
+  DIRECT_PARAM: () => DIRECT_PARAM,
+  LOADER_ID_PARAM: () => LOADER_ID_PARAM
 });
+module.exports = __toCommonJS(constants_exports);
 const LOADER_ID_PARAM = "__loader";
 const DIRECT_PARAM = "__ssrDirect";
 const CONTENT_TYPE_DEFERRED = "text/modernjs-deferred";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONTENT_TYPE_DEFERRED,
+  DIRECT_PARAM,
+  LOADER_ID_PARAM
+});

package/dist/cjs/runtime/index.js

@@ -1,35 +1,38 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
   for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  isRedirectResponse: function() {
-    return isRedirectResponse;
-  },
-  isResponse: function() {
-    return isResponse;
-  },
-  handleRequest: function() {
-    return handleRequest;
+    __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+__export(runtime_exports, {
+  handleRequest: () => handleRequest,
+  isRedirectResponse: () => isRedirectResponse,
+  isResponse: () => isResponse
 });
-const _node = require("@remix-run/node");
-const _remixrouter = require("@modern-js/runtime-utils/remix-router");
-const _browser = require("@modern-js/runtime-utils/browser");
-const _lodash = require("@modern-js/utils/lodash");
-const _node1 = require("@modern-js/runtime-utils/node");
-const _time = require("@modern-js/runtime-utils/time");
-const _constants = require("@modern-js/utils/universal/constants");
-const _constants1 = require("../common/constants");
-const _response = require("./response");
-(0, _node.installGlobals)();
+module.exports = __toCommonJS(runtime_exports);
+var import_node = require("@remix-run/node");
+var import_remix_router = require("@modern-js/runtime-utils/remix-router");
+var import_browser = require("@modern-js/runtime-utils/browser");
+var import_lodash = require("@modern-js/utils/lodash");
+var import_node2 = require("@modern-js/runtime-utils/node");
+var import_time = require("@modern-js/runtime-utils/time");
+var import_constants = require("@modern-js/utils/universal/constants");
+var import_constants2 = require("../common/constants");
+var import_response = require("./response");
+(0, import_node.installGlobals)();
 const redirectStatusCodes = /* @__PURE__ */ new Set([
   301,
   302,
@@ -51,7 +54,7 @@ function convertModernRedirectResponse(headers, basename) {
   }
   newHeaders.set("X-Modernjs-Redirect", redirectUrl);
   newHeaders.delete("Location");
-  return new _node.Response(null, {
+  return new import_node.Response(null, {
     status: 204,
     headers: newHeaders
   });
@@ -71,7 +74,7 @@ const createLoaderHeaders = (requestHeaders) => {
   }
   return headers;
 };
-const createLoaderRequest = (context) => {
+const createRequest = (context) => {
   const origin = `${context.protocol}://${context.host}`;
   const url = new URL(context.url, origin);
   const controller = new AbortController();
@@ -80,7 +83,14 @@ const createLoaderRequest = (context) => {
     headers: createLoaderHeaders(context.headers),
     signal: controller.signal
   };
-  return new Request(url.href, init);
+  if (![
+    "GET",
+    "HEAD"
+  ].includes(context.method.toUpperCase())) {
+    init.body = context.req;
+  }
+  const request = new Request(url.href, init);
+  return request;
 };
 const sendLoaderResponse = async (res, nodeResponse) => {
   res.statusMessage = nodeResponse.statusText;
@@ -89,31 +99,28 @@ const sendLoaderResponse = async (res, nodeResponse) => {
     res.setHeader(key, value);
   }
   if (nodeResponse.body) {
-    await (0, _node.writeReadableStreamToWritable)(nodeResponse.body, res);
+    await (0, import_node.writeReadableStreamToWritable)(nodeResponse.body, res);
   } else {
     res.end();
   }
 };
 const handleRequest = async ({ context, serverRoutes, routes: routesConfig }) => {
-  const { method, query } = context;
-  const routeId = query[_constants1.LOADER_ID_PARAM];
-  const entry = (0, _node1.matchEntry)(context.path, serverRoutes);
+  const { query } = context;
+  const routeId = query[import_constants2.LOADER_ID_PARAM];
+  const entry = (0, import_node2.matchEntry)(context.path, serverRoutes);
   if (!routeId || !entry) {
     return;
   }
-  if (method.toLowerCase() !== "get") {
-    throw new Error("CSR data loader request only support http GET method");
-  }
   const basename = entry.urlPath;
-  const end = (0, _time.time)();
+  const end = (0, import_time.time)();
   const { res, logger, reporter } = context;
-  const routes = (0, _browser.transformNestedRoutes)(routesConfig, reporter);
-  const { queryRoute } = (0, _remixrouter.createStaticHandler)(routes, {
+  const routes = (0, import_browser.transformNestedRoutes)(routesConfig, reporter);
+  const { queryRoute } = (0, import_remix_router.createStaticHandler)(routes, {
     basename
   });
-  const request = createLoaderRequest(context);
-  const requestContext = (0, _node1.createRequestContext)();
-  requestContext.set(_node1.reporterCtx, reporter);
+  const request = createRequest(context);
+  const requestContext = (0, import_node2.createRequestContext)();
+  requestContext.set(import_node2.reporterCtx, reporter);
   let response;
   try {
     response = await queryRoute(request, {
@@ -122,9 +129,9 @@ const handleRequest = async ({ context, serverRoutes, routes: routesConfig }) =>
     });
     if (isResponse(response) && isRedirectResponse(response.status)) {
       response = convertModernRedirectResponse(response.headers, basename);
-    } else if ((0, _lodash.isPlainObject)(response) && _remixrouter.UNSAFE_DEFERRED_SYMBOL in response) {
-      const deferredData = response[_remixrouter.UNSAFE_DEFERRED_SYMBOL];
-      const body = (0, _response.createDeferredReadableStream)(deferredData, request.signal);
+    } else if ((0, import_lodash.isPlainObject)(response) && import_remix_router.UNSAFE_DEFERRED_SYMBOL in response) {
+      const deferredData = response[import_remix_router.UNSAFE_DEFERRED_SYMBOL];
+      const body = (0, import_response.createDeferredReadableStream)(deferredData, request.signal);
       const init = deferredData.init || {};
       if (init.status && isRedirectResponse(init.status)) {
         if (!init.headers) {
@@ -133,21 +140,25 @@ const handleRequest = async ({ context, serverRoutes, routes: routesConfig }) =>
         response = convertModernRedirectResponse(new Headers(init.headers), basename);
       } else {
         const headers = new Headers(init.headers);
-        headers.set("Content-Type", `${_constants1.CONTENT_TYPE_DEFERRED}; charset=UTF-8`);
+        headers.set("Content-Type", `${import_constants2.CONTENT_TYPE_DEFERRED}; charset=UTF-8`);
         init.headers = headers;
-        response = new _node.Response(body, init);
+        response = new import_node.Response(body, init);
       }
     } else {
-      response = isResponse(response) ? response : new _node.Response(JSON.stringify(response), {
+      response = isResponse(response) ? response : new import_node.Response(JSON.stringify(response), {
         headers: {
           "Content-Type": "application/json; charset=utf-8"
         }
       });
     }
   } catch (error) {
-    const message = error instanceof _remixrouter.ErrorResponse ? error.data : String(error);
-    logger === null || logger === void 0 ? void 0 : logger.error(message);
-    response = new _node.Response(message, {
+    const message = error instanceof import_remix_router.ErrorResponse ? error.data : String(error);
+    if (error instanceof Error) {
+      logger === null || logger === void 0 ? void 0 : logger.error(error);
+    } else {
+      logger === null || logger === void 0 ? void 0 : logger.error(message);
+    }
+    response = new import_node.Response(message, {
       status: 500,
       headers: {
         "Content-Type": "text/plain"
@@ -155,6 +166,12 @@ const handleRequest = async ({ context, serverRoutes, routes: routesConfig }) =>
     });
   }
   const cost = end();
-  reporter.reportTiming(`${_constants.LOADER_REPORTER_NAME}-navigation`, cost);
+  reporter.reportTiming(`${import_constants.LOADER_REPORTER_NAME}-navigation`, cost);
   await sendLoaderResponse(res, response);
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleRequest,
+  isRedirectResponse,
+  isResponse
+});