@analogjs/vite-plugin-nitro 3.0.0-alpha.4 → 3.0.0-alpha.41

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

@@ -1,50 +1,44 @@
-import { H3 } from 'nitro/h3';
-import { globSync } from 'tinyglobby';
-import { toWebRequest, writeWebResponseToNode } from './node-web-bridge.js';
-const PASSTHROUGH_HEADER = 'x-analog-passthrough';
+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.
- *
- * 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 async function registerDevServerMiddleware(root, sourceRoot, viteServer) {
-    const middlewareFiles = globSync([`${root}/${sourceRoot}/server/middleware/**/*.ts`], {
-        dot: true,
-        absolute: true,
-    });
-    middlewareFiles.forEach((file) => {
-        // Create the H3 app once per middleware file (not per request).
-        // The dynamic handler inside still loads the module fresh each request
-        // via ssrLoadModule, preserving HMR.
-        const app = new H3();
-        app.use(async (event) => {
-            const handler = await viteServer
-                .ssrLoadModule(file)
-                .then((m) => m.default);
-            return handler(event);
-        });
-        // Sentinel catch-all: when the middleware returns undefined (does not
-        // handle the request), h3 does not emit its default 404 — instead we
-        // detect the passthrough header and let the Connect stack continue.
-        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);
-        });
-    });
+* 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,EAAE,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAE5E,MAAM,kBAAkB,GAAG,sBAAsB,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAC/C,IAAY,EACZ,UAAkB,EAClB,UAAyB;IAEzB,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,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QAC/B,gEAAgE;QAChE,uEAAuE;QACvE,qCAAqC;QACrC,MAAM,GAAG,GAAG,IAAI,EAAE,EAAE,CAAC;QACrB,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YACtB,MAAM,OAAO,GAAiB,MAAM,UAAU;iBAC3C,aAAa,CAAC,IAAI,CAAC;iBACnB,IAAI,CAAC,CAAC,CAAU,EAAE,EAAE,CAAE,CAA+B,CAAC,OAAO,CAAC,CAAC;YAClE,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;QACH,sEAAsE;QACtE,qEAAqE;QACrE,oEAAoE;QACpE,GAAG,CAAC,GAAG,CACL,GAAG,EAAE,CACH,IAAI,QAAQ,CAAC,IAAI,EAAE;YACjB,MAAM,EAAE,GAAG;YACX,OAAO,EAAE,EAAE,CAAC,kBAAkB,CAAC,EAAE,GAAG,EAAE;SACvC,CAAC,CACL,CAAC;QAEF,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE;YAClD,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC;YAEpD,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,KAAK,GAAG,EAAE,CAAC;gBACrD,IAAI,EAAE,CAAC;gBACP,OAAO;YACT,CAAC;YAED,MAAM,sBAAsB,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"register-dev-middleware.js","names":[],"sources":["../../../../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/register-i18n-watcher.d.ts

@@ -0,0 +1,15 @@
+import { ViteDevServer } from "vite";
+/**
+* Registers a file watcher that triggers a full page reload
+* when translation files are added or modified.
+*
+* Matches files in i18n directories with .json, .xlf, .xmb, or .arb extensions.
+*
+* @param viteServer The Vite development server instance
+*/
+export declare function registerI18nWatcher(viteServer: ViteDevServer): void;
+/**
+* Checks whether a file path looks like a translation file
+* based on its location in an i18n directory and its extension.
+*/
+export declare function isTranslationFile(path: string): boolean;

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

@@ -1,53 +1,53 @@
 /**
- * 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.
- */
+* 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(templatePath: string): string;
+* 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(templatePath: string): 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.
- */
+* 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,14 +1,15 @@
+//#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.
- */
-export const SERVER_FETCH_FACTORY_SNIPPET = `
+* 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();
@@ -16,28 +17,27 @@ export const SERVER_FETCH_FACTORY_SNIPPET = `
     }
   });`;
 /**
- * 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 function ssrRenderer(templatePath) {
-    return `
-import { readFileSync } from 'node:fs';
+* 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';
+import template from '#analog/index';
 
-const template = readFileSync(${JSON.stringify(templatePath)}, 'utf8');
 const normalizeHtmlRequestUrl = (url) =>
   url.replace(/\\/index\\.html(?=$|[?#])/, '/');
 
@@ -77,17 +77,15 @@ ${SERVER_FETCH_FACTORY_SNIPPET}
 });`;
 }
 /**
- * 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 function clientRenderer(templatePath) {
-    return `
-import { readFileSync } from 'node:fs';
+* 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';
-
-const template = readFileSync(${JSON.stringify(templatePath)}, 'utf8');
+import template from '#analog/index';
 
 export default defineHandler(async (event) => {
   event.res.headers.set('content-type', 'text/html; charset=utf-8');
@@ -96,25 +94,25 @@ export default defineHandler(async (event) => {
 `;
 }
 /**
- * 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 const apiMiddleware = `
+* 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';
 
@@ -139,4 +137,7 @@ export default defineHandler(async (event) => {
     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;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG;;;;;;MAMtC,CAAC;AAEP;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,WAAW,CAAC,YAAoB;IAC9C,OAAO;;;;;;;gCAOuB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC1D,4BAA4B;;;;;IAK1B,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,YAAoB;IACjD,OAAO;;;;gCAIuB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;;;;;;CAM3D,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;IAwBzB,CAAC"}
+{"version":3,"file":"renderers.js","names":[],"sources":["../../../../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":["../../../../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 type { NitroConfig } from 'nitro/types';
-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[];