@analogjs/vite-plugin-nitro 2.4.0-beta.9 → 3.0.0-alpha.10

package/src/lib/utils/get-page-handlers.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-page-handlers.js","sourceRoot":"","sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/get-page-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAY,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtC,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAUrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,UAAU,eAAe,CAAC,EAC9B,aAAa,EACb,UAAU,EACV,OAAO,EACP,mBAAmB,EACnB,SAAS,GACO;IAChB,+DAA+D;IAC/D,MAAM,IAAI,GAAG,aAAa,CAAC,OAAO,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC;IAE5D,4FAA4F;IAC5F,iGAAiG;IACjG,MAAM,aAAa,GAAa,QAAQ,CACtC;QACE,GAAG,IAAI,IAAI,UAAU,2BAA2B;QAChD,GAAG,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,GAAG,CAChC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,aAAa,GAAG,GAAG,iBAAiB,CACjD;KACF,EACD,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAC9B,CAAC;IAEF,4DAA4D;IAC5D,MAAM,QAAQ,GAAwB,aAAa,CAAC,GAAG,CAAC,CAAC,YAAY,EAAE,EAAE;QACvE,sEAAsE;QACtE,MAAM,KAAK,GAAG,YAAY;aACvB,OAAO,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC,kCAAkC;aACrE,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,8BAA8B;aAC3D,OAAO,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC,oDAAoD;aACvF,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAC,gCAAgC;aACpE,OAAO,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,4CAA4C;aAC7E,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC,6CAA6C;aAC1E,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,kCAAkC;QAE1D,8EAA8E;QAC9E,OAAO;YACL,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,KAAK,EAAE;YACnD,IAAI,EAAE,IAAI;SACX,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC;AAClB,CAAC"}
+{"version":3,"file":"get-page-handlers.js","names":[],"sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/get-page-handlers.ts"],"sourcesContent":["import { resolve, relative } from 'node:path';\nimport { globSync } from 'tinyglobby';\n\nimport type { NitroEventHandler } from 'nitro/types';\nimport { normalizePath } from 'vite';\n\ntype GetHandlersArgs = {\n  workspaceRoot: string;\n  sourceRoot: string;\n  rootDir: string;\n  additionalPagesDirs?: string[];\n  hasAPIDir?: boolean;\n};\n\n/**\n * Discovers and generates Nitro event handlers for server-side page routes.\n *\n * This function:\n * 1. Discovers all .server.ts files in the app/pages directory and additional pages directories\n * 2. Converts file paths to route patterns using Angular-style route syntax\n * 3. Generates Nitro event handlers with proper route mapping and lazy loading\n * 4. Handles dynamic route parameters and catch-all routes\n *\n * @param workspaceRoot The workspace root directory path\n * @param sourceRoot The source directory path (e.g., 'src')\n * @param rootDir The project root directory relative to workspace\n * @param additionalPagesDirs Optional array of additional pages directories to scan\n * @param hasAPIDir Whether the project has an API directory (affects route prefixing)\n * @returns Array of NitroEventHandler objects with handler paths and route patterns\n *\n * Example usage:\n * const handlers = getPageHandlers({\n *   workspaceRoot: '/workspace',\n *   sourceRoot: 'src',\n *   rootDir: 'apps/my-app',\n *   additionalPagesDirs: ['/libs/shared/pages'],\n *   hasAPIDir: true\n * });\n *\n * Sample discovered file paths:\n * - /workspace/apps/my-app/src/app/pages/index.server.ts\n * - /workspace/apps/my-app/src/app/pages/users/[id].server.ts\n * - /workspace/apps/my-app/src/app/pages/products/[...slug].server.ts\n * - /workspace/apps/my-app/src/app/pages/(auth)/login.server.ts\n *\n * Route transformation examples:\n * - index.server.ts → /_analog/pages/index\n * - users/[id].server.ts → /_analog/pages/users/:id\n * - products/[...slug].server.ts → /_analog/pages/products/**:slug\n * - (auth)/login.server.ts → /_analog/pages/-auth-/login\n *\n * tinyglobby vs fast-glob comparison:\n * - Both support the same glob patterns for file discovery\n * - Both are efficient for finding server-side page files\n * - tinyglobby is now used instead of fast-glob\n * - tinyglobby provides similar functionality with smaller bundle size\n * - tinyglobby's globSync returns absolute paths when absolute: true is set\n *\n * Route transformation rules:\n * 1. Removes .server.ts extension\n * 2. Converts [param] to :param for dynamic routes\n * 3. Converts [...param] to **:param for catch-all routes\n * 4. Converts (group) to -group- for route groups\n * 5. Converts dots to forward slashes\n * 6. Prefixes with /_analog/pages and optionally /api\n */\nexport function getPageHandlers({\n  workspaceRoot,\n  sourceRoot,\n  rootDir,\n  additionalPagesDirs,\n  hasAPIDir,\n}: GetHandlersArgs): NitroEventHandler[] {\n  // Normalize the project root path for consistent path handling\n  const root = normalizePath(resolve(workspaceRoot, rootDir));\n\n  // Discover all .server.ts files in the app/pages directory and additional pages directories\n  // Pattern: looks for any .server.ts files in app/pages/**/*.server.ts and additional directories\n  const endpointFiles: string[] = globSync(\n    [\n      `${root}/${sourceRoot}/app/pages/**/*.server.ts`,\n      ...(additionalPagesDirs || []).map(\n        (dir) => `${workspaceRoot}${dir}/**/*.server.ts`,\n      ),\n    ],\n    { dot: true, absolute: true },\n  );\n\n  // Transform each discovered file into a Nitro event handler\n  const handlers: NitroEventHandler[] = endpointFiles.map((endpointFile) => {\n    // Normalize the endpoint file path for consistent path handling\n    const normalized = normalizePath(endpointFile);\n    // Transform the normalized path into a route pattern\n    const route = normalized\n      .replace(/^(.*?)\\/pages/, '/pages')\n      .replace(/\\.server\\.ts$/, '') // Remove .server.ts extension\n      .replace(/\\[\\.{3}(.+)\\]/g, '**:$1') // Convert [...param] to **:param (catch-all routes)\n      .replace(/\\[\\.{3}(\\w+)\\]/g, '**:$1') // Alternative catch-all pattern\n      .replace(/\\/\\((.*?)\\)$/, '/-$1-') // Convert (group) to -group- (route groups)\n      .replace(/\\[(\\w+)\\]/g, ':$1') // Convert [param] to :param (dynamic routes)\n      .replace(/\\./g, '/'); // Convert dots to forward slashes\n\n    // Return Nitro event handler with absolute handler path and transformed route\n    return {\n      handler: endpointFile,\n      route: `${hasAPIDir ? '/api' : ''}/_analog${route}`,\n      lazy: true,\n    };\n  });\n\n  return handlers;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,SAAgB,gBAAgB,EAC9B,eACA,YACA,SACA,qBACA,aACuC;AAsCvC,QAhCgC,SAC9B,CACE,GANS,cAAc,QAAQ,eAAe,QAAQ,CAAC,CAM/C,GAAG,WAAW,4BACtB,IAAI,uBAAuB,EAAE,EAAE,KAC5B,QAAQ,GAAG,gBAAgB,IAAI,iBACjC,CACF,EACD;EAAE,KAAK;EAAM,UAAU;EAAM,CAC9B,CAGmD,KAAK,iBAAiB;EAIxE,MAAM,QAFa,cAAc,aAAa,CAG3C,QAAQ,iBAAiB,SAAS,CAClC,QAAQ,iBAAiB,GAAG,CAC5B,QAAQ,kBAAkB,QAAQ,CAClC,QAAQ,mBAAmB,QAAQ,CACnC,QAAQ,gBAAgB,QAAQ,CAChC,QAAQ,cAAc,MAAM,CAC5B,QAAQ,OAAO,IAAI;AAGtB,SAAO;GACL,SAAS;GACT,OAAO,GAAG,YAAY,SAAS,GAAG,UAAU;GAC5C,MAAM;GACP;GACD"}

package/src/lib/utils/load-esm.d.ts

@@ -1,21 +1,21 @@
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
-import { URL } from 'node:url';
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.dev/license
+*/
+import { URL } from "node:url";
 /**
- * This uses a dynamic import to load a module which may be ESM.
- * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
- * will currently, unconditionally downlevel dynamic import into a require call.
- * require calls cannot load ESM code and will result in a runtime error. To workaround
- * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
- * Once TypeScript provides support for keeping the dynamic import this workaround can
- * be dropped.
- *
- * @param modulePath The path of the module to load.
- * @returns A Promise that resolves to the dynamically imported module.
- */
+* This uses a dynamic import to load a module which may be ESM.
+* CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
+* will currently, unconditionally downlevel dynamic import into a require call.
+* require calls cannot load ESM code and will result in a runtime error. To workaround
+* this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
+* Once TypeScript provides support for keeping the dynamic import this workaround can
+* be dropped.
+*
+* @param modulePath The path of the module to load.
+* @returns A Promise that resolves to the dynamically imported module.
+*/
 export declare function loadEsmModule<T>(modulePath: string | URL): Promise<T>;

package/src/lib/utils/node-web-bridge.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function toWebRequest(req: IncomingMessage): Request;
+export declare function writeWebResponseToNode(res: ServerResponse, response: Response): Promise<void>;

package/src/lib/utils/node-web-bridge.js

@@ -0,0 +1,55 @@
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+//#region packages/vite-plugin-nitro/src/lib/utils/node-web-bridge.ts
+function toWebHeaders(headers) {
+	return Object.entries(headers).reduce((acc, [key, value]) => {
+		if (value) acc.set(key, Array.isArray(value) ? value.join(", ") : value);
+		return acc;
+	}, new Headers());
+}
+function toWebRequest(req) {
+	const protocol = "http";
+	const host = req.headers.host || "localhost";
+	const url = new URL(req.url || "/", `${protocol}://${host}`);
+	const body = req.method && !["GET", "HEAD"].includes(req.method) ? Readable.toWeb(req) : void 0;
+	return new Request(url, {
+		method: req.method,
+		headers: toWebHeaders(req.headers),
+		body,
+		duplex: body ? "half" : void 0
+	});
+}
+function isClientDisconnectError(error, res) {
+	if (!(error instanceof Error)) return false;
+	const hasDisconnectCode = "code" in error && typeof error.code === "string" && [
+		"ERR_STREAM_PREMATURE_CLOSE",
+		"ERR_INVALID_STATE",
+		"ECONNRESET",
+		"EPIPE"
+	].includes(error.code);
+	const hasDisconnectMessage = /closed or destroyed stream/i.test(error.message);
+	return (res.destroyed || res.writableEnded) && (hasDisconnectCode || hasDisconnectMessage);
+}
+async function writeWebResponseToNode(res, response) {
+	res.statusCode = response.status;
+	res.statusMessage = response.statusText;
+	const setCookies = "getSetCookie" in response.headers && typeof response.headers.getSetCookie === "function" ? response.headers.getSetCookie() : [];
+	if (setCookies.length > 0) res.setHeader("set-cookie", setCookies);
+	response.headers.forEach((value, key) => {
+		if (key !== "set-cookie") res.setHeader(key, value);
+	});
+	if (!response.body) {
+		res.end();
+		return;
+	}
+	try {
+		await pipeline(Readable.fromWeb(response.body), res);
+	} catch (error) {
+		if (isClientDisconnectError(error, res)) return;
+		throw error;
+	}
+}
+//#endregion
+export { toWebRequest, writeWebResponseToNode };
+
+//# sourceMappingURL=node-web-bridge.js.map

package/src/lib/utils/node-web-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-web-bridge.js","names":[],"sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/node-web-bridge.ts"],"sourcesContent":["import type {\n  IncomingHttpHeaders,\n  IncomingMessage,\n  ServerResponse,\n} from 'node:http';\nimport { Readable } from 'node:stream';\nimport { pipeline } from 'node:stream/promises';\n\nfunction toWebHeaders(headers: IncomingHttpHeaders) {\n  return Object.entries(headers).reduce((acc, [key, value]) => {\n    if (value) {\n      acc.set(key, Array.isArray(value) ? value.join(', ') : value);\n    }\n\n    return acc;\n  }, new Headers());\n}\n\nexport function toWebRequest(req: IncomingMessage): Request {\n  const protocol = 'http';\n  const host = req.headers.host || 'localhost';\n  const url = new URL(req.url || '/', `${protocol}://${host}`);\n  const body =\n    req.method && !['GET', 'HEAD'].includes(req.method)\n      ? (Readable.toWeb(req) as ReadableStream<Uint8Array>)\n      : undefined;\n\n  return new Request(url, {\n    method: req.method,\n    headers: toWebHeaders(req.headers),\n    body,\n    // @ts-expect-error duplex is required for streaming request bodies in Node.js\n    duplex: body ? 'half' : undefined,\n  });\n}\n\nfunction isClientDisconnectError(error: unknown, res: ServerResponse): boolean {\n  if (!(error instanceof Error)) {\n    return false;\n  }\n\n  const hasDisconnectCode =\n    'code' in error &&\n    typeof error.code === 'string' &&\n    [\n      'ERR_STREAM_PREMATURE_CLOSE',\n      'ERR_INVALID_STATE',\n      'ECONNRESET',\n      'EPIPE',\n    ].includes(error.code);\n\n  const hasDisconnectMessage = /closed or destroyed stream/i.test(\n    error.message,\n  );\n\n  return (\n    (res.destroyed || res.writableEnded) &&\n    (hasDisconnectCode || hasDisconnectMessage)\n  );\n}\n\nexport async function writeWebResponseToNode(\n  res: ServerResponse,\n  response: Response,\n): Promise<void> {\n  res.statusCode = response.status;\n  res.statusMessage = response.statusText;\n\n  const setCookies =\n    'getSetCookie' in response.headers &&\n    typeof response.headers.getSetCookie === 'function'\n      ? response.headers.getSetCookie()\n      : [];\n\n  if (setCookies.length > 0) {\n    res.setHeader('set-cookie', setCookies);\n  }\n\n  response.headers.forEach((value, key) => {\n    if (key !== 'set-cookie') {\n      res.setHeader(key, value);\n    }\n  });\n\n  if (!response.body) {\n    res.end();\n    return;\n  }\n\n  // The Web ReadableStream and Node.js stream/web ReadableStream types\n  // are structurally identical at runtime but TypeScript treats them as\n  // distinct nominal types. The double-cast bridges this gap safely.\n  try {\n    await pipeline(\n      Readable.fromWeb(\n        response.body as unknown as import('node:stream/web').ReadableStream,\n      ),\n      res,\n    );\n  } catch (error) {\n    // Long-lived dev responses such as SSE can be interrupted by a browser\n    // refresh or HMR-triggered reconnect. Those closed-stream cases are\n    // expected and should not surface as noisy server errors.\n    if (isClientDisconnectError(error, res)) {\n      return;\n    }\n\n    throw error;\n  }\n}\n"],"mappings":";;;AAQA,SAAS,aAAa,SAA8B;AAClD,QAAO,OAAO,QAAQ,QAAQ,CAAC,QAAQ,KAAK,CAAC,KAAK,WAAW;AAC3D,MAAI,MACF,KAAI,IAAI,KAAK,MAAM,QAAQ,MAAM,GAAG,MAAM,KAAK,KAAK,GAAG,MAAM;AAG/D,SAAO;IACN,IAAI,SAAS,CAAC;;AAGnB,SAAgB,aAAa,KAA+B;CAC1D,MAAM,WAAW;CACjB,MAAM,OAAO,IAAI,QAAQ,QAAQ;CACjC,MAAM,MAAM,IAAI,IAAI,IAAI,OAAO,KAAK,GAAG,SAAS,KAAK,OAAO;CAC5D,MAAM,OACJ,IAAI,UAAU,CAAC,CAAC,OAAO,OAAO,CAAC,SAAS,IAAI,OAAO,GAC9C,SAAS,MAAM,IAAI,GACpB,KAAA;AAEN,QAAO,IAAI,QAAQ,KAAK;EACtB,QAAQ,IAAI;EACZ,SAAS,aAAa,IAAI,QAAQ;EAClC;EAEA,QAAQ,OAAO,SAAS,KAAA;EACzB,CAAC;;AAGJ,SAAS,wBAAwB,OAAgB,KAA8B;AAC7E,KAAI,EAAE,iBAAiB,OACrB,QAAO;CAGT,MAAM,oBACJ,UAAU,SACV,OAAO,MAAM,SAAS,YACtB;EACE;EACA;EACA;EACA;EACD,CAAC,SAAS,MAAM,KAAK;CAExB,MAAM,uBAAuB,8BAA8B,KACzD,MAAM,QACP;AAED,SACG,IAAI,aAAa,IAAI,mBACrB,qBAAqB;;AAI1B,eAAsB,uBACpB,KACA,UACe;AACf,KAAI,aAAa,SAAS;AAC1B,KAAI,gBAAgB,SAAS;CAE7B,MAAM,aACJ,kBAAkB,SAAS,WAC3B,OAAO,SAAS,QAAQ,iBAAiB,aACrC,SAAS,QAAQ,cAAc,GAC/B,EAAE;AAER,KAAI,WAAW,SAAS,EACtB,KAAI,UAAU,cAAc,WAAW;AAGzC,UAAS,QAAQ,SAAS,OAAO,QAAQ;AACvC,MAAI,QAAQ,aACV,KAAI,UAAU,KAAK,MAAM;GAE3B;AAEF,KAAI,CAAC,SAAS,MAAM;AAClB,MAAI,KAAK;AACT;;AAMF,KAAI;AACF,QAAM,SACJ,SAAS,QACP,SAAS,KACV,EACD,IACD;UACM,OAAO;AAId,MAAI,wBAAwB,OAAO,IAAI,CACrC;AAGF,QAAM"}

package/src/lib/utils/register-dev-middleware.d.ts

@@ -1,42 +1,14 @@
-import { ViteDevServer } from 'vite';
+import { ViteDevServer } from "vite";
 /**
- * Registers development server middleware by discovering and loading middleware files.
- *
- * This function:
- * 1. Discovers all TypeScript middleware files in the server/middleware directory
- * 2. Dynamically loads each middleware module using Vite's SSR module loader
- * 3. Registers each middleware handler with the Vite development server
- * 4. Handles middleware execution flow and error handling
- *
- * @param root The project root directory path
- * @param sourceRoot The source directory path (e.g., 'src')
- * @param viteServer The Vite development server instance
- *
- * Example usage:
- * await registerDevServerMiddleware('/workspace/my-app', 'src', viteServer);
- *
- * Sample middleware file paths that would be discovered:
- * - /workspace/my-app/src/server/middleware/auth.ts
- * - /workspace/my-app/src/server/middleware/cors.ts
- * - /workspace/my-app/src/server/middleware/logging.ts
- * - /workspace/my-app/src/server/middleware/validation.ts
- *
- * tinyglobby vs fast-glob comparison:
- * - Both support the same glob patterns for file discovery
- * - Both are efficient for finding middleware files
- * - tinyglobby is now used instead of fast-glob
- * - tinyglobby provides similar functionality with smaller bundle size
- * - tinyglobby's globSync returns absolute paths when absolute: true is set
- *
- * globSync options explained:
- * - dot: true - Includes files/directories that start with a dot (e.g., .env.middleware)
- * - absolute: true - Returns absolute file paths instead of relative paths
- *
- * Middleware execution flow:
- * 1. Request comes to Vite dev server
- * 2. Each registered middleware is executed in order
- * 3. If middleware returns a result, request processing stops
- * 4. If middleware returns no result, next middleware is called
- * 5. If no middleware handles the request, it continues to normal Vite processing
- */
+* Registers development server middleware by discovering and loading middleware files.
+*
+* Each discovered h3 middleware module is loaded through Vite's SSR loader,
+* wrapped in a temporary H3 app, then bridged back into Vite's Connect stack.
+* If the middleware does not write a response, control falls through to the
+* next Vite middleware.
+*
+* @param root The project root directory path
+* @param sourceRoot The source directory path (e.g., 'src')
+* @param viteServer The Vite development server instance
+*/
 export declare function registerDevServerMiddleware(root: string, sourceRoot: string, viteServer: ViteDevServer): Promise<void>;

package/src/lib/utils/register-dev-middleware.js

@@ -1,68 +1,44 @@
-import { createEvent } from 'h3';
-import { globSync } from 'tinyglobby';
+import { toWebRequest, writeWebResponseToNode } from "./node-web-bridge.js";
+import { globSync } from "tinyglobby";
+import { H3 } from "nitro/h3";
+//#region packages/vite-plugin-nitro/src/lib/utils/register-dev-middleware.ts
+var PASSTHROUGH_HEADER = "x-analog-passthrough";
 /**
- * Registers development server middleware by discovering and loading middleware files.
- *
- * This function:
- * 1. Discovers all TypeScript middleware files in the server/middleware directory
- * 2. Dynamically loads each middleware module using Vite's SSR module loader
- * 3. Registers each middleware handler with the Vite development server
- * 4. Handles middleware execution flow and error handling
- *
- * @param root The project root directory path
- * @param sourceRoot The source directory path (e.g., 'src')
- * @param viteServer The Vite development server instance
- *
- * Example usage:
- * await registerDevServerMiddleware('/workspace/my-app', 'src', viteServer);
- *
- * Sample middleware file paths that would be discovered:
- * - /workspace/my-app/src/server/middleware/auth.ts
- * - /workspace/my-app/src/server/middleware/cors.ts
- * - /workspace/my-app/src/server/middleware/logging.ts
- * - /workspace/my-app/src/server/middleware/validation.ts
- *
- * tinyglobby vs fast-glob comparison:
- * - Both support the same glob patterns for file discovery
- * - Both are efficient for finding middleware files
- * - tinyglobby is now used instead of fast-glob
- * - tinyglobby provides similar functionality with smaller bundle size
- * - tinyglobby's globSync returns absolute paths when absolute: true is set
- *
- * globSync options explained:
- * - dot: true - Includes files/directories that start with a dot (e.g., .env.middleware)
- * - absolute: true - Returns absolute file paths instead of relative paths
- *
- * Middleware execution flow:
- * 1. Request comes to Vite dev server
- * 2. Each registered middleware is executed in order
- * 3. If middleware returns a result, request processing stops
- * 4. If middleware returns no result, next middleware is called
- * 5. If no middleware handles the request, it continues to normal Vite processing
- */
-export async function registerDevServerMiddleware(root, sourceRoot, viteServer) {
-    // Discover all TypeScript middleware files in the server/middleware directory
-    // Pattern: looks for any .ts files in server/middleware/**/*.ts
-    const middlewareFiles = globSync([`${root}/${sourceRoot}/server/middleware/**/*.ts`], {
-        dot: true,
-        absolute: true,
-    });
-    // Register each discovered middleware file with the Vite dev server
-    middlewareFiles.forEach((file) => {
-        viteServer.middlewares.use(async (req, res, next) => {
-            // Dynamically load the middleware module using Vite's SSR module loader
-            // This allows for hot module replacement during development
-            const middlewareHandler = await viteServer
-                .ssrLoadModule(file)
-                .then((m) => m.default);
-            // Execute the middleware handler with the request/response event
-            const result = await middlewareHandler(createEvent(req, res));
-            // If middleware doesn't return a result, continue to next middleware
-            // If middleware returns a result, stop processing (middleware handled the request)
-            if (!result) {
-                next();
-            }
-        });
-    });
+* Registers development server middleware by discovering and loading middleware files.
+*
+* Each discovered h3 middleware module is loaded through Vite's SSR loader,
+* wrapped in a temporary H3 app, then bridged back into Vite's Connect stack.
+* If the middleware does not write a response, control falls through to the
+* next Vite middleware.
+*
+* @param root The project root directory path
+* @param sourceRoot The source directory path (e.g., 'src')
+* @param viteServer The Vite development server instance
+*/
+async function registerDevServerMiddleware(root, sourceRoot, viteServer) {
+	globSync([`${root}/${sourceRoot}/server/middleware/**/*.ts`], {
+		dot: true,
+		absolute: true
+	}).forEach((file) => {
+		const app = new H3();
+		app.use(async (event) => {
+			return (await viteServer.ssrLoadModule(file).then((m) => m.default))(event);
+		});
+		app.use(() => new Response(null, {
+			status: 204,
+			headers: { [PASSTHROUGH_HEADER]: "1" }
+		}));
+		viteServer.middlewares.use(async (req, res, next) => {
+			const response = await app.fetch(toWebRequest(req));
+			if (response.headers.get(PASSTHROUGH_HEADER) === "1") {
+				next();
+				return;
+			}
+			await writeWebResponseToNode(res, response);
+		});
+	});
 }
+//#endregion
+export { registerDevServerMiddleware };
+
 //# sourceMappingURL=register-dev-middleware.js.map

package/src/lib/utils/register-dev-middleware.js.map

@@ -1 +1 @@
-{"version":3,"file":"register-dev-middleware.js","sourceRoot":"","sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/register-dev-middleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,WAAW,EAAE,MAAM,IAAI,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAC/C,IAAY,EACZ,UAAkB,EAClB,UAAyB;IAEzB,8EAA8E;IAC9E,gEAAgE;IAChE,MAAM,eAAe,GAAG,QAAQ,CAC9B,CAAC,GAAG,IAAI,IAAI,UAAU,4BAA4B,CAAC,EACnD;QACE,GAAG,EAAE,IAAI;QACT,QAAQ,EAAE,IAAI;KACf,CACF,CAAC;IAEF,oEAAoE;IACpE,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QAC/B,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;YAClD,wEAAwE;YACxE,4DAA4D;YAC5D,MAAM,iBAAiB,GAAiB,MAAM,UAAU;iBACrD,aAAa,CAAC,IAAI,CAAC;iBACnB,IAAI,CAAC,CAAC,CAAU,EAAE,EAAE,CAAE,CAA+B,CAAC,OAAO,CAAC,CAAC;YAElE,iEAAiE;YACjE,MAAM,MAAM,GAAG,MAAM,iBAAiB,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;YAE9D,qEAAqE;YACrE,mFAAmF;YACnF,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,IAAI,EAAE,CAAC;YACT,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"register-dev-middleware.js","names":[],"sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/register-dev-middleware.ts"],"sourcesContent":["import { ViteDevServer } from 'vite';\nimport { EventHandler, H3 } from 'nitro/h3';\nimport { globSync } from 'tinyglobby';\n\nimport { toWebRequest, writeWebResponseToNode } from './node-web-bridge.js';\n\nconst PASSTHROUGH_HEADER = 'x-analog-passthrough';\n\n/**\n * Registers development server middleware by discovering and loading middleware files.\n *\n * Each discovered h3 middleware module is loaded through Vite's SSR loader,\n * wrapped in a temporary H3 app, then bridged back into Vite's Connect stack.\n * If the middleware does not write a response, control falls through to the\n * next Vite middleware.\n *\n * @param root The project root directory path\n * @param sourceRoot The source directory path (e.g., 'src')\n * @param viteServer The Vite development server instance\n */\nexport async function registerDevServerMiddleware(\n  root: string,\n  sourceRoot: string,\n  viteServer: ViteDevServer,\n): Promise<void> {\n  const middlewareFiles = globSync(\n    [`${root}/${sourceRoot}/server/middleware/**/*.ts`],\n    {\n      dot: true,\n      absolute: true,\n    },\n  );\n\n  middlewareFiles.forEach((file) => {\n    // Create the H3 app once per middleware file (not per request).\n    // The dynamic handler inside still loads the module fresh each request\n    // via ssrLoadModule, preserving HMR.\n    const app = new H3();\n    app.use(async (event) => {\n      const handler: EventHandler = await viteServer\n        .ssrLoadModule(file)\n        .then((m: unknown) => (m as { default: EventHandler }).default);\n      return handler(event);\n    });\n    // Sentinel catch-all: when the middleware returns undefined (does not\n    // handle the request), h3 does not emit its default 404 — instead we\n    // detect the passthrough header and let the Connect stack continue.\n    app.use(\n      () =>\n        new Response(null, {\n          status: 204,\n          headers: { [PASSTHROUGH_HEADER]: '1' },\n        }),\n    );\n\n    viteServer.middlewares.use(async (req, res, next) => {\n      const response = await app.fetch(toWebRequest(req));\n\n      if (response.headers.get(PASSTHROUGH_HEADER) === '1') {\n        next();\n        return;\n      }\n\n      await writeWebResponseToNode(res, response);\n    });\n  });\n}\n"],"mappings":";;;;AAMA,IAAM,qBAAqB;;;;;;;;;;;;;AAc3B,eAAsB,4BACpB,MACA,YACA,YACe;AACS,UACtB,CAAC,GAAG,KAAK,GAAG,WAAW,4BAA4B,EACnD;EACE,KAAK;EACL,UAAU;EACX,CACF,CAEe,SAAS,SAAS;EAIhC,MAAM,MAAM,IAAI,IAAI;AACpB,MAAI,IAAI,OAAO,UAAU;AAIvB,WAH8B,MAAM,WACjC,cAAc,KAAK,CACnB,MAAM,MAAgB,EAAgC,QAAQ,EAClD,MAAM;IACrB;AAIF,MAAI,UAEA,IAAI,SAAS,MAAM;GACjB,QAAQ;GACR,SAAS,GAAG,qBAAqB,KAAK;GACvC,CAAC,CACL;AAED,aAAW,YAAY,IAAI,OAAO,KAAK,KAAK,SAAS;GACnD,MAAM,WAAW,MAAM,IAAI,MAAM,aAAa,IAAI,CAAC;AAEnD,OAAI,SAAS,QAAQ,IAAI,mBAAmB,KAAK,KAAK;AACpD,UAAM;AACN;;AAGF,SAAM,uBAAuB,KAAK,SAAS;IAC3C;GACF"}

package/src/lib/utils/renderers.d.ts

@@ -1,3 +1,53 @@
-export declare const ssrRenderer = "\nimport { eventHandler, getResponseHeader } from 'h3';\n// @ts-ignore\nimport renderer from '#analog/ssr';\n// @ts-ignore\nimport template from '#analog/index';\n\nexport default eventHandler(async (event) => {\n  const noSSR = getResponseHeader(event, 'x-analog-no-ssr');\n\n  if (noSSR === 'true') {\n    return template;\n  }\n\n  const html = await renderer(event.node.req.url, template, {\n    req: event.node.req,\n    res: event.node.res,\n  });\n\n  return html;\n});";
-export declare const clientRenderer = "\nimport { eventHandler } from 'h3';\n\n// @ts-ignore\nimport template from '#analog/index';\n\nexport default eventHandler(async () => {\n  return template;\n});\n";
-export declare const apiMiddleware = "\nimport { eventHandler, proxyRequest } from 'h3';\nimport { useRuntimeConfig } from '#imports';\n\nexport default eventHandler(async (event) => {\n  const prefix = useRuntimeConfig().prefix;\n  const apiPrefix = `${prefix}/${useRuntimeConfig().apiPrefix}`;\n\n  if (event.node.req.url?.startsWith(apiPrefix)) {\n    const reqUrl = event.node.req.url?.replace(apiPrefix, '');\n\n    if (\n      event.node.req.method === 'GET' &&\n      // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers\n      // and can render the XML correctly as a static asset\n      !event.node.req.url?.endsWith('.xml')\n    ) {\n      return $fetch(reqUrl, { headers: event.node.req.headers });\n    }\n\n    return proxyRequest(event, reqUrl, {\n      // @ts-ignore\n      fetch: $fetch.native,\n    });\n  }\n});";
+/**
+* Code snippet emitted into virtual modules to create a request-scoped
+* fetch using ofetch's `createFetch` + h3's `fetchWithEvent`.
+*
+* Shared between the SSR renderer and page-endpoint virtual modules so
+* the fetch-wiring logic stays in sync.
+*
+* The emitted variable is named `serverFetch` — callers should reference it
+* by that name.
+*/
+export declare const SERVER_FETCH_FACTORY_SNIPPET = "\n  const serverFetch = createFetch({\n    fetch: (resource, init) => {\n      const url = resource instanceof Request ? resource.url : resource.toString();\n      return fetchWithEvent(event, url, init);\n    }\n  });";
+/**
+* SSR renderer virtual module content.
+*
+* This code runs inside Nitro's server runtime (Node.js context) where
+* event.node is always populated. In h3 v2, event.node is typed as optional,
+* so we use h3's first-class event properties (event.path, event.method) where
+* possible and apply optional chaining when accessing the Node.js context for
+* the Angular renderer which requires raw req/res objects.
+*
+* h3 v2 idiomatic APIs used:
+* - defineHandler (replaces defineEventHandler / eventHandler)
+* - event.path (replaces event.node.req.url)
+* - getResponseHeader compat shim (still available in h3 v2)
+*/
+export declare function ssrRenderer(): string;
+/**
+* Client-only renderer virtual module content.
+*
+* Used when SSR is disabled — simply serves the static index.html template
+* for every route, letting the client-side Angular router handle navigation.
+*/
+export declare function clientRenderer(): string;
+/**
+* API middleware virtual module content.
+*
+* Intercepts requests matching the configured API prefix and either:
+* - Uses event-bound internal forwarding for GET requests (except .xml routes)
+* - Uses request proxying for all other methods to forward the full request
+*
+* h3 v2 idiomatic APIs used:
+* - defineHandler (replaces defineEventHandler / eventHandler)
+* - event.path (replaces event.node.req.url)
+* - event.method (replaces event.node.req.method)
+* - proxyRequest is retained internally because it preserves Nitro route
+*   matching for event-bound server requests during SSR/prerender
+* - Object.fromEntries(event.req.headers.entries()) replaces direct event.node.req.headers access
+*
+* `fetchWithEvent` keeps the active event context while forwarding to a
+* rewritten path, which avoids falling through to the HTML renderer when
+* SSR code makes relative API requests.
+*/
+export declare const apiMiddleware = "\nimport { defineHandler, fetchWithEvent, proxyRequest } from 'nitro/h3';\nimport { useRuntimeConfig } from 'nitro/runtime-config';\n\nexport default defineHandler(async (event) => {\n  const prefix = useRuntimeConfig().prefix;\n  const apiPrefix = `${prefix}/${useRuntimeConfig().apiPrefix}`;\n\n  if (event.path?.startsWith(apiPrefix)) {\n    const reqUrl = event.path?.replace(apiPrefix, '');\n\n    if (\n      event.method === 'GET' &&\n      // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers\n      // and can render the XML correctly as a static asset\n      !event.path?.endsWith('.xml')\n    ) {\n      return fetchWithEvent(event, reqUrl, {\n        headers: Object.fromEntries(event.req.headers.entries()),\n      });\n    }\n\n    return proxyRequest(event, reqUrl);\n  }\n});";

package/src/lib/utils/renderers.js

@@ -1,58 +1,143 @@
-export const ssrRenderer = `
-import { eventHandler, getResponseHeader } from 'h3';
+//#region packages/vite-plugin-nitro/src/lib/utils/renderers.ts
+/**
+* Code snippet emitted into virtual modules to create a request-scoped
+* fetch using ofetch's `createFetch` + h3's `fetchWithEvent`.
+*
+* Shared between the SSR renderer and page-endpoint virtual modules so
+* the fetch-wiring logic stays in sync.
+*
+* The emitted variable is named `serverFetch` — callers should reference it
+* by that name.
+*/
+var SERVER_FETCH_FACTORY_SNIPPET = `
+  const serverFetch = createFetch({
+    fetch: (resource, init) => {
+      const url = resource instanceof Request ? resource.url : resource.toString();
+      return fetchWithEvent(event, url, init);
+    }
+  });`;
+/**
+* SSR renderer virtual module content.
+*
+* This code runs inside Nitro's server runtime (Node.js context) where
+* event.node is always populated. In h3 v2, event.node is typed as optional,
+* so we use h3's first-class event properties (event.path, event.method) where
+* possible and apply optional chaining when accessing the Node.js context for
+* the Angular renderer which requires raw req/res objects.
+*
+* h3 v2 idiomatic APIs used:
+* - defineHandler (replaces defineEventHandler / eventHandler)
+* - event.path (replaces event.node.req.url)
+* - getResponseHeader compat shim (still available in h3 v2)
+*/
+function ssrRenderer() {
+	return `
+import { createFetch } from 'ofetch';
+import { defineHandler, fetchWithEvent } from 'nitro/h3';
 // @ts-ignore
 import renderer from '#analog/ssr';
-// @ts-ignore
 import template from '#analog/index';
 
-export default eventHandler(async (event) => {
-  const noSSR = getResponseHeader(event, 'x-analog-no-ssr');
+const normalizeHtmlRequestUrl = (url) =>
+  url.replace(/\\/index\\.html(?=$|[?#])/, '/');
+
+export default defineHandler(async (event) => {
+  event.res.headers.set('content-type', 'text/html; charset=utf-8');
+  const noSSR = event.res.headers.get('x-analog-no-ssr');
+  const requestPath = normalizeHtmlRequestUrl(event.path);
 
   if (noSSR === 'true') {
     return template;
   }
 
-  const html = await renderer(event.node.req.url, template, {
-    req: event.node.req,
-    res: event.node.res,
-  });
+  // event.path is the canonical h3 v2 way to access the request URL.
+  // event.node?.req and event.node?.res are needed by the Angular SSR renderer
+  // which operates on raw Node.js request/response objects.
+  // During prerendering (Nitro v3 fetch-based pipeline), event.node is undefined.
+  // The Angular renderer requires a req object with at least { headers, url },
+  // so we provide a minimal stub to avoid runtime errors in prerender context.
+  const req = event.node?.req
+    ? {
+        ...event.node.req,
+        url: requestPath,
+        originalUrl: requestPath,
+      }
+    : {
+    headers: { host: 'localhost' },
+    url: requestPath,
+    originalUrl: requestPath,
+    connection: {},
+  };
+  const res = event.node?.res;
+${SERVER_FETCH_FACTORY_SNIPPET}
+
+  const html = await renderer(requestPath, template, { req, res, fetch: serverFetch });
 
   return html;
 });`;
-export const clientRenderer = `
-import { eventHandler } from 'h3';
-
-// @ts-ignore
+}
+/**
+* Client-only renderer virtual module content.
+*
+* Used when SSR is disabled — simply serves the static index.html template
+* for every route, letting the client-side Angular router handle navigation.
+*/
+function clientRenderer() {
+	return `
+import { defineHandler } from 'nitro/h3';
 import template from '#analog/index';
 
-export default eventHandler(async () => {
+export default defineHandler(async (event) => {
+  event.res.headers.set('content-type', 'text/html; charset=utf-8');
   return template;
 });
 `;
-export const apiMiddleware = `
-import { eventHandler, proxyRequest } from 'h3';
-import { useRuntimeConfig } from '#imports';
+}
+/**
+* API middleware virtual module content.
+*
+* Intercepts requests matching the configured API prefix and either:
+* - Uses event-bound internal forwarding for GET requests (except .xml routes)
+* - Uses request proxying for all other methods to forward the full request
+*
+* h3 v2 idiomatic APIs used:
+* - defineHandler (replaces defineEventHandler / eventHandler)
+* - event.path (replaces event.node.req.url)
+* - event.method (replaces event.node.req.method)
+* - proxyRequest is retained internally because it preserves Nitro route
+*   matching for event-bound server requests during SSR/prerender
+* - Object.fromEntries(event.req.headers.entries()) replaces direct event.node.req.headers access
+*
+* `fetchWithEvent` keeps the active event context while forwarding to a
+* rewritten path, which avoids falling through to the HTML renderer when
+* SSR code makes relative API requests.
+*/
+var apiMiddleware = `
+import { defineHandler, fetchWithEvent, proxyRequest } from 'nitro/h3';
+import { useRuntimeConfig } from 'nitro/runtime-config';
 
-export default eventHandler(async (event) => {
+export default defineHandler(async (event) => {
   const prefix = useRuntimeConfig().prefix;
   const apiPrefix = \`\${prefix}/\${useRuntimeConfig().apiPrefix}\`;
 
-  if (event.node.req.url?.startsWith(apiPrefix)) {
-    const reqUrl = event.node.req.url?.replace(apiPrefix, '');
+  if (event.path?.startsWith(apiPrefix)) {
+    const reqUrl = event.path?.replace(apiPrefix, '');
 
     if (
-      event.node.req.method === 'GET' &&
+      event.method === 'GET' &&
       // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers
       // and can render the XML correctly as a static asset
-      !event.node.req.url?.endsWith('.xml')
+      !event.path?.endsWith('.xml')
     ) {
-      return $fetch(reqUrl, { headers: event.node.req.headers });
+      return fetchWithEvent(event, reqUrl, {
+        headers: Object.fromEntries(event.req.headers.entries()),
+      });
     }
 
-    return proxyRequest(event, reqUrl, {
-      // @ts-ignore
-      fetch: $fetch.native,
-    });
+    return proxyRequest(event, reqUrl);
   }
 });`;
+//#endregion
+export { SERVER_FETCH_FACTORY_SNIPPET, apiMiddleware, clientRenderer, ssrRenderer };
+
 //# sourceMappingURL=renderers.js.map

package/src/lib/utils/renderers.js.map

@@ -1 +1 @@
-{"version":3,"file":"renderers.js","sourceRoot":"","sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/renderers.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;IAoBvB,CAAC;AAEL,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;CAS7B,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;IAyBzB,CAAC"}
+{"version":3,"file":"renderers.js","names":[],"sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/renderers.ts"],"sourcesContent":["/**\n * Code snippet emitted into virtual modules to create a request-scoped\n * fetch using ofetch's `createFetch` + h3's `fetchWithEvent`.\n *\n * Shared between the SSR renderer and page-endpoint virtual modules so\n * the fetch-wiring logic stays in sync.\n *\n * The emitted variable is named `serverFetch` — callers should reference it\n * by that name.\n */\nexport const SERVER_FETCH_FACTORY_SNIPPET = `\n  const serverFetch = createFetch({\n    fetch: (resource, init) => {\n      const url = resource instanceof Request ? resource.url : resource.toString();\n      return fetchWithEvent(event, url, init);\n    }\n  });`;\n\n/**\n * SSR renderer virtual module content.\n *\n * This code runs inside Nitro's server runtime (Node.js context) where\n * event.node is always populated. In h3 v2, event.node is typed as optional,\n * so we use h3's first-class event properties (event.path, event.method) where\n * possible and apply optional chaining when accessing the Node.js context for\n * the Angular renderer which requires raw req/res objects.\n *\n * h3 v2 idiomatic APIs used:\n * - defineHandler (replaces defineEventHandler / eventHandler)\n * - event.path (replaces event.node.req.url)\n * - getResponseHeader compat shim (still available in h3 v2)\n */\nexport function ssrRenderer() {\n  return `\nimport { createFetch } from 'ofetch';\nimport { defineHandler, fetchWithEvent } from 'nitro/h3';\n// @ts-ignore\nimport renderer from '#analog/ssr';\nimport template from '#analog/index';\n\nconst normalizeHtmlRequestUrl = (url) =>\n  url.replace(/\\\\/index\\\\.html(?=$|[?#])/, '/');\n\nexport default defineHandler(async (event) => {\n  event.res.headers.set('content-type', 'text/html; charset=utf-8');\n  const noSSR = event.res.headers.get('x-analog-no-ssr');\n  const requestPath = normalizeHtmlRequestUrl(event.path);\n\n  if (noSSR === 'true') {\n    return template;\n  }\n\n  // event.path is the canonical h3 v2 way to access the request URL.\n  // event.node?.req and event.node?.res are needed by the Angular SSR renderer\n  // which operates on raw Node.js request/response objects.\n  // During prerendering (Nitro v3 fetch-based pipeline), event.node is undefined.\n  // The Angular renderer requires a req object with at least { headers, url },\n  // so we provide a minimal stub to avoid runtime errors in prerender context.\n  const req = event.node?.req\n    ? {\n        ...event.node.req,\n        url: requestPath,\n        originalUrl: requestPath,\n      }\n    : {\n    headers: { host: 'localhost' },\n    url: requestPath,\n    originalUrl: requestPath,\n    connection: {},\n  };\n  const res = event.node?.res;\n${SERVER_FETCH_FACTORY_SNIPPET}\n\n  const html = await renderer(requestPath, template, { req, res, fetch: serverFetch });\n\n  return html;\n});`;\n}\n\n/**\n * Client-only renderer virtual module content.\n *\n * Used when SSR is disabled — simply serves the static index.html template\n * for every route, letting the client-side Angular router handle navigation.\n */\nexport function clientRenderer() {\n  return `\nimport { defineHandler } from 'nitro/h3';\nimport template from '#analog/index';\n\nexport default defineHandler(async (event) => {\n  event.res.headers.set('content-type', 'text/html; charset=utf-8');\n  return template;\n});\n`;\n}\n\n/**\n * API middleware virtual module content.\n *\n * Intercepts requests matching the configured API prefix and either:\n * - Uses event-bound internal forwarding for GET requests (except .xml routes)\n * - Uses request proxying for all other methods to forward the full request\n *\n * h3 v2 idiomatic APIs used:\n * - defineHandler (replaces defineEventHandler / eventHandler)\n * - event.path (replaces event.node.req.url)\n * - event.method (replaces event.node.req.method)\n * - proxyRequest is retained internally because it preserves Nitro route\n *   matching for event-bound server requests during SSR/prerender\n * - Object.fromEntries(event.req.headers.entries()) replaces direct event.node.req.headers access\n *\n * `fetchWithEvent` keeps the active event context while forwarding to a\n * rewritten path, which avoids falling through to the HTML renderer when\n * SSR code makes relative API requests.\n */\nexport const apiMiddleware = `\nimport { defineHandler, fetchWithEvent, proxyRequest } from 'nitro/h3';\nimport { useRuntimeConfig } from 'nitro/runtime-config';\n\nexport default defineHandler(async (event) => {\n  const prefix = useRuntimeConfig().prefix;\n  const apiPrefix = \\`\\${prefix}/\\${useRuntimeConfig().apiPrefix}\\`;\n\n  if (event.path?.startsWith(apiPrefix)) {\n    const reqUrl = event.path?.replace(apiPrefix, '');\n\n    if (\n      event.method === 'GET' &&\n      // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers\n      // and can render the XML correctly as a static asset\n      !event.path?.endsWith('.xml')\n    ) {\n      return fetchWithEvent(event, reqUrl, {\n        headers: Object.fromEntries(event.req.headers.entries()),\n      });\n    }\n\n    return proxyRequest(event, reqUrl);\n  }\n});`;\n"],"mappings":";;;;;;;;;;;AAUA,IAAa,+BAA+B;;;;;;;;;;;;;;;;;;;;;AAsB5C,SAAgB,cAAc;AAC5B,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCP,6BAA6B;;;;;;;;;;;;;AAc/B,SAAgB,iBAAiB;AAC/B,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BT,IAAa,gBAAgB"}

package/src/lib/utils/rolldown.d.ts

@@ -0,0 +1,2 @@
+export declare function isRolldown(): boolean;
+export declare function getBundleOptionsKey(): "rolldownOptions" | "rollupOptions";

package/src/lib/utils/rolldown.js

@@ -0,0 +1,12 @@
+import * as vite from "vite";
+//#region packages/vite-plugin-nitro/src/lib/utils/rolldown.ts
+function isRolldown() {
+	return !!vite.rolldownVersion;
+}
+function getBundleOptionsKey() {
+	return isRolldown() ? "rolldownOptions" : "rollupOptions";
+}
+//#endregion
+export { getBundleOptionsKey, isRolldown };
+
+//# sourceMappingURL=rolldown.js.map

package/src/lib/utils/rolldown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rolldown.js","names":[],"sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/rolldown.ts"],"sourcesContent":["import * as vite from 'vite';\n\nexport function isRolldown(): boolean {\n  return !!vite.rolldownVersion;\n}\n\nexport function getBundleOptionsKey(): 'rolldownOptions' | 'rollupOptions' {\n  return isRolldown() ? 'rolldownOptions' : 'rollupOptions';\n}\n"],"mappings":";;AAEA,SAAgB,aAAsB;AACpC,QAAO,CAAC,CAAC,KAAK;;AAGhB,SAAgB,sBAA2D;AACzE,QAAO,YAAY,GAAG,oBAAoB"}

package/src/lib/vite-plugin-nitro.d.ts

@@ -1,4 +1,4 @@
-import { NitroConfig } from 'nitropack';
-import type { Plugin } from 'vite';
-import { Options } from './options.js';
+import type { NitroConfig } from "nitro/types";
+import type { Plugin } from "vite";
+import { Options } from "./options.js";
 export declare function nitro(options?: Options, nitroOptions?: NitroConfig): Plugin[];