@analogjs/platform 3.0.0-alpha.9 → 3.0.0-alpha.90

package/src/lib/nitro/analog-nitro-plugin.js

@@ -0,0 +1,582 @@
+import { SERVER_MODE_ID } from "../../server-mode-plugin.js";
+import { getPageHandlers } from "./get-page-handlers.js";
+import { pageEndpointsPlugin } from "./page-endpoints-plugin.js";
+import { getMatchingContentFilesWithFrontMatter } from "./get-content-files.js";
+import { buildSitemap } from "./build-sitemap.js";
+import { addPostRenderingHooks } from "./post-rendering-hook.js";
+import { createI18nPostRenderingHook, expandRoutesWithLocales } from "./i18n-prerender.js";
+import { angularLinkerPlugin } from "./angular-linker-plugin.js";
+import { basename, dirname, relative, resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+//#region packages/platform/src/lib/nitro/analog-nitro-plugin.ts
+var SSR_ENTRY_VIRTUAL_ID = "\0virtual:@analogjs/nitro/ssr-entry";
+/**
+* Angular packages that ship in partial-compilation form and must pass
+* through the linker before the SSR / nitro bundle can execute without
+* JIT. Wired into `ssr.optimizeDeps.rolldownOptions.plugins`.
+*/
+var ANGULAR_SSR_DEPS = [
+	"@angular/compiler",
+	"@angular/core",
+	"@angular/common",
+	"@angular/platform-browser",
+	"@angular/platform-server"
+];
+/**
+* Analog's NitroModule. Plug it into the Vite plugin chain alongside
+* `nitro()` from `nitro/vite`; nitro/vite picks up the `.nitro` property
+* and runs `setup(nitro)` once the Nitro instance is ready.
+*/
+function analogNitroPlugin(options = {}) {
+	const workspaceRoot = options.workspaceRoot ?? process.env["NX_WORKSPACE_ROOT"] ?? process.cwd();
+	const sourceRoot = "src";
+	const ssr = options.ssr ?? true;
+	const apiPrefix = options.apiPrefix ?? "api";
+	let context = {
+		workspaceRoot,
+		rootDir: ".",
+		sourceRoot
+	};
+	let ssrEntryMarkerPath = "";
+	let userPublicDir;
+	let isBuild = false;
+	const ssrDepsReady = /* @__PURE__ */ new WeakMap();
+	let builtIndexHtml;
+	function waitForSsrDeps(environment) {
+		let ready = ssrDepsReady.get(environment);
+		if (!ready) {
+			ready = Promise.resolve(environment.depsOptimizer?.init());
+			ssrDepsReady.set(environment, ready);
+		}
+		return ready;
+	}
+	function refreshContext(viteRoot) {
+		context = {
+			workspaceRoot,
+			rootDir: relative(workspaceRoot, viteRoot ?? process.cwd()) || ".",
+			sourceRoot
+		};
+		ssrEntryMarkerPath = resolve(context.workspaceRoot, context.rootDir, ".analog/__ssr-entry.mjs");
+	}
+	function indexHtmlPath() {
+		return resolve(context.workspaceRoot, context.rootDir, options.index ?? "index.html");
+	}
+	function readIndexHtml() {
+		if (!isBuild) {
+			const source = indexHtmlPath();
+			return existsSync(source) ? readFileSync(source, "utf-8") : "<!doctype html><html><body><div id=\"app\"></div></body></html>";
+		}
+		if (builtIndexHtml === void 0) throw new Error(`[analog] The client build produced no ${basename(indexHtmlPath())}, so there is no document to server-render around. Rendering around the source document instead would ship markup pointing at the unbundled entry, which does not exist in a build.`);
+		return builtIndexHtml;
+	}
+	function resolveEntryServer() {
+		return options.entryServer ?? resolve(context.workspaceRoot, context.rootDir, `${sourceRoot}/main.server.ts`);
+	}
+	return {
+		name: "@analogjs/nitro",
+		enforce: "pre",
+		config(userConfig, configEnv) {
+			refreshContext(userConfig.root);
+			isBuild = configEnv?.command === "build";
+			if (userConfig.publicDir !== false) userPublicDir = resolve(context.workspaceRoot, context.rootDir, userConfig.publicDir ?? "public");
+			if (!process.env["NITRO_PRESET"]) {
+				if (process.env["BUILD_PRESET"]) process.env["NITRO_PRESET"] = process.env["BUILD_PRESET"];
+				else if (process.env["VERCEL"]) process.env["NITRO_PRESET"] = "vercel";
+				else if (process.env["NETLIFY"]) process.env["NITRO_PRESET"] = "netlify";
+				else if (process.env["CF_PAGES"]) process.env["NITRO_PRESET"] = "cloudflare-pages";
+			}
+			const overrides = {
+				server: { fs: { allow: [context.workspaceRoot] } },
+				environments: { client: { build: { rollupOptions: { input: indexHtmlPath() } } } }
+			};
+			if (ssr) {
+				overrides.experimental = { vite: { services: { ssr: { entry: ssrEntryMarkerPath } } } };
+				overrides.environments["ssr"] = {
+					build: {
+						outDir: resolve(context.workspaceRoot, "dist", context.rootDir, "ssr"),
+						rollupOptions: { input: { index: ssrEntryMarkerPath } }
+					},
+					optimizeDeps: {
+						include: ANGULAR_SSR_DEPS,
+						rolldownOptions: { plugins: [angularLinkerPlugin()] }
+					}
+				};
+			}
+			return overrides;
+		},
+		configureServer(server) {
+			const environment = server.environments["ssr"];
+			if (ssr && environment) waitForSsrDeps(environment).catch(() => void 0);
+		},
+		resolveId(id) {
+			if (id === ssrEntryMarkerPath || id === SSR_ENTRY_VIRTUAL_ID) {
+				if (ssr && !isBuild && this.environment.name === "ssr") return waitForSsrDeps(this.environment).then(() => SSR_ENTRY_VIRTUAL_ID);
+				return SSR_ENTRY_VIRTUAL_ID;
+			}
+			return null;
+		},
+		load(id) {
+			if (id !== SSR_ENTRY_VIRTUAL_ID) return null;
+			return generateSsrEntryWrapper(resolveEntryServer(), readIndexHtml());
+		},
+		writeBundle(_outputOptions, bundle) {
+			if (this.environment?.name !== "client") return;
+			const emitted = bundle[basename(indexHtmlPath())];
+			if (emitted?.type === "asset") {
+				const { source } = emitted;
+				builtIndexHtml = typeof source === "string" ? source : new TextDecoder().decode(source);
+			}
+		},
+		nitro: { async setup(nitro) {
+			if (!context || context.rootDir === ".") refreshContext(nitro.options.rootDir);
+			if (nitro.options.dev && !process.env["NITRO_DEV_RUNNER"] && !nitro.options.devServer?.runner) nitro.options.devServer = {
+				...nitro.options.devServer,
+				runner: "self"
+			};
+			if (!nitro.options.dev) {
+				const preset = (nitro.options.preset ?? "").toLowerCase();
+				const isManagedPreset = preset !== "" && preset !== "node-server" && preset !== "node" && preset !== "nitro-dev";
+				if (preset.includes("vercel")) {
+					const vercel = nitro.options.vercel;
+					nitro.options.vercel = {
+						...vercel,
+						entryFormat: vercel?.entryFormat ?? "node",
+						functions: {
+							runtime: vercel?.functions?.runtime ?? "nodejs24.x",
+							...vercel?.functions
+						}
+					};
+					const vercelDir = resolve(context.workspaceRoot, ".vercel/output");
+					nitro.options.output = {
+						...nitro.options.output,
+						dir: vercelDir,
+						serverDir: resolve(vercelDir, "functions/__server.func"),
+						publicDir: resolve(vercelDir, "static")
+					};
+				}
+				if (preset === "netlify" || preset === "netlify-edge") {
+					const netlifyDir = resolve(context.workspaceRoot, ".netlify/functions-internal");
+					nitro.options.output = {
+						...nitro.options.output,
+						dir: netlifyDir,
+						serverDir: resolve(netlifyDir, "server"),
+						publicDir: resolve(context.workspaceRoot, "dist", context.rootDir, "analog/public")
+					};
+				}
+				if (preset.includes("cloudflare")) {
+					const cfDir = resolve(context.workspaceRoot, "dist", context.rootDir);
+					nitro.options.output = {
+						...nitro.options.output,
+						dir: cfDir,
+						publicDir: cfDir,
+						serverDir: resolve(cfDir, "_worker.js")
+					};
+				}
+				if (!isManagedPreset) {
+					const distRoot = resolve(context.workspaceRoot, "dist", context.rootDir);
+					nitro.options.output = {
+						...nitro.options.output,
+						dir: resolve(distRoot, "analog"),
+						publicDir: resolve(distRoot, "analog/public"),
+						serverDir: resolve(distRoot, "analog/server")
+					};
+				}
+				nitro.hooks.hook("prerender:route", async (route) => {
+					if (!route.skip || route.error) return;
+					const buffer = route.data;
+					if (!buffer || !route.fileName) return;
+					const filePath = resolve(nitro.options.output.publicDir, route.fileName.replace(/^[\\/]+/, ""));
+					try {
+						await mkdir(dirname(filePath), { recursive: true });
+						await writeFile(filePath, Buffer.from(buffer));
+						route.skip = false;
+					} catch {}
+				});
+			}
+			if (userPublicDir && existsSync(userPublicDir)) {
+				if (!nitro.options.publicAssets.some((asset) => asset.dir === userPublicDir)) nitro.options.publicAssets.push({
+					dir: userPublicDir,
+					baseURL: "/",
+					maxAge: 0,
+					fallthrough: true
+				});
+			}
+			nitro.hooks.hook("prerender:config", (prerendererConfig) => {
+				prerendererConfig.output = {
+					...prerendererConfig.output,
+					publicDir: nitro.options.output.publicDir
+				};
+			});
+			const pageHandlers = getPageHandlers({
+				workspaceRoot: context.workspaceRoot,
+				sourceRoot: context.sourceRoot,
+				rootDir: context.rootDir,
+				additionalPagesDirs: options.additionalPagesDirs
+			});
+			nitro.options.handlers.push(...pageHandlers);
+			const serverDir = resolve(context.workspaceRoot, context.rootDir, `${context.sourceRoot}/server`);
+			if (existsSync(serverDir) && !nitro.options.scanDirs.includes(serverDir)) nitro.options.scanDirs.push(serverDir);
+			nitro.hooks.hook("rollup:before", (_n, rollupConfig) => {
+				if (Array.isArray(rollupConfig.plugins)) rollupConfig.plugins.push(pageEndpointsPlugin());
+				applyAnalogNitroExternals(rollupConfig);
+				sanitizeNitroBundlerConfig(rollupConfig);
+			});
+			if (ssr) {
+				nitro.options.virtual["#analog/ssr"] = () => generateSsrServiceVirtual(nitro);
+				nitro.options.virtual["#analog/ssr-renderer"] = () => generateSsrRendererVirtual(readIndexHtml());
+				nitro.options.renderer ??= {};
+				nitro.options.renderer.handler = "#analog/ssr-renderer";
+				delete nitro.options.renderer.template;
+				nitro.hooks.hook("prerender:config", (prerendererConfig) => {
+					prerendererConfig.renderer = false;
+				});
+				nitro.hooks.hook("prerender:init", (prerenderer) => {
+					prerenderer.options.renderer = { handler: "#analog/ssr-renderer" };
+				});
+			}
+			injectAnalogRouteRuleHeaders(nitro);
+			await wirePrerender(nitro, options, context, apiPrefix);
+			if (options.i18n) addPostRenderingHooks(nitro, [createI18nPostRenderingHook({
+				defaultLocale: options.i18n.defaultLocale,
+				locales: options.i18n.locales
+			})]);
+		} }
+	};
+}
+/**
+* Builds the h3 handler installed as Nitro's `renderer.handler`. Short-circuits
+* `ssr: false` routes to the raw client template; otherwise dispatches the
+* request to the SSR service env (`fetchViteEnv("ssr", req)` works in dev via
+* the env-runner and in prod via the `__nitro_vite_envs__` global set up by
+* nitro/vite's `prodSetup`).
+*/
+function generateSsrRendererVirtual(template) {
+	return `
+import { defineHandler } from 'nitro/h3';
+import ssr from '#analog/ssr';
+
+const TEMPLATE = ${JSON.stringify(template)};
+
+export default defineHandler(async (event) => {
+  event.res.headers.set('content-type', 'text/html; charset=utf-8');
+  // 'x-analog-no-ssr' is stamped on response headers by
+  // injectAnalogRouteRuleHeaders for routeRules with \`ssr: false\`. Nitro
+  // applies routeRule headers to the response before the renderer fires,
+  // so we can short-circuit by reading them here.
+  if (event.res.headers.get('x-analog-no-ssr') === 'true') {
+    return TEMPLATE;
+  }
+  const service = ssr.default ?? ssr;
+  return service.fetch(event.req);
+});
+`;
+}
+/**
+* Resolves \`#analog/ssr\` to the SSR fetch handler. The shape returned by
+* this function is bundler-agnostic: works in Vite-built main bundles and
+* Rolldown-built prerender bundles alike.
+*
+* - Dev: dispatch through nitro/vite's env runner (\`fetchViteEnv\`); the SSR
+*   service module isn't on disk yet, so we delegate to the runner.
+* - Build / prerender: re-export the built SSR entry directly from the
+*   filesystem. By the time Nitro's bundlers ask for \`#analog/ssr\`, Vite has
+*   already produced \`<buildDir>/vite/services/ssr/<entry>.mjs\`.
+*/
+function generateSsrServiceVirtual(nitro) {
+	if (nitro.options.dev) return `
+import { fetchViteEnv } from 'nitro/vite/runtime';
+export default {
+  // The dev runner answers from a worker, and a rejection there comes back as
+  // something Nitro cannot turn into a response, so the request hangs with no
+  // status and no message. Answer with the failure instead.
+  async fetch(req) {
+    try {
+      return await fetchViteEnv('ssr', req);
+    } catch (err) {
+      console.error('[analog ssr]', err);
+      const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
+      return new Response(message, {
+        status: 500,
+        headers: { 'content-type': 'text/plain; charset=utf-8' },
+      });
+    }
+  },
+};
+`;
+	const ssrDir = resolve(nitro.options.buildDir, "vite/services/ssr");
+	if (!existsSync(ssrDir)) return `export default { async fetch() { throw new Error('Analog SSR service directory missing: ${ssrDir}'); } };`;
+	const entries = readdirSync(ssrDir).filter((f) => f.endsWith(".mjs"));
+	if (entries.length === 0) return `export default { async fetch() { throw new Error('No Analog SSR entry file built in: ${ssrDir}'); } };`;
+	const entryPath = resolve(ssrDir, entries.find((f) => f === "main.server.mjs") ?? entries[0]);
+	return `export { default } from ${JSON.stringify(entryPath)};`;
+}
+/**
+* Packages Analog forces external in the Nitro server bundle. Each entry is
+* here for a specific reason — see comments.
+*/
+var ANALOG_NITRO_EXTERNALS = [
+	"rxjs",
+	"node-fetch-native/dist/polyfill",
+	"sharp"
+];
+function applyAnalogNitroExternals(rollupConfig) {
+	const prev = rollupConfig.external;
+	const existing = prev === void 0 ? [] : Array.isArray(prev) ? prev : prev instanceof RegExp ? [prev] : typeof prev === "string" ? [prev] : [];
+	const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	for (const entry of ANALOG_NITRO_EXTERNALS) {
+		const pattern = new RegExp(`^${escapeRegExp(entry)}(?:/|$)`);
+		if (!existing.some((p) => String(p) === String(pattern))) existing.push(pattern);
+	}
+	rollupConfig.external = existing;
+}
+/**
+* Workarounds for Nitro v3 + Rolldown bundler interaction quirks. Each
+* is narrowly scoped and can be removed once the upstream bug is fixed:
+*
+* 1. `output.codeSplitting` — Nitro 3.0.x sets this; Rolldown rejects it
+*    as an unknown key.
+* 2. `output.manualChunks` — Nitro's default manual chunking crashes
+*    Nitro's prerender rebundle.
+* 3. `output.chunkFileNames` — Nitro's chunk-name function produces
+*    route-derived `[token]` patterns which Rollup/Rolldown interprets as
+*    placeholders; we rewrite non-standard tokens to `_token_`.
+*/
+function sanitizeNitroBundlerConfig(rollupConfig) {
+	const output = rollupConfig.output;
+	if (!output || Array.isArray(output) || typeof output !== "object") return;
+	const out = output;
+	if ("codeSplitting" in out) delete out["codeSplitting"];
+	if ("manualChunks" in out) delete out["manualChunks"];
+	const VALID_ROLLUP_PLACEHOLDER = /^\[(?:name|hash|format|ext)\]$/;
+	const chunkFileNames = out["chunkFileNames"];
+	if (typeof chunkFileNames === "function") {
+		const originalFn = chunkFileNames;
+		out["chunkFileNames"] = (...args) => {
+			const result = originalFn(...args);
+			if (typeof result !== "string") return result;
+			return result.replace(/\[[^\]]+\]/g, (match) => VALID_ROLLUP_PLACEHOLDER.test(match) ? match : `_${match.slice(1, -1)}_`);
+		};
+	}
+}
+/**
+* Walks Nitro's resolved routeRules and stamps `x-analog-no-ssr: true` onto
+* any rule with `ssr: false`, and `x-analog-no-streaming: true` onto any rule
+* with `streaming: false`. Kept as response-header hints for downstream
+* consumers (CDN, edge logic); the actual SSR short-circuit happens inside
+* the SSR renderer virtual above, and the router falls back to a buffered
+* render when it sees the streaming hint.
+*/
+function injectAnalogRouteRuleHeaders(nitro) {
+	const routeRules = nitro.options.routeRules;
+	if (!routeRules) return;
+	for (const rule of Object.values(routeRules)) {
+		if (rule?.ssr === false) rule.headers = {
+			...rule.headers,
+			"x-analog-no-ssr": "true"
+		};
+		if (rule?.streaming === false) rule.headers = {
+			...rule.headers,
+			"x-analog-no-streaming": "true"
+		};
+	}
+}
+/**
+* Builds the SSR service entry source. The wrapper imports the user's
+* `main.server.ts` Angular renderer and adapts it to the `{ fetch(req) }`
+* shape that nitro/vite's service mechanism expects.
+*/
+function generateSsrEntryWrapper(entryServer, template) {
+	return `
+// Import \`serverFetch\` from the root \`nitro\` entry rather than \`nitro/app\`.
+// The /app subpath creates a fresh \`useNitroApp()\` instance scoped to the
+// importing bundle, which in our setup is the standalone SSR vite bundle —
+// it has no route handlers, so every fetch 404s. The root entry instead
+// reads \`globalThis.__nitro__.{default,prerender}\`, which the surrounding
+// Nitro server (prerender pass or production runtime) has already
+// populated with the real app + handlers.
+// Set \`ngServerMode\` before the Angular renderer and its app config evaluate,
+// otherwise \`provideClientHydration()\` registers browser-only features such
+// as event replay on the server.
+import ${JSON.stringify(SERVER_MODE_ID)};
+import { serverFetch as nitroServerFetch } from 'nitro';
+import { createFetch } from 'ofetch';
+import renderer from ${JSON.stringify(entryServer)};
+
+const TEMPLATE = ${JSON.stringify(template)};
+
+const normalizeRequestPath = (url) =>
+  url.replace(/\\/index\\.html(?=$|[?#])/, '/');
+
+// In-process fetch wired into Nitro's request pipeline. Angular's HttpClient
+// (via withFetch()) and Analog's injectLoad() call this during SSR/prerender
+// so they hit the running app's page-endpoint and API routes without going
+// through the network — the prerender pipeline doesn't have a listening
+// socket. Without this, every SSR data fetch ECONNREFUSEs and Angular's
+// router fails to resolve any data-bound route, producing an empty
+// <router-outlet/> in the prerendered HTML.
+const ssrFetch = (resource, init) => {
+  let url = typeof resource === 'string'
+    ? resource
+    : resource instanceof URL
+      ? resource.href
+      : resource.url;
+  // Relative URLs from injectAPIPrefix() etc. need a host for Nitro's
+  // Request constructor to accept them.
+  if (typeof url === 'string' && url.startsWith('/')) {
+    url = 'http://localhost' + url;
+  }
+  return nitroServerFetch(url, init);
+};
+
+// Wrap in ofetch so consumers that expect \`$fetch.raw()\` (the router's
+// request-context interceptor short-circuits SSR HttpClient calls through
+// \`globalThis.$fetch.raw\`) can call it. Set on globalThis so router code
+// running inside the Angular renderer can find it.
+const ssrOFetch = createFetch({ fetch: ssrFetch });
+if (typeof globalThis.$fetch === 'undefined') {
+  globalThis.$fetch = ssrOFetch;
+}
+
+export default {
+  async fetch(req) {
+    const url = new URL(req.url);
+    const requestPath = normalizeRequestPath(url.pathname);
+    // Preserve the query string so Angular's router + injectQuery() and
+    // server data loaders that read from req.url see the full path+query.
+    const requestUrl = requestPath + url.search;
+
+    if (req.headers.get('x-analog-no-ssr') === 'true') {
+      return new Response(TEMPLATE, {
+        status: 200,
+        headers: { 'content-type': 'text/html; charset=utf-8' },
+      });
+    }
+
+    const reqShim = {
+      headers: Object.fromEntries(req.headers.entries()),
+      url: requestUrl,
+      originalUrl: requestUrl,
+      connection: {},
+    };
+
+    try {
+      const html = await renderer(requestUrl, TEMPLATE, {
+        req: reqShim,
+        // Pass the ofetch-wrapped fetch — INTERNAL_FETCH is consumed by the
+        // router's request-context interceptor via \`serverFetch.raw(...)\`,
+        // which is ofetch's response-shape API. Plain fetch lacks \`.raw\`
+        // and throws TypeError during prerender/SSR.
+        fetch: ssrOFetch,
+      });
+      return new Response(html, {
+        status: 200,
+        headers: { 'content-type': 'text/html; charset=utf-8' },
+      });
+    } catch (err) {
+      console.error('[analog ssr]', err);
+      return new Response(TEMPLATE, {
+        status: 500,
+        headers: { 'content-type': 'text/html; charset=utf-8' },
+      });
+    }
+  },
+};
+`;
+}
+async function wirePrerender(nitro, options, context, apiPrefix) {
+	const prerender = options.prerender;
+	if (!prerender && !options.i18n) return;
+	const { routes: collected, sitemaps: routeSitemaps, routeSourceFiles } = await collectRoutes(prerender?.routes, context, apiPrefix);
+	const expanded = options.i18n ? expandRoutesWithLocales(collected, {
+		defaultLocale: options.i18n.defaultLocale,
+		locales: options.i18n.locales
+	}) : collected;
+	const nitroPrerender = nitro.options.prerender ??= {};
+	nitroPrerender.routes ??= [];
+	nitroPrerender.routes.push(...expanded);
+	if (prerender?.discover ?? false) nitroPrerender.crawlLinks = true;
+	const prerendersRoot = nitroPrerender.routes.some((route) => route === "/");
+	if ((options.ssr ?? true) && prerendersRoot) nitro.hooks.hook("prerender:init", () => {
+		const publicDir = resolve(nitro.options.output.publicDir);
+		for (const extension of [
+			"",
+			".br",
+			".gz"
+		]) {
+			const indexFile = resolve(publicDir, `index.html${extension}`);
+			if (existsSync(indexFile)) unlinkSync(indexFile);
+		}
+	});
+	if (prerender?.postRenderingHooks?.length) addPostRenderingHooks(nitro, prerender.postRenderingHooks);
+	if (Object.keys(routeSourceFiles).length > 0) nitro.hooks.hook("prerender:done", async () => {
+		const publicDir = resolve(nitro.options.output.publicDir);
+		const { mkdirSync, writeFileSync } = await import("node:fs");
+		const { dirname, join } = await import("node:path");
+		for (const [route, content] of Object.entries(routeSourceFiles)) {
+			const outputPath = join(publicDir, `${route}.md`);
+			mkdirSync(dirname(outputPath), { recursive: true });
+			writeFileSync(outputPath, content, "utf8");
+		}
+	});
+	const sitemapConfig = prerender?.sitemap;
+	if (sitemapConfig) nitro.hooks.hook("prerender:done", async (result) => {
+		await buildSitemap({}, sitemapConfig, (result?.prerenderedRoutes ?? []).map((r) => r.route), resolve(nitro.options.output.publicDir), routeSitemaps, { apiPrefix });
+	});
+}
+async function collectRoutes(routesInput, context, apiPrefix) {
+	const out = [];
+	const sitemaps = {};
+	const routeSourceFiles = {};
+	if (!routesInput) return {
+		routes: out,
+		sitemaps,
+		routeSourceFiles
+	};
+	const inputs = Array.isArray(routesInput) ? routesInput : typeof routesInput === "function" ? await routesInput() : [];
+	for (const entry of inputs) {
+		if (!entry) continue;
+		if (typeof entry === "string") {
+			out.push(entry);
+			continue;
+		}
+		if ("contentDir" in entry) {
+			const dir = entry;
+			const files = getMatchingContentFilesWithFrontMatter(context.workspaceRoot, context.rootDir, dir.contentDir, !!dir.recursive);
+			for (const file of files) {
+				const route = dir.transform(file);
+				if (route === false) continue;
+				out.push(route);
+				if (dir.sitemap) sitemaps[route] = typeof dir.sitemap === "function" ? dir.sitemap(file) : dir.sitemap;
+				if (dir.outputSourceFile) {
+					const sourceContent = dir.outputSourceFile(file);
+					if (typeof sourceContent === "string") routeSourceFiles[route] = sourceContent;
+				}
+			}
+			continue;
+		}
+		if ("route" in entry) {
+			const cfg = entry;
+			out.push(cfg.route);
+			if (cfg.sitemap) sitemaps[cfg.route] = cfg.sitemap;
+			if (cfg.outputSourceFile) {
+				const sourcePath = resolve(context.workspaceRoot, context.rootDir, cfg.outputSourceFile);
+				if (existsSync(sourcePath)) routeSourceFiles[cfg.route] = readFileSync(sourcePath, "utf8");
+			}
+			if (cfg.staticData) {
+				const prefix = apiPrefix.startsWith("/") ? apiPrefix : `/${apiPrefix}`;
+				const route = cfg.route.startsWith("/") ? cfg.route : `/${cfg.route}`;
+				out.push(`${prefix}/_analog/pages${route}`);
+			}
+		}
+	}
+	return {
+		routes: out,
+		sitemaps,
+		routeSourceFiles
+	};
+}
+//#endregion
+export { analogNitroPlugin };
+
+//# sourceMappingURL=analog-nitro-plugin.js.map