@analogjs/vite-plugin-nitro 3.0.0-alpha.3 → 3.0.0-alpha.31

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

@@ -1,100 +1,91 @@
-import { readFileSync } from 'node:fs';
-import { join, relative, resolve } from 'node:path';
-import { normalizePath } from 'vite';
-import { createRequire } from 'node:module';
-import { globSync } from 'tinyglobby';
-const require = createRequire(import.meta.url);
+import { normalizePath } from "vite";
+import { join, relative, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { globSync } from "tinyglobby";
+import { createRequire } from "node:module";
+//#region packages/vite-plugin-nitro/src/lib/utils/get-content-files.ts
+var require = createRequire(import.meta.url);
 /**
- * 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 function getMatchingContentFilesWithFrontMatter(workspaceRoot, rootDir, glob) {
-    // Dynamically require front-matter library
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const fm = require('front-matter');
-    // Normalize the project root path for consistent path handling
-    const root = normalizePath(resolve(workspaceRoot, rootDir));
-    // Resolve the content directory path relative to the project root
-    const resolvedDir = normalizePath(relative(root, join(root, glob)));
-    // Discover all content files in the specified directory
-    // Pattern: looks for any files in the resolved directory
-    const contentFiles = globSync([`${root}/${resolvedDir}/*`], {
-        dot: true,
-        absolute: true,
-    });
-    // Process each discovered content file to extract metadata and front matter
-    const mappedFilesWithFm = contentFiles.map((f) => {
-        // Read the file contents as UTF-8 text
-        const fileContents = readFileSync(f, 'utf8');
-        // Parse front matter from the file content
-        const raw = fm(fileContents);
-        const filepath = normalizePath(f).replace(root, '');
-        const match = filepath.match(/\/([^/.]+)(\.([^/.]+))?$/);
-        let name = '';
-        let extension = '';
-        if (match) {
-            name = match[1]; // File name without extension
-            extension = match[3] || ''; // File extension or empty string if no extension
-        }
-        // Return structured content file data for prerendering
-        return {
-            name,
-            extension,
-            path: resolvedDir,
-            attributes: raw.attributes,
-            content: fileContents,
-        };
-    });
-    return mappedFilesWithFm;
+* 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
+*/
+function getMatchingContentFilesWithFrontMatter(workspaceRoot, rootDir, glob) {
+	const fm = require("front-matter");
+	const root = normalizePath(resolve(workspaceRoot, rootDir));
+	const resolvedDir = normalizePath(relative(root, join(root, glob)));
+	return globSync([`${root}/${resolvedDir}/*`], {
+		dot: true,
+		absolute: true
+	}).map((f) => {
+		const fileContents = readFileSync(f, "utf8");
+		const raw = fm(fileContents);
+		const match = normalizePath(f).replace(root, "").match(/\/([^/.]+)(\.([^/.]+))?$/);
+		let name = "";
+		let extension = "";
+		if (match) {
+			name = match[1];
+			extension = match[3] || "";
+		}
+		return {
+			name,
+			extension,
+			path: resolvedDir,
+			attributes: raw.attributes,
+			content: fileContents
+		};
+	});
 }
+//#endregion
+export { getMatchingContentFilesWithFrontMatter };
+
 //# sourceMappingURL=get-content-files.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"get-content-files.js","sourceRoot":"","sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/get-content-files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAItC,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,UAAU,sCAAsC,CACpD,aAAqB,EACrB,OAAe,EACf,IAAY;IAEZ,2CAA2C;IAC3C,8DAA8D;IAC9D,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAEnC,+DAA+D;IAC/D,MAAM,IAAI,GAAG,aAAa,CAAC,OAAO,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC;IAE5D,kEAAkE;IAClE,MAAM,WAAW,GAAG,aAAa,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IAEpE,wDAAwD;IACxD,yDAAyD;IACzD,MAAM,YAAY,GAAa,QAAQ,CAAC,CAAC,GAAG,IAAI,IAAI,WAAW,IAAI,CAAC,EAAE;QACpE,GAAG,EAAE,IAAI;QACT,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;IAEH,4EAA4E;IAC5E,MAAM,iBAAiB,GAA2B,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACvE,uCAAuC;QACvC,MAAM,YAAY,GAAG,YAAY,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;QAE7C,2CAA2C;QAC3C,MAAM,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,CAAC;QAE7B,MAAM,QAAQ,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAEpD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;QACzD,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,8BAA8B;YAC/C,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,iDAAiD;QAC/E,CAAC;QAED,uDAAuD;QACvD,OAAO;YACL,IAAI;YACJ,SAAS;YACT,IAAI,EAAE,WAAW;YACjB,UAAU,EAAE,GAAG,CAAC,UAAiD;YACjE,OAAO,EAAE,YAAY;SACtB,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,OAAO,iBAAiB,CAAC;AAC3B,CAAC"}
+{"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): 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"}

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

@@ -1,62 +1,62 @@
-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[];
+	hasAPIDir?: boolean;
 };
 /**
- * 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
+* @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[];
 export {};

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

@@ -1,87 +1,73 @@
-import { resolve } from 'node:path';
-import { globSync } from 'tinyglobby';
-import { normalizePath } from 'vite';
+import { normalizePath } from "vite";
+import { resolve } from "node:path";
+import { globSync } from "tinyglobby";
+//#region packages/vite-plugin-nitro/src/lib/utils/get-page-handlers.ts
 /**
- * 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 function getPageHandlers({ workspaceRoot, sourceRoot, rootDir, additionalPagesDirs, hasAPIDir, }) {
-    // Normalize the project root path for consistent path handling
-    const root = normalizePath(resolve(workspaceRoot, rootDir));
-    // Discover all .server.ts files in the app/pages directory and additional pages directories
-    // Pattern: looks for any .server.ts files in app/pages/**/*.server.ts and additional directories
-    const endpointFiles = globSync([
-        `${root}/${sourceRoot}/app/pages/**/*.server.ts`,
-        ...(additionalPagesDirs || []).map((dir) => `${workspaceRoot}${dir}/**/*.server.ts`),
-    ], { dot: true, absolute: true });
-    // Transform each discovered file into a Nitro event handler
-    const handlers = endpointFiles.map((endpointFile) => {
-        // Normalize the endpoint file path for consistent path handling
-        const normalized = normalizePath(endpointFile);
-        // Transform the normalized path into a route pattern
-        const route = normalized
-            .replace(/^(.*?)\/pages/, '/pages')
-            .replace(/\.server\.ts$/, '') // Remove .server.ts extension
-            .replace(/\[\.{3}(.+)\]/g, '**:$1') // Convert [...param] to **:param (catch-all routes)
-            .replace(/\[\.{3}(\w+)\]/g, '**:$1') // Alternative catch-all pattern
-            .replace(/\/\((.*?)\)$/, '/-$1-') // Convert (group) to -group- (route groups)
-            .replace(/\[(\w+)\]/g, ':$1') // Convert [param] to :param (dynamic routes)
-            .replace(/\./g, '/'); // Convert dots to forward slashes
-        // Return Nitro event handler with absolute handler path and transformed route
-        return {
-            handler: endpointFile,
-            route: `${hasAPIDir ? '/api' : ''}/_analog${route}`,
-            lazy: true,
-        };
-    });
-    return handlers;
+* 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
+*/
+function getPageHandlers({ workspaceRoot, sourceRoot, rootDir, additionalPagesDirs, hasAPIDir }) {
+	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}`,
+			lazy: true
+		};
+	});
 }
+//#endregion
+export { getPageHandlers };
+
 //# sourceMappingURL=get-page-handlers.js.map

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

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

package/src/lib/utils/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"}