nitro-nightly 3.1.0-20251026-222805-a13234bf → 3.1.0-20251026-232057-ce388de2

package/dist/_chunks/index.mjs

@@ -20679,6 +20679,9 @@ class Router {
       addRoute(this.#router, route.method, route.route, route.data);
     }
   }
+  hasRoutes() {
+    return this.#routes.length > 0;
+  }
   compileToString(opts) {
     return this.#compiled || (this.#compiled = compileRouterToString(this.#router, void 0, opts));
   }

package/dist/_chunks/info.mjs

@@ -10360,6 +10360,7 @@ import * as __routeRules__ from "nitro/runtime/internal/route-rules";
 ${nitro.options.serverEntry ? `import __serverEntry__ from ${JSON.stringify(nitro.options.serverEntry)};` : ""}
 import {${h3Imports.join(", ")}} from "nitro/deps/h3";
 
+export const hasRouteRules = ${nitro.routing.routeRules.hasRoutes() ? "true" : "false"};
 export const findRouteRules = ${nitro.routing.routeRules.compileToString({ serialize: serializeRouteRule, matchAll: true })}
 
 ${allHandlers.filter((h) => !h.lazy).map((h) => (
@@ -10374,10 +10375,13 @@ ${allHandlers.filter((h) => h.lazy).map(
             )
           ).join("\n")}
 
+export const hasRoutes = ${nitro.routing.routes.hasRoutes() ? "true" : "false"};
 export const findRoute = ${nitro.routing.routes.compileToString({ serialize: serializeHandler })}
 
+export const hasRoutedMiddleware = ${nitro.routing.routedMiddleware.hasRoutes() ? "true" : "false"};
 export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({ serialize: serializeHandler, matchAll: true })};
 
+export const hasGlobalMiddleware = ${nitro.routing.globalMiddleware.length > 0 || nitro.options.serverEntry ? "true" : "false"};
 export const globalMiddleware = [${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `toEventHandler(${h._importHash})`).join(",")}];
 
 ${nitro.options.serverEntry && /* js */

package/dist/runtime/internal/app.mjs

@@ -4,10 +4,14 @@ import { nitroAsyncContext } from "./context.mjs";
 import errorHandler from "#nitro-internal-virtual/error-handler";
 import { plugins } from "#nitro-internal-virtual/plugins";
 import {
+  hasRouteRules,
   findRoute,
   findRouteRules,
   globalMiddleware,
-  findRoutedMiddleware
+  findRoutedMiddleware,
+  hasRoutedMiddleware,
+  hasGlobalMiddleware,
+  hasRoutes
 } from "#nitro-internal-virtual/routing";
 export function useNitroApp() {
   return useNitroApp.__instance__ ??= initNitroApp();
@@ -97,18 +101,33 @@ function createNitroApp() {
 }
 function createH3App(config) {
   const h3App = new H3Core(config);
-  h3App._findRoute = (event) => findRoute(event.req.method, event.url.pathname);
+  if (hasRoutes) {
+    h3App._findRoute = (event) => findRoute(event.req.method, event.url.pathname);
+  }
   h3App._getMiddleware = (event, route) => {
-    const pathname = event.url.pathname;
-    const method = event.req.method;
-    const { routeRules, routeRuleMiddleware } = getRouteRules(method, pathname);
-    event.context.routeRules = routeRules;
-    return [
-      ...routeRuleMiddleware,
-      ...globalMiddleware,
-      ...findRoutedMiddleware(method, pathname).map((r) => r.data),
-      ...route?.data?.middleware || []
-    ].filter(Boolean);
+    const needsRouting = hasRouteRules || hasRoutedMiddleware;
+    const pathname = needsRouting ? event.url.pathname : void 0;
+    const method = needsRouting ? event.req.method : void 0;
+    const middleware = [];
+    if (hasRouteRules) {
+      const routeRules = getRouteRules(method, pathname);
+      event.context.routeRules = routeRules?.routeRules;
+      if (routeRules?.routeRuleMiddleware.length) {
+        middleware.push(...routeRules.routeRuleMiddleware);
+      }
+    }
+    if (hasGlobalMiddleware) {
+      middleware.push(...globalMiddleware);
+    }
+    if (hasRoutedMiddleware) {
+      middleware.push(
+        ...findRoutedMiddleware(method, pathname).map((r) => r.data)
+      );
+    }
+    if (route?.data?.middleware?.length) {
+      middleware.push(...route.data.middleware);
+    }
+    return middleware;
   };
   return h3App;
 }

package/dist/types/index.d.mts

@@ -3817,6 +3817,7 @@ declare class Router<T> {
     constructor(matchAll?: boolean);
     get routes(): Route<T>[];
     _update(routes: Route<T>[]): void;
+    hasRoutes(): boolean;
     compileToString(opts?: RouterCompilerOptions): string;
     match(method: string, path: string): undefined | T;
     matchAll(method: string, path: string): T[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nitro-nightly",
-  "version": "3.1.0-20251026-222805-a13234bf",
+  "version": "3.1.0-20251026-232057-ce388de2",
   "description": "Build and Deploy Universal JavaScript Servers",
   "homepage": "https://nitro.build",
   "repository": "nitrojs/nitro",