@analogjs/vite-plugin-nitro 3.0.0-alpha.1 → 3.0.0-alpha.10

package/src/lib/plugins/page-endpoints.js.map

@@ -1 +1 @@
-{"version":3,"file":"page-endpoints.js","sourceRoot":"","sources":["../../../../../../packages/vite-plugin-nitro/src/lib/plugins/page-endpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAErC,MAAM,UAAU,mBAAmB;IACjC,OAAO;QACL,IAAI,EAAE,iDAAiD;QACvD,KAAK,CAAC,SAAS,CAAC,KAAa,EAAE,EAAU;YACvC,IAAI,aAAa,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;gBACvE,MAAM,QAAQ,GAAG,SAAS,CAAC;oBACzB,KAAK,EAAE;wBACL,QAAQ,EAAE,KAAK;wBACf,UAAU,EAAE,EAAE;wBACd,MAAM,EAAE,IAAI;qBACb;oBACD,KAAK,EAAE,KAAK;oBACZ,QAAQ,EAAE,IAAI;oBACd,QAAQ,EAAE,SAAS;oBACnB,MAAM,EAAE,KAAK;oBACb,QAAQ,EAAE,QAAQ;iBACnB,CAAC,CAAC;gBAEH,IAAI,WAAW,GAAa,EAAE,CAAC;gBAE/B,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC;oBAC7C,IAAI,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC;wBAC/C,WAAW,GAAG,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;oBACxD,CAAC;gBACH,CAAC;gBAED,mEAAmE;gBACnE,kEAAkE;gBAClE,gEAAgE;gBAChE,6CAA6C;gBAC7C,gEAAgE;gBAChE,wCAAwC;gBACxC,EAAE;gBACF,uEAAuE;gBACvE,uEAAuE;gBACvE,qBAAqB;gBACrB,sDAAsD;gBACtD,kEAAkE;gBAClE,EAAE;gBACF,wEAAwE;gBACxE,8DAA8D;gBAC9D,MAAM,IAAI,GAAG;;;;cAKP,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC;oBAC1B,CAAC,CAAC,KAAK;oBACP,CAAC,CAAC;kBACA,KAAK;;;kBAIX;;cAGE,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC;oBAC5B,CAAC,CAAC,EAAE;oBACJ,CAAC,CAAC;;;;eAKN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAsCD,CAAC;gBAEJ,OAAO;oBACL,IAAI;oBACJ,GAAG,EAAE,IAAI;iBACV,CAAC;YACJ,CAAC;YAED,OAAO;QACT,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"page-endpoints.js","names":[],"sources":["../../../../../../packages/vite-plugin-nitro/src/lib/plugins/page-endpoints.ts"],"sourcesContent":["import { parseSync } from 'oxc-parser';\nimport { normalizePath } from 'vite';\nimport { SERVER_FETCH_FACTORY_SNIPPET } from '../utils/renderers.js';\n\nexport function pageEndpointsPlugin() {\n  return {\n    name: 'analogjs-vite-plugin-nitro-rollup-page-endpoint',\n    async transform(\n      _code: string,\n      id: string,\n    ): Promise<{ code: string; map: null } | undefined> {\n      if (normalizePath(id).includes('/pages/') && id.endsWith('.server.ts')) {\n        const result = parseSync(id, _code, {\n          sourceType: 'module',\n          lang: 'ts',\n        });\n\n        const fileExports: string[] = result.module.staticExports.flatMap((e) =>\n          e.entries\n            .filter((entry) => entry.exportName.name !== null)\n            .map((entry) => entry.exportName.name as string),\n        );\n\n        // In h3 v2 / Nitro v3, event.node is undefined during prerendering\n        // (which uses the fetch-based pipeline, not Node.js http). We use\n        // optional chaining so that page endpoints work in both Node.js\n        // server and fetch-based prerender contexts.\n        // Nitro v3 no longer guarantees the private `nitro/deps/ofetch`\n        // subpath that older codegen relied on.\n        //\n        // Page loaders expect Nitro-style `$fetch` semantics (parsed data plus\n        // internal relative-route support), so construct a request-local fetch\n        // using public APIs:\n        // - `createFetch` from `ofetch` for `$fetch` behavior\n        // - `fetchWithEvent` from `h3` for internal Nitro request routing\n        //\n        // This avoids both unstable private Nitro imports and assumptions about\n        // a global runtime `$fetch` being available during prerender.\n        const code = `\n            import { defineHandler, fetchWithEvent } from 'nitro/h3';\n            import { createFetch } from 'ofetch';\n\n            ${\n              fileExports.includes('load')\n                ? _code\n                : `\n                ${_code}\n                export const load = () => {\n                  return {};\n                }`\n            }\n\n            ${\n              fileExports.includes('action')\n                ? ''\n                : `\n                export const action = () => {\n                  return {};\n                }\n              `\n            }\n\n            export default defineHandler(async(event) => {\n              ${SERVER_FETCH_FACTORY_SNIPPET}\n\n              if (event.method === 'GET') {\n                try {\n                  return await load({\n                    params: event.context.params,\n                    req: event.node?.req,\n                    res: event.node?.res,\n                    fetch: serverFetch,\n                    event\n                  });\n                } catch(e) {\n                  console.error(\\` An error occurred: \\${e}\\`)\n                  throw e;\n                }\n              } else {\n                try {\n                  return await action({\n                    params: event.context.params,\n                    req: event.node?.req,\n                    res: event.node?.res,\n                    fetch: serverFetch,\n                    event\n                  });\n                } catch(e) {\n                  console.error(\\` An error occurred: \\${e}\\`)\n                  throw e;\n                }\n              }\n            });\n          `;\n\n        return {\n          code,\n          map: null,\n        };\n      }\n\n      return;\n    },\n  };\n}\n"],"mappings":";;;;AAIA,SAAgB,sBAAsB;AACpC,QAAO;EACL,MAAM;EACN,MAAM,UACJ,OACA,IACkD;AAClD,OAAI,cAAc,GAAG,CAAC,SAAS,UAAU,IAAI,GAAG,SAAS,aAAa,EAAE;IAMtE,MAAM,cALS,UAAU,IAAI,OAAO;KAClC,YAAY;KACZ,MAAM;KACP,CAAC,CAEmC,OAAO,cAAc,SAAS,MACjE,EAAE,QACC,QAAQ,UAAU,MAAM,WAAW,SAAS,KAAK,CACjD,KAAK,UAAU,MAAM,WAAW,KAAe,CACnD;AA0ED,WAAO;KACL,MA1DW;;;;cAKP,YAAY,SAAS,OAAO,GACxB,QACA;kBACA,MAAM;;;mBAIX;;cAGC,YAAY,SAAS,SAAS,GAC1B,KACA;;;;gBAKL;;;gBAGG,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkCnC,KAAK;KACN;;;EAKN"}

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
- */
+* 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[];

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":["../../../../../../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"}

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