@analogjs/vite-plugin-nitro 3.0.0-alpha.2 → 3.0.0-alpha.21

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

@@ -1,42 +1,53 @@
 /**
- * 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;
+* 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  });";
 /**
- * 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;
+* 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;
 /**
- * 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.
- */
+* 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,26 +1,43 @@
+//#region packages/vite-plugin-nitro/src/lib/utils/renderers.ts
 /**
- * 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';
+* 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';
+import template from '#analog/index';
 
-const template = readFileSync(${JSON.stringify(templatePath)}, 'utf8');
 const normalizeHtmlRequestUrl = (url) =>
   url.replace(/\\/index\\.html(?=$|[?#])/, '/');
 
@@ -52,30 +69,23 @@ export default defineHandler(async (event) => {
     connection: {},
   };
   const res = event.node?.res;
-  const fetch = createFetch({
-    fetch: (resource, init) => {
-      const url = resource instanceof Request ? resource.url : resource.toString();
-      return fetchWithEvent(event, url, init);
-    }
-  });
+${SERVER_FETCH_FACTORY_SNIPPET}
 
-  const html = await renderer(requestPath, template, { req, res, fetch });
+  const html = await renderer(requestPath, template, { req, res, fetch: serverFetch });
 
   return html;
 });`;
 }
 /**
- * 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');
@@ -84,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';
 
@@ -127,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;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,WAAW,CAAC,YAAoB;IAC9C,OAAO;;;;;;;gCAOuB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0CxD,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[];