@analogjs/vite-plugin-nitro 3.0.0-alpha.9 → 3.0.0-alpha.91

package/src/lib/utils/get-content-files.d.ts

@@ -1,56 +1,56 @@
-import { PrerenderContentFile } from '../options';
+import { PrerenderContentFile } from "../options";
 /**
- * Discovers content files with front matter and extracts metadata for prerendering.
- *
- * This function:
- * 1. Discovers all content files matching the specified glob pattern
- * 2. Reads each file and parses front matter metadata
- * 3. Extracts file name, extension, and path information
- * 4. Returns structured data for prerendering content pages
- *
- * @param workspaceRoot The workspace root directory path
- * @param rootDir The project root directory relative to workspace
- * @param glob The glob pattern to match content files (e.g., 'content/blog')
- * @returns Array of PrerenderContentFile objects with metadata and front matter
- *
- * Example usage:
- * const contentFiles = getMatchingContentFilesWithFrontMatter(
- *   '/workspace',
- *   'apps/my-app',
- *   'content/blog'
- * );
- *
- * Sample discovered file paths:
- * - /workspace/apps/my-app/content/blog/first-post.md
- * - /workspace/apps/my-app/content/blog/2024/01/hello-world.md
- * - /workspace/apps/my-app/content/blog/tech/angular-v17.mdx
- * - /workspace/apps/my-app/content/blog/about/index.md
- *
- * Sample output structure:
- * {
- *   name: 'first-post',
- *   extension: 'md',
- *   path: 'content/blog',
- *   attributes: { title: 'My First Post', date: '2024-01-01', tags: ['intro'] }
- * }
- *
- * tinyglobby vs fast-glob comparison:
- * - Both support the same glob patterns for file discovery
- * - Both are efficient for finding content 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
- *
- * Front matter parsing:
- * - Uses front-matter library to parse YAML/TOML front matter
- * - Extracts metadata like title, date, tags, author, etc.
- * - Supports both YAML (---) and TOML (+++) delimiters
- * - Returns structured attributes for prerendering
- *
- * File path processing:
- * - Normalizes paths for cross-platform compatibility
- * - Extracts file name without extension
- * - Determines file extension for content type handling
- * - Maintains relative path structure for routing
- */
-export declare function getMatchingContentFilesWithFrontMatter(workspaceRoot: string, rootDir: string, glob: string): PrerenderContentFile[];
+* Discovers content files with front matter and extracts metadata for prerendering.
+*
+* This function:
+* 1. Discovers all content files matching the specified glob pattern
+* 2. Reads each file and parses front matter metadata
+* 3. Extracts file name, extension, and path information
+* 4. Returns structured data for prerendering content pages
+*
+* @param workspaceRoot The workspace root directory path
+* @param rootDir The project root directory relative to workspace
+* @param glob The glob pattern to match content files (e.g., 'content/blog')
+* @returns Array of PrerenderContentFile objects with metadata and front matter
+*
+* Example usage:
+* const contentFiles = getMatchingContentFilesWithFrontMatter(
+*   '/workspace',
+*   'apps/my-app',
+*   'content/blog'
+* );
+*
+* Sample discovered file paths:
+* - /workspace/apps/my-app/content/blog/first-post.md
+* - /workspace/apps/my-app/content/blog/2024/01/hello-world.md
+* - /workspace/apps/my-app/content/blog/tech/angular-v17.mdx
+* - /workspace/apps/my-app/content/blog/about/index.md
+*
+* Sample output structure:
+* {
+*   name: 'first-post',
+*   extension: 'md',
+*   path: 'content/blog',
+*   attributes: { title: 'My First Post', date: '2024-01-01', tags: ['intro'] }
+* }
+*
+* tinyglobby vs fast-glob comparison:
+* - Both support the same glob patterns for file discovery
+* - Both are efficient for finding content 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
+*
+* Front matter parsing:
+* - Uses front-matter library to parse YAML/TOML front matter
+* - Extracts metadata like title, date, tags, author, etc.
+* - Supports both YAML (---) and TOML (+++) delimiters
+* - Returns structured attributes for prerendering
+*
+* File path processing:
+* - Normalizes paths for cross-platform compatibility
+* - Extracts file name without extension
+* - Determines file extension for content type handling
+* - Maintains relative path structure for routing
+*/
+export declare function getMatchingContentFilesWithFrontMatter(workspaceRoot: string, rootDir: string, glob: string, recursive?: boolean): PrerenderContentFile[];

package/src/lib/utils/get-content-files.js

@@ -59,14 +59,17 @@ var require = createRequire(import.meta.url);
 * - Determines file extension for content type handling
 * - Maintains relative path structure for routing
 */
-function getMatchingContentFilesWithFrontMatter(workspaceRoot, rootDir, glob) {
+function getMatchingContentFilesWithFrontMatter(workspaceRoot, rootDir, glob, recursive = false) {
 	const fm = require("front-matter");
 	const root = normalizePath(resolve(workspaceRoot, rootDir));
 	const resolvedDir = normalizePath(relative(root, join(root, glob)));
-	return globSync([`${root}/${resolvedDir}/*`], {
+	const contentFiles = globSync([recursive ? `${root}/${resolvedDir}/**/*` : `${root}/${resolvedDir}/*`], {
 		dot: true,
-		absolute: true
-	}).map((f) => {
+		absolute: true,
+		onlyFiles: true
+	});
+	const dirPrefix = `${root}/${resolvedDir}`;
+	return contentFiles.map((f) => {
 		const fileContents = readFileSync(f, "utf8");
 		const raw = fm(fileContents);
 		const match = normalizePath(f).replace(root, "").match(/\/([^/.]+)(\.([^/.]+))?$/);
@@ -76,12 +79,16 @@ function getMatchingContentFilesWithFrontMatter(workspaceRoot, rootDir, glob) {
 			name = match[1];
 			extension = match[3] || "";
 		}
+		const relativeDir = normalizePath(relative(dirPrefix, f));
+		const lastSlash = relativeDir.lastIndexOf("/");
+		const relativePath = lastSlash === -1 ? "" : relativeDir.slice(0, lastSlash);
 		return {
 			name,
 			extension,
 			path: resolvedDir,
 			attributes: raw.attributes,
-			content: fileContents
+			content: fileContents,
+			relativePath
 		};
 	});
 }

package/src/lib/utils/get-content-files.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-content-files.js","names":[],"sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/get-content-files.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport { join, relative, resolve } from 'node:path';\nimport { normalizePath } from 'vite';\nimport { createRequire } from 'node:module';\nimport { globSync } from 'tinyglobby';\n\nimport { PrerenderContentFile } from '../options';\n\nconst require = createRequire(import.meta.url);\n\n/**\n * Discovers content files with front matter and extracts metadata for prerendering.\n *\n * This function:\n * 1. Discovers all content files matching the specified glob pattern\n * 2. Reads each file and parses front matter metadata\n * 3. Extracts file name, extension, and path information\n * 4. Returns structured data for prerendering content pages\n *\n * @param workspaceRoot The workspace root directory path\n * @param rootDir The project root directory relative to workspace\n * @param glob The glob pattern to match content files (e.g., 'content/blog')\n * @returns Array of PrerenderContentFile objects with metadata and front matter\n *\n * Example usage:\n * const contentFiles = getMatchingContentFilesWithFrontMatter(\n *   '/workspace',\n *   'apps/my-app',\n *   'content/blog'\n * );\n *\n * Sample discovered file paths:\n * - /workspace/apps/my-app/content/blog/first-post.md\n * - /workspace/apps/my-app/content/blog/2024/01/hello-world.md\n * - /workspace/apps/my-app/content/blog/tech/angular-v17.mdx\n * - /workspace/apps/my-app/content/blog/about/index.md\n *\n * Sample output structure:\n * {\n *   name: 'first-post',\n *   extension: 'md',\n *   path: 'content/blog',\n *   attributes: { title: 'My First Post', date: '2024-01-01', tags: ['intro'] }\n * }\n *\n * tinyglobby vs fast-glob comparison:\n * - Both support the same glob patterns for file discovery\n * - Both are efficient for finding content 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 * Front matter parsing:\n * - Uses front-matter library to parse YAML/TOML front matter\n * - Extracts metadata like title, date, tags, author, etc.\n * - Supports both YAML (---) and TOML (+++) delimiters\n * - Returns structured attributes for prerendering\n *\n * File path processing:\n * - Normalizes paths for cross-platform compatibility\n * - Extracts file name without extension\n * - Determines file extension for content type handling\n * - Maintains relative path structure for routing\n */\nexport function getMatchingContentFilesWithFrontMatter(\n  workspaceRoot: string,\n  rootDir: string,\n  glob: string,\n): PrerenderContentFile[] {\n  // Dynamically require front-matter library\n  // eslint-disable-next-line @typescript-eslint/no-var-requires\n  const fm = require('front-matter');\n\n  // Normalize the project root path for consistent path handling\n  const root = normalizePath(resolve(workspaceRoot, rootDir));\n\n  // Resolve the content directory path relative to the project root\n  const resolvedDir = normalizePath(relative(root, join(root, glob)));\n\n  // Discover all content files in the specified directory\n  // Pattern: looks for any files in the resolved directory\n  const contentFiles: string[] = globSync([`${root}/${resolvedDir}/*`], {\n    dot: true,\n    absolute: true,\n  });\n\n  // Process each discovered content file to extract metadata and front matter\n  const mappedFilesWithFm: PrerenderContentFile[] = contentFiles.map((f) => {\n    // Read the file contents as UTF-8 text\n    const fileContents = readFileSync(f, 'utf8');\n\n    // Parse front matter from the file content\n    const raw = fm(fileContents);\n\n    const filepath = normalizePath(f).replace(root, '');\n\n    const match = filepath.match(/\\/([^/.]+)(\\.([^/.]+))?$/);\n    let name = '';\n    let extension = '';\n    if (match) {\n      name = match[1]; // File name without extension\n      extension = match[3] || ''; // File extension or empty string if no extension\n    }\n\n    // Return structured content file data for prerendering\n    return {\n      name,\n      extension,\n      path: resolvedDir,\n      attributes: raw.attributes as { attributes: Record<string, any> },\n      content: fileContents,\n    };\n  });\n\n  return mappedFilesWithFm;\n}\n"],"mappings":";;;;;;AAQA,IAAM,UAAU,cAAc,OAAO,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwD9C,SAAgB,uCACd,eACA,SACA,MACwB;CAGxB,MAAM,KAAK,QAAQ,eAAe;CAGlC,MAAM,OAAO,cAAc,QAAQ,eAAe,QAAQ,CAAC;CAG3D,MAAM,cAAc,cAAc,SAAS,MAAM,KAAK,MAAM,KAAK,CAAC,CAAC;AAqCnE,QAjC+B,SAAS,CAAC,GAAG,KAAK,GAAG,YAAY,IAAI,EAAE;EACpE,KAAK;EACL,UAAU;EACX,CAAC,CAG6D,KAAK,MAAM;EAExE,MAAM,eAAe,aAAa,GAAG,OAAO;EAG5C,MAAM,MAAM,GAAG,aAAa;EAI5B,MAAM,QAFW,cAAc,EAAE,CAAC,QAAQ,MAAM,GAAG,CAE5B,MAAM,2BAA2B;EACxD,IAAI,OAAO;EACX,IAAI,YAAY;AAChB,MAAI,OAAO;AACT,UAAO,MAAM;AACb,eAAY,MAAM,MAAM;;AAI1B,SAAO;GACL;GACA;GACA,MAAM;GACN,YAAY,IAAI;GAChB,SAAS;GACV;GACD"}
+{"version":3,"file":"get-content-files.js","names":[],"sources":["../../../../src/lib/utils/get-content-files.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport { join, relative, resolve } from 'node:path';\nimport { normalizePath } from 'vite';\nimport { createRequire } from 'node:module';\nimport { globSync } from 'tinyglobby';\n\nimport { PrerenderContentFile } from '../options';\n\nconst require = createRequire(import.meta.url);\n\n/**\n * Discovers content files with front matter and extracts metadata for prerendering.\n *\n * This function:\n * 1. Discovers all content files matching the specified glob pattern\n * 2. Reads each file and parses front matter metadata\n * 3. Extracts file name, extension, and path information\n * 4. Returns structured data for prerendering content pages\n *\n * @param workspaceRoot The workspace root directory path\n * @param rootDir The project root directory relative to workspace\n * @param glob The glob pattern to match content files (e.g., 'content/blog')\n * @returns Array of PrerenderContentFile objects with metadata and front matter\n *\n * Example usage:\n * const contentFiles = getMatchingContentFilesWithFrontMatter(\n *   '/workspace',\n *   'apps/my-app',\n *   'content/blog'\n * );\n *\n * Sample discovered file paths:\n * - /workspace/apps/my-app/content/blog/first-post.md\n * - /workspace/apps/my-app/content/blog/2024/01/hello-world.md\n * - /workspace/apps/my-app/content/blog/tech/angular-v17.mdx\n * - /workspace/apps/my-app/content/blog/about/index.md\n *\n * Sample output structure:\n * {\n *   name: 'first-post',\n *   extension: 'md',\n *   path: 'content/blog',\n *   attributes: { title: 'My First Post', date: '2024-01-01', tags: ['intro'] }\n * }\n *\n * tinyglobby vs fast-glob comparison:\n * - Both support the same glob patterns for file discovery\n * - Both are efficient for finding content 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 * Front matter parsing:\n * - Uses front-matter library to parse YAML/TOML front matter\n * - Extracts metadata like title, date, tags, author, etc.\n * - Supports both YAML (---) and TOML (+++) delimiters\n * - Returns structured attributes for prerendering\n *\n * File path processing:\n * - Normalizes paths for cross-platform compatibility\n * - Extracts file name without extension\n * - Determines file extension for content type handling\n * - Maintains relative path structure for routing\n */\nexport function getMatchingContentFilesWithFrontMatter(\n  workspaceRoot: string,\n  rootDir: string,\n  glob: string,\n  recursive = false,\n): PrerenderContentFile[] {\n  // Dynamically require front-matter library\n  // eslint-disable-next-line @typescript-eslint/no-var-requires\n  const fm = require('front-matter');\n\n  // Normalize the project root path for consistent path handling\n  const root = normalizePath(resolve(workspaceRoot, rootDir));\n\n  // Resolve the content directory path relative to the project root\n  const resolvedDir = normalizePath(relative(root, join(root, glob)));\n\n  // Discover all content files in the specified directory.\n  // Default pattern matches only top-level files; recursive opt-in walks subdirectories.\n  const pattern = recursive\n    ? `${root}/${resolvedDir}/**/*`\n    : `${root}/${resolvedDir}/*`;\n  const contentFiles: string[] = globSync([pattern], {\n    dot: true,\n    absolute: true,\n    onlyFiles: true,\n  });\n\n  const dirPrefix = `${root}/${resolvedDir}`;\n\n  // Process each discovered content file to extract metadata and front matter\n  const mappedFilesWithFm: PrerenderContentFile[] = contentFiles.map((f) => {\n    // Read the file contents as UTF-8 text\n    const fileContents = readFileSync(f, 'utf8');\n\n    // Parse front matter from the file content\n    const raw = fm(fileContents);\n\n    const filepath = normalizePath(f).replace(root, '');\n\n    const match = filepath.match(/\\/([^/.]+)(\\.([^/.]+))?$/);\n    let name = '';\n    let extension = '';\n    if (match) {\n      name = match[1]; // File name without extension\n      extension = match[3] || ''; // File extension or empty string if no extension\n    }\n\n    // Path of the file's directory relative to the configured contentDir.\n    // For top-level files this is an empty string; for nested files it\n    // gives transforms enough context to disambiguate identically-named\n    // files (e.g. docs/a/post.md vs docs/b/post.md).\n    const relativeDir = normalizePath(relative(dirPrefix, f));\n    const lastSlash = relativeDir.lastIndexOf('/');\n    const relativePath =\n      lastSlash === -1 ? '' : relativeDir.slice(0, lastSlash);\n\n    // Return structured content file data for prerendering\n    return {\n      name,\n      extension,\n      path: resolvedDir,\n      attributes: raw.attributes as { attributes: Record<string, any> },\n      content: fileContents,\n      relativePath,\n    };\n  });\n\n  return mappedFilesWithFm;\n}\n"],"mappings":";;;;;;AAQA,IAAM,UAAU,cAAc,OAAO,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwD9C,SAAgB,uCACd,eACA,SACA,MACA,YAAY,OACY;CAGxB,MAAM,KAAK,QAAQ,eAAe;CAGlC,MAAM,OAAO,cAAc,QAAQ,eAAe,QAAQ,CAAC;CAG3D,MAAM,cAAc,cAAc,SAAS,MAAM,KAAK,MAAM,KAAK,CAAC,CAAC;CAOnE,MAAM,eAAyB,SAAS,CAHxB,YACZ,GAAG,KAAK,GAAG,YAAY,SACvB,GAAG,KAAK,GAAG,YAAY,IACsB,EAAE;EACjD,KAAK;EACL,UAAU;EACV,WAAW;EACZ,CAAC;CAEF,MAAM,YAAY,GAAG,KAAK,GAAG;AAwC7B,QArCkD,aAAa,KAAK,MAAM;EAExE,MAAM,eAAe,aAAa,GAAG,OAAO;EAG5C,MAAM,MAAM,GAAG,aAAa;EAI5B,MAAM,QAFW,cAAc,EAAE,CAAC,QAAQ,MAAM,GAAG,CAE5B,MAAM,2BAA2B;EACxD,IAAI,OAAO;EACX,IAAI,YAAY;AAChB,MAAI,OAAO;AACT,UAAO,MAAM;AACb,eAAY,MAAM,MAAM;;EAO1B,MAAM,cAAc,cAAc,SAAS,WAAW,EAAE,CAAC;EACzD,MAAM,YAAY,YAAY,YAAY,IAAI;EAC9C,MAAM,eACJ,cAAc,KAAK,KAAK,YAAY,MAAM,GAAG,UAAU;AAGzD,SAAO;GACL;GACA;GACA,MAAM;GACN,YAAY,IAAI;GAChB,SAAS;GACT;GACD;GACD"}

package/src/lib/utils/get-page-handlers.d.ts

@@ -1,62 +1,59 @@
-import type { NitroEventHandler } from 'nitro/types';
+import type { NitroEventHandler } from "nitro/types";
 type GetHandlersArgs = {
-    workspaceRoot: string;
-    sourceRoot: string;
-    rootDir: string;
-    additionalPagesDirs?: string[];
-    hasAPIDir?: boolean;
+	workspaceRoot: string;
+	sourceRoot: string;
+	rootDir: string;
+	additionalPagesDirs?: string[];
 };
 /**
- * Discovers and generates Nitro event handlers for server-side page routes.
- *
- * This function:
- * 1. Discovers all .server.ts files in the app/pages directory and additional pages directories
- * 2. Converts file paths to route patterns using Angular-style route syntax
- * 3. Generates Nitro event handlers with proper route mapping and lazy loading
- * 4. Handles dynamic route parameters and catch-all routes
- *
- * @param workspaceRoot The workspace root directory path
- * @param sourceRoot The source directory path (e.g., 'src')
- * @param rootDir The project root directory relative to workspace
- * @param additionalPagesDirs Optional array of additional pages directories to scan
- * @param hasAPIDir Whether the project has an API directory (affects route prefixing)
- * @returns Array of NitroEventHandler objects with handler paths and route patterns
- *
- * Example usage:
- * const handlers = getPageHandlers({
- *   workspaceRoot: '/workspace',
- *   sourceRoot: 'src',
- *   rootDir: 'apps/my-app',
- *   additionalPagesDirs: ['/libs/shared/pages'],
- *   hasAPIDir: true
- * });
- *
- * Sample discovered file paths:
- * - /workspace/apps/my-app/src/app/pages/index.server.ts
- * - /workspace/apps/my-app/src/app/pages/users/[id].server.ts
- * - /workspace/apps/my-app/src/app/pages/products/[...slug].server.ts
- * - /workspace/apps/my-app/src/app/pages/(auth)/login.server.ts
- *
- * Route transformation examples:
- * - index.server.ts → /_analog/pages/index
- * - users/[id].server.ts → /_analog/pages/users/:id
- * - products/[...slug].server.ts → /_analog/pages/products/**:slug
- * - (auth)/login.server.ts → /_analog/pages/-auth-/login
- *
- * tinyglobby vs fast-glob comparison:
- * - Both support the same glob patterns for file discovery
- * - Both are efficient for finding server-side page 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
- *
- * Route transformation rules:
- * 1. Removes .server.ts extension
- * 2. Converts [param] to :param for dynamic routes
- * 3. Converts [...param] to **:param for catch-all routes
- * 4. Converts (group) to -group- for route groups
- * 5. Converts dots to forward slashes
- * 6. Prefixes with /_analog/pages and optionally /api
- */
-export declare function getPageHandlers({ workspaceRoot, sourceRoot, rootDir, additionalPagesDirs, hasAPIDir, }: GetHandlersArgs): NitroEventHandler[];
+* Discovers and generates Nitro event handlers for server-side page routes.
+*
+* This function:
+* 1. Discovers all .server.ts files in the app/pages directory and additional pages directories
+* 2. Converts file paths to route patterns using Angular-style route syntax
+* 3. Generates Nitro event handlers with proper route mapping and lazy loading
+* 4. Handles dynamic route parameters and catch-all routes
+*
+* @param workspaceRoot The workspace root directory path
+* @param sourceRoot The source directory path (e.g., 'src')
+* @param rootDir The project root directory relative to workspace
+* @param additionalPagesDirs Optional array of additional pages directories to scan
+* @returns Array of NitroEventHandler objects with handler paths and route patterns
+*
+* Example usage:
+* const handlers = getPageHandlers({
+*   workspaceRoot: '/workspace',
+*   sourceRoot: 'src',
+*   rootDir: 'apps/my-app',
+*   additionalPagesDirs: ['/libs/shared/pages'],
+* });
+*
+* Sample discovered file paths:
+* - /workspace/apps/my-app/src/app/pages/index.server.ts
+* - /workspace/apps/my-app/src/app/pages/users/[id].server.ts
+* - /workspace/apps/my-app/src/app/pages/products/[...slug].server.ts
+* - /workspace/apps/my-app/src/app/pages/(auth)/login.server.ts
+*
+* Route transformation examples:
+* - index.server.ts → /api/_analog/pages/index
+* - users/[id].server.ts → /api/_analog/pages/users/:id
+* - products/[...slug].server.ts → /api/_analog/pages/products/**:slug
+* - (auth)/login.server.ts → /api/_analog/pages/-auth-/login
+*
+* tinyglobby vs fast-glob comparison:
+* - Both support the same glob patterns for file discovery
+* - Both are efficient for finding server-side page 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
+*
+* Route transformation rules:
+* 1. Removes .server.ts extension
+* 2. Converts [param] to :param for dynamic routes
+* 3. Converts [...param] to **:param for catch-all routes
+* 4. Converts (group) to -group- for route groups
+* 5. Converts dots to forward slashes
+* 6. Prefixes with /api/_analog/pages
+*/
+export declare function getPageHandlers({ workspaceRoot, sourceRoot, rootDir, additionalPagesDirs }: GetHandlersArgs): NitroEventHandler[];
 export {};

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

@@ -15,7 +15,6 @@ import { globSync } from "tinyglobby";
 * @param sourceRoot The source directory path (e.g., 'src')
 * @param rootDir The project root directory relative to workspace
 * @param additionalPagesDirs Optional array of additional pages directories to scan
-* @param hasAPIDir Whether the project has an API directory (affects route prefixing)
 * @returns Array of NitroEventHandler objects with handler paths and route patterns
 *
 * Example usage:
@@ -24,7 +23,6 @@ import { globSync } from "tinyglobby";
 *   sourceRoot: 'src',
 *   rootDir: 'apps/my-app',
 *   additionalPagesDirs: ['/libs/shared/pages'],
-*   hasAPIDir: true
 * });
 *
 * Sample discovered file paths:
@@ -34,10 +32,10 @@ import { globSync } from "tinyglobby";
 * - /workspace/apps/my-app/src/app/pages/(auth)/login.server.ts
 *
 * Route transformation examples:
-* - index.server.ts → /_analog/pages/index
-* - users/[id].server.ts → /_analog/pages/users/:id
-* - products/[...slug].server.ts → /_analog/pages/products/**:slug
-* - (auth)/login.server.ts → /_analog/pages/-auth-/login
+* - index.server.ts → /api/_analog/pages/index
+* - users/[id].server.ts → /api/_analog/pages/users/:id
+* - products/[...slug].server.ts → /api/_analog/pages/products/**:slug
+* - (auth)/login.server.ts → /api/_analog/pages/-auth-/login
 *
 * tinyglobby vs fast-glob comparison:
 * - Both support the same glob patterns for file discovery
@@ -52,17 +50,16 @@ import { globSync } from "tinyglobby";
 * 3. Converts [...param] to **:param for catch-all routes
 * 4. Converts (group) to -group- for route groups
 * 5. Converts dots to forward slashes
-* 6. Prefixes with /_analog/pages and optionally /api
+* 6. Prefixes with /api/_analog/pages
 */
-function getPageHandlers({ workspaceRoot, sourceRoot, rootDir, additionalPagesDirs, hasAPIDir }) {
+function getPageHandlers({ workspaceRoot, sourceRoot, rootDir, additionalPagesDirs }) {
 	return globSync([`${normalizePath(resolve(workspaceRoot, rootDir))}/${sourceRoot}/app/pages/**/*.server.ts`, ...(additionalPagesDirs || []).map((dir) => `${workspaceRoot}${dir}/**/*.server.ts`)], {
 		dot: true,
 		absolute: true
 	}).map((endpointFile) => {
-		const route = normalizePath(endpointFile).replace(/^(.*?)\/pages/, "/pages").replace(/\.server\.ts$/, "").replace(/\[\.{3}(.+)\]/g, "**:$1").replace(/\[\.{3}(\w+)\]/g, "**:$1").replace(/\/\((.*?)\)$/, "/-$1-").replace(/\[(\w+)\]/g, ":$1").replace(/\./g, "/");
 		return {
 			handler: endpointFile,
-			route: `${hasAPIDir ? "/api" : ""}/_analog${route}`,
+			route: `/api/_analog${normalizePath(endpointFile).replace(/^(.*?)\/pages/, "/pages").replace(/\.server\.ts$/, "").replace(/\[\.{3}(.+)\]/g, "**:$1").replace(/\[\.{3}(\w+)\]/g, "**:$1").replace(/\/\((.*?)\)$/, "/-$1-").replace(/\[(\w+)\]/g, ":$1").replace(/\./g, "/")}`,
 			lazy: true
 		};
 	});

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"get-page-handlers.js","names":[],"sources":["../../../../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};\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 * @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 * });\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 → /api/_analog/pages/index\n * - users/[id].server.ts → /api/_analog/pages/users/:id\n * - products/[...slug].server.ts → /api/_analog/pages/products/**:slug\n * - (auth)/login.server.ts → /api/_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 /api/_analog/pages\n */\nexport function getPageHandlers({\n  workspaceRoot,\n  sourceRoot,\n  rootDir,\n  additionalPagesDirs,\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: `/api/_analog${route}`,\n      lazy: true,\n    };\n  });\n\n  return handlers;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAgB,gBAAgB,EAC9B,eACA,YACA,SACA,uBACuC;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;AAcxE,SAAO;GACL,SAAS;GACT,OAAO,eAdU,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;GAMpB,MAAM;GACP;GACD"}

package/src/lib/utils/get-server-fn-handlers.d.ts

@@ -0,0 +1,29 @@
+export type GetServerFnHandlersArgs = {
+	workspaceRoot: string;
+	sourceRoot: string;
+	rootDir: string;
+	additionalServerFnDirs?: string[];
+};
+export type ServerFnHandlerModule = {
+	/** Absolute, normalized path to a discovered `*.server.ts` module. */
+	file: string;
+};
+/**
+* Discovers the `*.server.ts` modules that may define server functions.
+*
+* Unlike page endpoints (one Nitro handler per file), server functions all
+* share a single `/_analog/fn/:id` dispatch route. The discovered modules are
+* imported for their registration side-effects — each `serverFn(...)` call
+* registers itself into the server-side registry at import time — after which
+* dispatch looks up the requested function by id.
+*
+* Scope is `<projectRoot>/<sourceRoot>/**\/*.server.ts` because the RFC allows a
+* server function to live in any `.server.ts` module, including existing page
+* server files. Only modules defining a server function that the client
+* transform can rewrite participate.
+* Angular SSR config (`app.config.server.ts`) is excluded — it is not a route or
+* function module and must not be pulled into the dispatch bundle.
+*
+* @returns discovered modules, de-duplicated and sorted for deterministic output
+*/
+export declare function getServerFnHandlers({ workspaceRoot, sourceRoot, rootDir, additionalServerFnDirs }: GetServerFnHandlersArgs): ServerFnHandlerModule[];

package/src/lib/utils/get-server-fn-handlers.js

@@ -0,0 +1,66 @@
+import { normalizePath } from "vite";
+import { resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { parseSync } from "oxc-parser";
+import { globSync } from "tinyglobby";
+//#region packages/vite-plugin-nitro/src/lib/utils/get-server-fn-handlers.ts
+/**
+* `*.server.ts` files that are matched by the glob but are never server-function
+* hosts, so importing them for registration side-effects would be wrong.
+*
+* The SSR entries (`main.server.ts`, `main-cf.server.ts`, …) sit at the top of
+* the source root and bootstrap the whole Angular application; importing one
+* would pull the entire app into the dispatch bundle. They are matched by
+* directory rather than by name so a page named `main.server.ts` still counts.
+*/
+var EXCLUDED_SERVER_FILES = [/\/app\.config\.server\.ts$/];
+/**
+* Discovers the `*.server.ts` modules that may define server functions.
+*
+* Unlike page endpoints (one Nitro handler per file), server functions all
+* share a single `/_analog/fn/:id` dispatch route. The discovered modules are
+* imported for their registration side-effects — each `serverFn(...)` call
+* registers itself into the server-side registry at import time — after which
+* dispatch looks up the requested function by id.
+*
+* Scope is `<projectRoot>/<sourceRoot>/**\/*.server.ts` because the RFC allows a
+* server function to live in any `.server.ts` module, including existing page
+* server files. Only modules defining a server function that the client
+* transform can rewrite participate.
+* Angular SSR config (`app.config.server.ts`) is excluded — it is not a route or
+* function module and must not be pulled into the dispatch bundle.
+*
+* @returns discovered modules, de-duplicated and sorted for deterministic output
+*/
+function getServerFnHandlers({ workspaceRoot, sourceRoot, rootDir, additionalServerFnDirs }) {
+	const root = normalizePath(resolve(workspaceRoot, rootDir));
+	const files = globSync([`${root}/${sourceRoot}/**/*.server.ts`, ...(additionalServerFnDirs || []).map((dir) => `${workspaceRoot}${dir}/**/*.server.ts`)], {
+		dot: true,
+		absolute: true
+	}).map((file) => normalizePath(file));
+	const sourceRootDir = `${root}/${sourceRoot}/`;
+	const seen = /* @__PURE__ */ new Set();
+	return files.filter((file) => !EXCLUDED_SERVER_FILES.some((re) => re.test(file))).filter((file) => !file.startsWith(sourceRootDir) || file.slice(sourceRootDir.length).includes("/")).filter((file) => seen.has(file) ? false : (seen.add(file), true)).sort().filter(definesServerFn).map((file) => ({ file }));
+}
+/**
+* Match the client scrub's supported server-function declaration shape. The
+* scrub deliberately falls back to the conventional `serverFn` name when the
+* function is re-exported through a local barrel, so discovery must make the
+* same choice or the browser receives a proxy without a dispatch route.
+*/
+function definesServerFn(file) {
+	const code = readFileSync(file, "utf8");
+	if (!code.includes("serverFn")) return false;
+	const { program } = parseSync(file, code);
+	const localNames = /* @__PURE__ */ new Set();
+	for (const node of program.body) {
+		if (node.type !== "ImportDeclaration" || node.source.value !== "@analogjs/router/server") continue;
+		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier" && (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) === "serverFn") localNames.add(specifier.local.name);
+	}
+	if (localNames.size === 0) localNames.add("serverFn");
+	return program.body.some((node) => node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration" && node.declaration.declarations.some((declarator) => declarator.id?.type === "Identifier" && declarator.init?.type === "CallExpression" && declarator.init.callee?.type === "Identifier" && localNames.has(declarator.init.callee.name)));
+}
+//#endregion
+export { getServerFnHandlers };
+
+//# sourceMappingURL=get-server-fn-handlers.js.map

package/src/lib/utils/get-server-fn-handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-server-fn-handlers.js","names":[],"sources":["../../../../src/lib/utils/get-server-fn-handlers.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport { parseSync } from 'oxc-parser';\nimport { resolve } from 'node:path';\nimport { globSync } from 'tinyglobby';\n\nimport { normalizePath } from 'vite';\n\nexport type GetServerFnHandlersArgs = {\n  workspaceRoot: string;\n  sourceRoot: string;\n  rootDir: string;\n  additionalServerFnDirs?: string[];\n};\n\nexport type ServerFnHandlerModule = {\n  /** Absolute, normalized path to a discovered `*.server.ts` module. */\n  file: string;\n};\n\n/**\n * `*.server.ts` files that are matched by the glob but are never server-function\n * hosts, so importing them for registration side-effects would be wrong.\n *\n * The SSR entries (`main.server.ts`, `main-cf.server.ts`, …) sit at the top of\n * the source root and bootstrap the whole Angular application; importing one\n * would pull the entire app into the dispatch bundle. They are matched by\n * directory rather than by name so a page named `main.server.ts` still counts.\n */\nconst EXCLUDED_SERVER_FILES: RegExp[] = [/\\/app\\.config\\.server\\.ts$/];\n\n/**\n * Discovers the `*.server.ts` modules that may define server functions.\n *\n * Unlike page endpoints (one Nitro handler per file), server functions all\n * share a single `/_analog/fn/:id` dispatch route. The discovered modules are\n * imported for their registration side-effects — each `serverFn(...)` call\n * registers itself into the server-side registry at import time — after which\n * dispatch looks up the requested function by id.\n *\n * Scope is `<projectRoot>/<sourceRoot>/**\\/*.server.ts` because the RFC allows a\n * server function to live in any `.server.ts` module, including existing page\n * server files. Only modules defining a server function that the client\n * transform can rewrite participate.\n * Angular SSR config (`app.config.server.ts`) is excluded — it is not a route or\n * function module and must not be pulled into the dispatch bundle.\n *\n * @returns discovered modules, de-duplicated and sorted for deterministic output\n */\nexport function getServerFnHandlers({\n  workspaceRoot,\n  sourceRoot,\n  rootDir,\n  additionalServerFnDirs,\n}: GetServerFnHandlersArgs): ServerFnHandlerModule[] {\n  const root = normalizePath(resolve(workspaceRoot, rootDir));\n\n  const files = globSync(\n    [\n      `${root}/${sourceRoot}/**/*.server.ts`,\n      ...(additionalServerFnDirs || []).map(\n        (dir) => `${workspaceRoot}${dir}/**/*.server.ts`,\n      ),\n    ],\n    { dot: true, absolute: true },\n  ).map((file) => normalizePath(file));\n\n  const sourceRootDir = `${root}/${sourceRoot}/`;\n  const seen = new Set<string>();\n  return files\n    .filter((file) => !EXCLUDED_SERVER_FILES.some((re) => re.test(file)))\n    .filter(\n      (file) =>\n        !file.startsWith(sourceRootDir) ||\n        file.slice(sourceRootDir.length).includes('/'),\n    )\n    .filter((file) => (seen.has(file) ? false : (seen.add(file), true)))\n    .sort()\n    .filter(definesServerFn)\n    .map((file) => ({ file }));\n}\n\n/**\n * Match the client scrub's supported server-function declaration shape. The\n * scrub deliberately falls back to the conventional `serverFn` name when the\n * function is re-exported through a local barrel, so discovery must make the\n * same choice or the browser receives a proxy without a dispatch route.\n */\nfunction definesServerFn(file: string): boolean {\n  const code = readFileSync(file, 'utf8');\n  if (!code.includes('serverFn')) return false;\n\n  const { program } = parseSync(file, code);\n  const localNames = new Set<string>();\n  for (const node of program.body) {\n    if (\n      node.type !== 'ImportDeclaration' ||\n      node.source.value !== '@analogjs/router/server'\n    ) {\n      continue;\n    }\n    for (const specifier of node.specifiers) {\n      if (\n        specifier.type === 'ImportSpecifier' &&\n        (specifier.imported.type === 'Identifier'\n          ? specifier.imported.name\n          : specifier.imported.value) === 'serverFn'\n      ) {\n        localNames.add(specifier.local.name);\n      }\n    }\n  }\n  if (localNames.size === 0) localNames.add('serverFn');\n\n  return program.body.some(\n    (node) =>\n      node.type === 'ExportNamedDeclaration' &&\n      node.declaration?.type === 'VariableDeclaration' &&\n      node.declaration.declarations.some(\n        (declarator) =>\n          declarator.id?.type === 'Identifier' &&\n          declarator.init?.type === 'CallExpression' &&\n          declarator.init.callee?.type === 'Identifier' &&\n          localNames.has(declarator.init.callee.name),\n      ),\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4BA,IAAM,wBAAkC,CAAC,6BAA6B;;;;;;;;;;;;;;;;;;;AAoBtE,SAAgB,oBAAoB,EAClC,eACA,YACA,SACA,0BACmD;CACnD,MAAM,OAAO,cAAc,QAAQ,eAAe,QAAQ,CAAC;CAE3D,MAAM,QAAQ,SACZ,CACE,GAAG,KAAK,GAAG,WAAW,kBACtB,IAAI,0BAA0B,EAAE,EAAE,KAC/B,QAAQ,GAAG,gBAAgB,IAAI,iBACjC,CACF,EACD;EAAE,KAAK;EAAM,UAAU;EAAM,CAC9B,CAAC,KAAK,SAAS,cAAc,KAAK,CAAC;CAEpC,MAAM,gBAAgB,GAAG,KAAK,GAAG,WAAW;CAC5C,MAAM,uBAAO,IAAI,KAAa;AAC9B,QAAO,MACJ,QAAQ,SAAS,CAAC,sBAAsB,MAAM,OAAO,GAAG,KAAK,KAAK,CAAC,CAAC,CACpE,QACE,SACC,CAAC,KAAK,WAAW,cAAc,IAC/B,KAAK,MAAM,cAAc,OAAO,CAAC,SAAS,IAAI,CACjD,CACA,QAAQ,SAAU,KAAK,IAAI,KAAK,GAAG,SAAS,KAAK,IAAI,KAAK,EAAE,MAAO,CACnE,MAAM,CACN,OAAO,gBAAgB,CACvB,KAAK,UAAU,EAAE,MAAM,EAAE;;;;;;;;AAS9B,SAAS,gBAAgB,MAAuB;CAC9C,MAAM,OAAO,aAAa,MAAM,OAAO;AACvC,KAAI,CAAC,KAAK,SAAS,WAAW,CAAE,QAAO;CAEvC,MAAM,EAAE,YAAY,UAAU,MAAM,KAAK;CACzC,MAAM,6BAAa,IAAI,KAAa;AACpC,MAAK,MAAM,QAAQ,QAAQ,MAAM;AAC/B,MACE,KAAK,SAAS,uBACd,KAAK,OAAO,UAAU,0BAEtB;AAEF,OAAK,MAAM,aAAa,KAAK,WAC3B,KACE,UAAU,SAAS,sBAClB,UAAU,SAAS,SAAS,eACzB,UAAU,SAAS,OACnB,UAAU,SAAS,WAAW,WAElC,YAAW,IAAI,UAAU,MAAM,KAAK;;AAI1C,KAAI,WAAW,SAAS,EAAG,YAAW,IAAI,WAAW;AAErD,QAAO,QAAQ,KAAK,MACjB,SACC,KAAK,SAAS,4BACd,KAAK,aAAa,SAAS,yBAC3B,KAAK,YAAY,aAAa,MAC3B,eACC,WAAW,IAAI,SAAS,gBACxB,WAAW,MAAM,SAAS,oBAC1B,WAAW,KAAK,QAAQ,SAAS,gBACjC,WAAW,IAAI,WAAW,KAAK,OAAO,KAAK,CAC9C,CACJ"}

package/src/lib/utils/i18n-prerender.d.ts

@@ -0,0 +1,36 @@
+import { PrerenderRoute } from "nitropack";
+import { I18nPrerenderOptions } from "../options.js";
+/**
+* Expands a list of routes to include locale-prefixed variants.
+*
+* For each route and each locale, generates a prefixed route:
+*   '/' + locale + route
+*
+* The default locale's routes are included both with and without the prefix
+* so that `/about` and `/en/about` both render.
+*
+* @param routes - The original routes to expand
+* @param i18n - The i18n prerender configuration
+* @returns Expanded routes with locale prefixes
+*/
+export declare function expandRoutesWithLocales(routes: string[], i18n: I18nPrerenderOptions): string[];
+/**
+* Creates a post-rendering hook that injects the `lang` attribute
+* into the `<html>` tag of prerendered pages based on the route's
+* locale prefix.
+*
+* @param i18n - The i18n prerender configuration
+* @returns A post-rendering hook function
+*/
+export declare function createI18nPostRenderingHook(i18n: I18nPrerenderOptions): (route: PrerenderRoute) => Promise<void>;
+/**
+* Detects the locale from a prerendered route path by checking
+* the first path segment against the configured locales.
+*/
+export declare function detectLocaleFromRoute(route: string, i18n: I18nPrerenderOptions): string;
+/**
+* Sets the `lang` attribute on the `<html>` tag in an HTML string.
+* If a `lang` attribute already exists, it is replaced.
+* If no `lang` attribute exists, it is added.
+*/
+export declare function setHtmlLang(html: string, locale: string): string;

package/src/lib/utils/i18n-prerender.js

@@ -0,0 +1,23 @@
+//#region packages/vite-plugin-nitro/src/lib/utils/i18n-prerender.ts
+/**
+* Detects the locale from a prerendered route path by checking
+* the first path segment against the configured locales.
+*/
+function detectLocaleFromRoute(route, i18n) {
+	const firstSegment = route.split("/").filter(Boolean)[0];
+	if (firstSegment && i18n.locales.includes(firstSegment)) return firstSegment;
+	return i18n.defaultLocale;
+}
+/**
+* Sets the `lang` attribute on the `<html>` tag in an HTML string.
+* If a `lang` attribute already exists, it is replaced.
+* If no `lang` attribute exists, it is added.
+*/
+function setHtmlLang(html, locale) {
+	if (/<html[^>]*\slang\s*=\s*["'][^"']*["']/i.test(html)) return html.replace(/(<html[^>]*\s)lang\s*=\s*["'][^"']*["']/i, `$1lang="${locale}"`);
+	return html.replace(/<html/i, `<html lang="${locale}"`);
+}
+//#endregion
+export { detectLocaleFromRoute, setHtmlLang };
+
+//# sourceMappingURL=i18n-prerender.js.map

package/src/lib/utils/i18n-prerender.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n-prerender.js","names":[],"sources":["../../../../src/lib/utils/i18n-prerender.ts"],"sourcesContent":["import { PrerenderRoute } from 'nitropack';\nimport { I18nPrerenderOptions } from '../options.js';\n\n/**\n * Expands a list of routes to include locale-prefixed variants.\n *\n * For each route and each locale, generates a prefixed route:\n *   '/' + locale + route\n *\n * The default locale's routes are included both with and without the prefix\n * so that `/about` and `/en/about` both render.\n *\n * @param routes - The original routes to expand\n * @param i18n - The i18n prerender configuration\n * @returns Expanded routes with locale prefixes\n */\nexport function expandRoutesWithLocales(\n  routes: string[],\n  i18n: I18nPrerenderOptions,\n): string[] {\n  const expanded: string[] = [];\n\n  for (const route of routes) {\n    // Skip API routes — they don't need locale prefixes\n    if (route.includes('/_analog/') || route.startsWith('/api/')) {\n      expanded.push(route);\n      continue;\n    }\n\n    for (const locale of i18n.locales) {\n      const prefix = `/${locale}`;\n      const localizedRoute = route === '/' ? prefix : `${prefix}${route}`;\n      expanded.push(localizedRoute);\n    }\n\n    // Keep the unprefixed route for the default locale\n    if (!expanded.includes(route)) {\n      expanded.push(route);\n    }\n  }\n\n  return expanded;\n}\n\n/**\n * Creates a post-rendering hook that injects the `lang` attribute\n * into the `<html>` tag of prerendered pages based on the route's\n * locale prefix.\n *\n * @param i18n - The i18n prerender configuration\n * @returns A post-rendering hook function\n */\nexport function createI18nPostRenderingHook(\n  i18n: I18nPrerenderOptions,\n): (route: PrerenderRoute) => Promise<void> {\n  return async (route: PrerenderRoute) => {\n    if (!route.contents || typeof route.contents !== 'string') {\n      return;\n    }\n\n    const locale = detectLocaleFromRoute(route.route, i18n);\n    if (!locale) {\n      return;\n    }\n\n    // Inject or replace the lang attribute on <html>\n    route.contents = setHtmlLang(route.contents, locale);\n  };\n}\n\n/**\n * Detects the locale from a prerendered route path by checking\n * the first path segment against the configured locales.\n */\nexport function detectLocaleFromRoute(\n  route: string,\n  i18n: I18nPrerenderOptions,\n): string {\n  const segments = route.split('/').filter(Boolean);\n  const firstSegment = segments[0];\n\n  if (firstSegment && i18n.locales.includes(firstSegment)) {\n    return firstSegment;\n  }\n\n  return i18n.defaultLocale;\n}\n\n/**\n * Sets the `lang` attribute on the `<html>` tag in an HTML string.\n * If a `lang` attribute already exists, it is replaced.\n * If no `lang` attribute exists, it is added.\n */\nexport function setHtmlLang(html: string, locale: string): string {\n  // Replace existing lang attribute\n  if (/<html[^>]*\\slang\\s*=\\s*[\"'][^\"']*[\"']/i.test(html)) {\n    return html.replace(\n      /(<html[^>]*\\s)lang\\s*=\\s*[\"'][^\"']*[\"']/i,\n      `$1lang=\"${locale}\"`,\n    );\n  }\n\n  // Add lang attribute to <html> tag\n  return html.replace(/<html/i, `<html lang=\"${locale}\"`);\n}\n"],"mappings":";;;;;AA0EA,SAAgB,sBACd,OACA,MACQ;CAER,MAAM,eADW,MAAM,MAAM,IAAI,CAAC,OAAO,QAAQ,CACnB;AAE9B,KAAI,gBAAgB,KAAK,QAAQ,SAAS,aAAa,CACrD,QAAO;AAGT,QAAO,KAAK;;;;;;;AAQd,SAAgB,YAAY,MAAc,QAAwB;AAEhE,KAAI,yCAAyC,KAAK,KAAK,CACrD,QAAO,KAAK,QACV,4CACA,WAAW,OAAO,GACnB;AAIH,QAAO,KAAK,QAAQ,UAAU,eAAe,OAAO,GAAG"}

package/src/lib/utils/inject-server-fn-ids.d.ts

@@ -0,0 +1,17 @@
+export interface InjectServerFnIdsResult {
+	code: string;
+	ids: {
+		name: string;
+		id: string;
+	}[];
+}
+/**
+* Server/SSR-build transform: injects the derived `id` into each
+* `export const NAME = serverFn(config, handler)` so the function registers
+* under the same opaque id the client proxy dispatches to. Unlike the client
+* scrub this keeps the handler and every other statement intact — it only edits
+* the config object — so the server module still runs the real implementation.
+*
+* Returns `null` when the module defines no server function.
+*/
+export declare function injectServerFnIds(code: string, fileId: string): InjectServerFnIdsResult | null;