@sigx/ssg 0.2.0 → 0.2.2

package/dist/virtual-entries-TuNN2It1.js

@@ -1,1298 +0,0 @@
-import path from "node:path";
-import fsSync from "node:fs";
-import fg from "fast-glob";
-import matter from "gray-matter";
-//#region src/config.ts
-/**
-* SSG Configuration helper
-*/
-/**
-* Define SSG configuration with type safety
-*
-* @example
-* ```ts
-* // ssg.config.ts
-* import { defineSSGConfig } from '@sigx/ssg';
-*
-* export default defineSSGConfig({
-*     pages: 'src/pages',
-*     layouts: 'src/layouts',
-*     theme: '@sigx/ssg-theme-daisyui',
-*     site: {
-*         title: 'My Site',
-*         description: 'A SignalX-powered static site'
-*     }
-* });
-* ```
-*/
-function defineSSGConfig(config) {
-	return {
-		pages: "src/pages",
-		layouts: "src/layouts",
-		content: "src/content",
-		defaultLayout: "default",
-		outDir: "dist",
-		base: "/",
-		autoEntries: true,
-		prefetch: true,
-		...config,
-		site: {
-			lang: "en",
-			...config.site
-		},
-		markdown: {
-			shiki: true,
-			...config.markdown
-		},
-		toc: {
-			minLevel: 2,
-			maxLevel: 3,
-			...config.toc
-		}
-	};
-}
-/**
-* Load SSG config from file
-*/
-async function loadConfig(configPath) {
-	const fsPath = await import("node:path");
-	const fs = await import("node:fs");
-	const { pathToFileURL } = await import("node:url");
-	const os = await import("node:os");
-	const cwd = process.cwd();
-	const possiblePaths = configPath ? [fsPath.resolve(cwd, configPath)] : [
-		fsPath.resolve(cwd, "ssg.config.ts"),
-		fsPath.resolve(cwd, "ssg.config.js"),
-		fsPath.resolve(cwd, "ssg.config.mjs")
-	];
-	let foundPath = null;
-	for (const p of possiblePaths) if (fs.existsSync(p)) {
-		foundPath = p;
-		break;
-	}
-	if (!foundPath) {
-		console.warn("No ssg.config found, using defaults");
-		return defineSSGConfig({});
-	}
-	try {
-		if (foundPath.endsWith(".ts")) {
-			const esbuild = await import("esbuild");
-			const tempDir = os.tmpdir();
-			fsPath.join(tempDir, `ssg-config-${Date.now()}.mjs`);
-			const source = fs.readFileSync(foundPath, "utf-8");
-			const result = await esbuild.transform(source, {
-				loader: "ts",
-				format: "esm"
-			});
-			const configDir = fsPath.dirname(foundPath);
-			const localTempFile = fsPath.join(configDir, `.ssg-config-temp-${Date.now()}.mjs`);
-			fs.writeFileSync(localTempFile, result.code);
-			try {
-				const configModule = await import(pathToFileURL(localTempFile).href);
-				return defineSSGConfig(configModule.default || configModule);
-			} finally {
-				try {
-					fs.unlinkSync(localTempFile);
-				} catch {}
-			}
-		}
-		const configModule = await import(pathToFileURL(foundPath).href);
-		return defineSSGConfig(configModule.default || configModule);
-	} catch (err) {
-		console.error(`Failed to load config from ${foundPath}:`, err);
-		return defineSSGConfig({});
-	}
-}
-/**
-* Resolve paths in config to absolute paths
-*/
-function resolveConfigPaths(config, root) {
-	return {
-		...config,
-		pages: path.resolve(root, config.pages || "src/pages"),
-		layouts: path.resolve(root, config.layouts || "src/layouts"),
-		content: path.resolve(root, config.content || "src/content"),
-		outDir: path.resolve(root, config.outDir || "dist")
-	};
-}
-//#endregion
-//#region src/mdx/frontmatter.ts
-/**
-* Frontmatter parser
-*
-* Extracts and parses YAML frontmatter from Markdown/MDX files.
-*/
-/**
-* Parse frontmatter from content
-*/
-function parseFrontmatter(source) {
-	const { data, content, matter: raw } = matter(source);
-	return {
-		data: normalizeFrontmatter(data),
-		content,
-		raw: raw || "",
-		hasFrontmatter: !!raw
-	};
-}
-/**
-* Normalize frontmatter data to PageMeta
-*/
-function normalizeFrontmatter(data) {
-	const meta = {};
-	if (typeof data.title === "string") meta.title = data.title;
-	if (typeof data.description === "string") meta.description = data.description;
-	if (typeof data.layout === "string") meta.layout = data.layout;
-	if (typeof data.draft === "boolean") meta.draft = data.draft;
-	if (data.date) {
-		if (data.date instanceof Date) meta.date = data.date;
-		else if (typeof data.date === "string") meta.date = new Date(data.date);
-	}
-	if (Array.isArray(data.tags)) meta.tags = data.tags.filter((t) => typeof t === "string");
-	if (typeof data.ssr === "boolean") meta.ssr = data.ssr;
-	for (const [key, value] of Object.entries(data)) if (!(key in meta)) meta[key] = value;
-	return meta;
-}
-/**
-* Extract title from markdown content if not in frontmatter
-*
-* Looks for the first H1 heading
-*/
-function extractTitleFromContent(content) {
-	const h1Match = content.match(/^#\s+(.+)$/m);
-	return h1Match ? h1Match[1].trim() : null;
-}
-//#endregion
-//#region src/routing/scanner.ts
-/**
-* File-based route scanner
-*
-* Scans a pages directory and generates route definitions from file paths.
-* Supports dynamic routes with [param] and catch-all with [...slug] patterns.
-*/
-/**
-* File extensions to treat as pages
-*/
-var PAGE_EXTENSIONS = [
-	".tsx",
-	".jsx",
-	".mdx",
-	".md"
-];
-/**
-* Files/directories to exclude from routing
-* 
-* Only exclude common non-page folders at the ROOT of pages directory.
-* Nested folders like /docs/components/ are valid routes.
-*/
-var EXCLUDED_PATTERNS = [
-	"components/**",
-	"hooks/**",
-	"utils/**",
-	"lib/**",
-	"**/_*",
-	"**/*.test.*",
-	"**/*.spec.*"
-];
-/**
-* Scan pages directory and generate routes
-*/
-async function scanPages(config, root) {
-	const pagesDir = path.resolve(root, config.pages || "src/pages");
-	const files = await fg(PAGE_EXTENSIONS.map((ext) => `**/*${ext}`), {
-		cwd: pagesDir,
-		ignore: EXCLUDED_PATTERNS,
-		onlyFiles: true,
-		absolute: false
-	});
-	const routes = [];
-	for (const file of files) {
-		const route = await fileToRouteWithMeta(file, pagesDir);
-		if (route) routes.push(route);
-	}
-	return sortRoutes(routes);
-}
-/**
-* Convert a file path to a route definition with frontmatter metadata
-*/
-async function fileToRouteWithMeta(filePath, pagesDir) {
-	const route = fileToRoute(filePath, pagesDir);
-	if (!route) return null;
-	const ext = path.extname(filePath).toLowerCase();
-	if (ext === ".mdx" || ext === ".md") try {
-		const { data } = parseFrontmatter(fsSync.readFileSync(route.file, "utf-8"));
-		route.meta = data;
-	} catch (err) {}
-	return route;
-}
-/**
-* Convert a file path to a route definition
-*/
-function fileToRoute(filePath, pagesDir) {
-	const ext = path.extname(filePath);
-	let routePath = filePath.slice(0, -ext.length);
-	if (routePath.endsWith("/index") || routePath === "index") routePath = routePath.replace(/\/?index$/, "") || "/";
-	routePath = filePathToRoutePath(routePath);
-	const name = pathToRouteName(routePath);
-	return {
-		path: routePath.startsWith("/") ? routePath : `/${routePath}`,
-		file: path.join(pagesDir, filePath),
-		name
-	};
-}
-/**
-* Convert file path patterns to route path patterns
-*
-* Examples:
-*   blog/[slug] -> /blog/:slug
-*   docs/[...path] -> /docs/*path
-*   users/[id]/posts -> /users/:id/posts
-*/
-function filePathToRoutePath(filePath) {
-	return filePath.split("/").map((segment) => {
-		if (segment.startsWith("[...") && segment.endsWith("]")) return `*${segment.slice(4, -1)}`;
-		if (segment.startsWith("[[...") && segment.endsWith("]]")) return `*${segment.slice(5, -2)}`;
-		if (segment.startsWith("[") && segment.endsWith("]")) return `:${segment.slice(1, -1)}`;
-		if (segment.startsWith("[[") && segment.endsWith("]]")) return `:${segment.slice(2, -2)}?`;
-		return segment;
-	}).join("/");
-}
-/**
-* Convert route path to a route name
-*
-* Examples:
-*   / -> index
-*   /about -> about
-*   /blog/:slug -> blog-slug
-*   /docs/*path -> docs-path
-*/
-function pathToRouteName(routePath) {
-	if (routePath === "/" || routePath === "") return "index";
-	return routePath.replace(/^\//, "").replace(/\//g, "-").replace(/:/g, "").replace(/\*/g, "").replace(/\?/g, "").replace(/-+/g, "-").replace(/-$/, "");
-}
-/**
-* Sort routes by specificity
-*
-* Order:
-*   1. Static routes (most specific)
-*   2. Dynamic param routes
-*   3. Catch-all routes (least specific)
-*
-* Within each category, longer paths come first
-*/
-function sortRoutes(routes) {
-	return routes.sort((a, b) => {
-		const scoreA = getRouteScore(a.path);
-		const scoreB = getRouteScore(b.path);
-		if (scoreA !== scoreB) return scoreB - scoreA;
-		return b.path.length - a.path.length;
-	});
-}
-/**
-* Calculate specificity score for a route
-*/
-function getRouteScore(routePath) {
-	const segments = routePath.split("/").filter(Boolean);
-	let score = 0;
-	for (const segment of segments) if (segment.startsWith("*")) score += 1;
-	else if (segment.startsWith(":")) score += 10;
-	else score += 100;
-	return score;
-}
-/**
-* Check if a route has dynamic segments
-*/
-function isDynamicRoute(route) {
-	return route.path.includes(":") || route.path.includes("*");
-}
-/**
-* Extract parameter names from a route path
-*/
-function extractParams(routePath) {
-	const params = [];
-	const segments = routePath.split("/");
-	for (const segment of segments) if (segment.startsWith(":")) params.push(segment.slice(1).replace("?", ""));
-	else if (segment.startsWith("*")) params.push(segment.slice(1));
-	return params;
-}
-/**
-* Generate all static paths for a route using getStaticPaths
-*/
-function expandDynamicRoute(route, staticPaths) {
-	const paths = [];
-	for (const { params } of staticPaths) {
-		let expandedPath = route.path;
-		for (const [key, value] of Object.entries(params)) {
-			expandedPath = expandedPath.replace(`:${key}`, value);
-			expandedPath = expandedPath.replace(`*${key}`, value);
-		}
-		paths.push(expandedPath);
-	}
-	return paths;
-}
-//#endregion
-//#region src/routing/virtual.ts
-/**
-* Virtual module ID for SSG routes
-*/
-var VIRTUAL_ROUTES_ID = "virtual:ssg-routes";
-var RESOLVED_VIRTUAL_ROUTES_ID = "\0" + VIRTUAL_ROUTES_ID;
-/**
-* Normalize file path to use forward slashes (for ES module imports)
-*/
-function normalizePath$1(filePath) {
-	return filePath.replace(/\\/g, "/");
-}
-/**
-* Generate the virtual routes module code
-*/
-function generateRoutesModule(routes, config) {
-	const imports = [];
-	const routeDefinitions = [];
-	for (let i = 0; i < routes.length; i++) {
-		const route = routes[i];
-		const componentName = `Page${i}`;
-		const metaName = `meta${i}`;
-		const normalizedFile = normalizePath$1(route.file);
-		imports.push(`import * as ${componentName}Module from '${normalizedFile}';`);
-		imports.push(`const ${metaName} = { ...('meta' in ${componentName}Module ? ${componentName}Module.meta : ${componentName}Module.default?.frontmatter || ${JSON.stringify(route.meta || {})}), headings: 'headings' in ${componentName}Module ? ${componentName}Module.headings : [] };`);
-		imports.push(`const ${componentName} = ${componentName}Module.default || ${componentName}Module;`);
-		routeDefinitions.push(`
-    {
-        path: '${route.path}',
-        name: '${route.name}',
-        file: '${normalizedFile}',
-        component: ${componentName},
-        meta: ${metaName},
-        layout: ${metaName}.layout || '${config.defaultLayout || "default"}',
-    }`);
-	}
-	return `
-${imports.join("\n")}
-
-const routes = [${routeDefinitions.join(",")}
-];
-
-export default routes;
-`;
-}
-/**
-* Generate lazy-loading routes module (for development with HMR)
-*/
-function generateLazyRoutesModule(routes, config) {
-	const imports = [];
-	const routeDefinitions = [];
-	for (let i = 0; i < routes.length; i++) {
-		const route = routes[i];
-		const componentName = `Page${i}`;
-		const metaName = `meta${i}`;
-		const normalizedFile = normalizePath$1(route.file);
-		imports.push(`import * as ${componentName}Module from '${normalizedFile}';`);
-		imports.push(`const ${metaName} = { ...('meta' in ${componentName}Module ? ${componentName}Module.meta : ${componentName}Module.default?.frontmatter || ${JSON.stringify(route.meta || {})}), headings: 'headings' in ${componentName}Module ? ${componentName}Module.headings : [] };`);
-		routeDefinitions.push(`
-    {
-        path: '${route.path}',
-        name: '${route.name}',
-        file: '${normalizedFile}',
-        component: () => import('${normalizedFile}'),
-        meta: ${metaName},
-        layout: ${metaName}.layout || '${config.defaultLayout || "default"}',
-    }`);
-	}
-	return `
-${imports.join("\n")}
-
-const routes = [${routeDefinitions.join(",")}
-];
-
-export default routes;
-`;
-}
-//#endregion
-//#region src/routing/navigation.ts
-/**
-* Generate navigation structure from routes for a specific collection path
-*
-* @param routes - Scanned SSG routes
-* @param collectionPath - Path prefix for the collection (e.g., '/docs')
-* @param showDrafts - Whether to show draft pages
-* @param isDev - Whether running in development mode
-*/
-function generateNavigation(routes, collectionPath, showDrafts, isDev) {
-	const navRoutes = routes.filter((route) => {
-		if (!route.path.startsWith(collectionPath)) return false;
-		const meta = route.meta || {};
-		if (meta.sidebar === false) return false;
-		if (meta.draft) {
-			if (showDrafts === "never") return false;
-			if (showDrafts === "dev" && !isDev) return false;
-		}
-		return true;
-	});
-	const context = {
-		categories: /* @__PURE__ */ new Map(),
-		uncategorized: []
-	};
-	for (const route of navRoutes) {
-		const meta = route.meta || {};
-		const title = meta.title || routeToTitle(route.path);
-		const order = typeof meta.order === "number" ? meta.order : 999;
-		const category = meta.category;
-		const item = {
-			title,
-			href: route.path,
-			order
-		};
-		if (!category) context.uncategorized.push(item);
-		else if (typeof category === "string") addToCategory(context.categories, [category], item);
-		else if (Array.isArray(category)) addToCategory(context.categories, category, item);
-	}
-	return { sidebar: buildSections(context) };
-}
-/**
-* Add an item to a nested category structure
-*/
-function addToCategory(categories, path, item) {
-	if (path.length === 0) return;
-	const [first, ...rest] = path;
-	let category = categories.get(first);
-	if (!category) {
-		category = {
-			title: first,
-			order: void 0,
-			items: [],
-			children: /* @__PURE__ */ new Map()
-		};
-		categories.set(first, category);
-	}
-	if (rest.length === 0) category.items.push(item);
-	else addToCategory(category.children, rest, item);
-}
-/**
-* Common section ordering for navigation
-* Used for both top-level sections and nested categories
-*/
-var SECTION_ORDER = {
-	"Getting Started": 10,
-	"Core Concepts": 20,
-	"Core": 20,
-	"Built-in Components": 30,
-	"Components": 30,
-	"Guides": 40,
-	"Advanced": 50,
-	"Ecosystem": 60,
-	"API Reference": 70,
-	"API": 70,
-	"Reference": 80,
-	"Actions": 100,
-	"Data Display": 110,
-	"Navigation": 120,
-	"Feedback": 130,
-	"Data Input": 140,
-	"Layout": 150,
-	"Mockup": 160,
-	"Other": 999
-};
-/**
-* Get sort order for a section/category title
-*/
-function getSectionOrder(title, explicitOrder) {
-	if (explicitOrder !== void 0) return explicitOrder;
-	return SECTION_ORDER[title] ?? 50;
-}
-/**
-* Build NavSection array from context
-*/
-function buildSections(context) {
-	const sections = [];
-	for (const [, category] of context.categories) sections.push(buildSection(category));
-	if (context.uncategorized.length > 0) sections.push({
-		title: "Other",
-		items: context.uncategorized.sort((a, b) => a.order - b.order || a.title.localeCompare(b.title)).map((item) => ({
-			title: item.title,
-			href: item.href,
-			order: item.order
-		})),
-		order: 999
-	});
-	sections.sort((a, b) => {
-		return getSectionOrder(a.title, a.order) - getSectionOrder(b.title, b.order);
-	});
-	return sections;
-}
-/**
-* Build a NavSection from a category
-*/
-function buildSection(category) {
-	const sortedItems = category.items.sort((a, b) => a.order - b.order || a.title.localeCompare(b.title)).map((item) => ({
-		title: item.title,
-		href: item.href,
-		order: item.order
-	}));
-	const childSections = [];
-	for (const [, child] of category.children) childSections.push(buildNestedSection(child));
-	const items = [...sortedItems];
-	for (const nested of childSections.sort((a, b) => {
-		return getSectionOrder(a.title, a.order) - getSectionOrder(b.title, b.order);
-	})) items.push(nested);
-	return {
-		title: category.title,
-		items,
-		order: category.order
-	};
-}
-/**
-* Build a nested NavItem from a child category
-*/
-function buildNestedSection(category) {
-	const sortedItems = category.items.sort((a, b) => a.order - b.order || a.title.localeCompare(b.title)).map((item) => ({
-		title: item.title,
-		href: item.href,
-		order: item.order
-	}));
-	const childItems = [];
-	for (const [, child] of category.children) childItems.push(buildNestedSection(child));
-	return {
-		title: category.title,
-		items: [...sortedItems, ...childItems.sort((a, b) => (a.order ?? 0) - (b.order ?? 0))],
-		order: category.order
-	};
-}
-/**
-* Convert route path to a display title
-*
-* @example '/docs/getting-started' -> 'Getting Started'
-* @example '/docs/api/router' -> 'Router'
-*/
-function routeToTitle(routePath) {
-	const segments = routePath.split("/").filter(Boolean);
-	return (segments[segments.length - 1] || "Home").replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
-}
-/**
-* Generate navigation for all collections
-*
-* @param routes - Scanned SSG routes
-* @param config - SSG configuration
-* @param isDev - Whether running in development mode
-* @returns Record mapping collection names to their navigation
-*/
-function generateAllCollections(routes, config, isDev) {
-	const collections = config.collections || {};
-	const result = {};
-	for (const [name, collectionConfig] of Object.entries(collections)) {
-		const showDrafts = collectionConfig.showDrafts ?? config.navigation?.showDrafts ?? "dev";
-		result[name] = generateNavigation(routes, collectionConfig.path, showDrafts, isDev);
-	}
-	return result;
-}
-//#endregion
-//#region src/routing/virtual-navigation.ts
-/**
-* Virtual module ID for SSG navigation
-*/
-var VIRTUAL_NAVIGATION_ID = "virtual:ssg-navigation";
-var RESOLVED_VIRTUAL_NAVIGATION_ID = "\0" + VIRTUAL_NAVIGATION_ID;
-/**
-* Generate the virtual navigation module code
-*
-* @param routes - Scanned SSG routes with metadata
-* @param config - SSG configuration
-* @param isDev - Whether running in development mode
-*/
-function generateNavigationModule(routes, config, isDev) {
-	const navigation = generateAllCollections(routes, config, isDev);
-	const collections = config.collections || {};
-	return `
-/**
- * Auto-generated navigation module
- * 
- * @generated by @sigx/ssg
- */
-
-/**
- * Navigation for all collections, keyed by collection name
- */
-export const navigation = ${JSON.stringify(navigation, null, 2)};
-
-/**
- * Collections configuration
- */
-const collections = ${JSON.stringify(collections, null, 2)};
-
-/**
- * Get navigation for a specific collection
- * @param name - Collection name (e.g., 'docs', 'examples')
- * @returns The collection's navigation or undefined if not found
- */
-export function getCollectionNav(name) {
-    return navigation[name];
-}
-
-/**
- * Detect which collection a route path belongs to
- * @param path - Current route path
- * @returns The collection name if found, undefined otherwise
- */
-export function detectCollection(path) {
-    // Sort by path length descending to match most specific path first
-    const sorted = Object.entries(collections).sort(
-        ([, a], [, b]) => b.path.length - a.path.length
-    );
-
-    for (const [name, config] of sorted) {
-        if (path.startsWith(config.path)) {
-            return name;
-        }
-    }
-
-    return undefined;
-}
-
-/**
- * Get sidebar for a specific collection
- * @param name - Collection name
- * @returns The sidebar array or empty array if not found
- */
-export function getSidebar(name) {
-    return navigation[name]?.sidebar || [];
-}
-
-export default { navigation, collections, getCollectionNav, detectCollection, getSidebar };
-`;
-}
-//#endregion
-//#region src/layouts/resolver.ts
-/**
-* Layout resolver
-*
-* Resolves layouts from local layouts directory or theme packages.
-* Layouts wrap page content and provide consistent structure.
-*/
-/**
-* Layout extensions to search for
-*/
-var LAYOUT_EXTENSIONS = [".tsx", ".jsx"];
-/**
-* Scan local layouts directory
-*/
-async function scanLocalLayouts(config, root) {
-	const layoutsDir = path.resolve(root, config.layouts || "src/layouts");
-	if (!fsSync.existsSync(layoutsDir)) return [];
-	return (await fg(LAYOUT_EXTENSIONS.map((ext) => `*${ext}`), {
-		cwd: layoutsDir,
-		onlyFiles: true,
-		absolute: false
-	})).map((file) => {
-		const ext = path.extname(file);
-		return {
-			name: file.slice(0, -ext.length),
-			file: path.join(layoutsDir, file),
-			source: "local"
-		};
-	});
-}
-/**
-* Load layouts from a theme package
-*/
-async function loadThemeLayouts(themeName, root) {
-	try {
-		const { createRequire } = await import("node:module");
-		const { pathToFileURL } = await import("node:url");
-		const themePackageJson = createRequire(path.join(root, "package.json")).resolve(`${themeName}/package.json`);
-		const themeDir = path.dirname(themePackageJson);
-		const packageJson = JSON.parse(fsSync.readFileSync(themePackageJson, "utf-8"));
-		const mainFile = packageJson.exports?.["."]?.import || packageJson.main || "./dist/index.js";
-		const themeModule = await import(pathToFileURL(path.resolve(themeDir, mainFile)).href);
-		if (!themeModule.layouts) return [];
-		return Object.keys(themeModule.layouts).map((name) => ({
-			name,
-			file: `${themeName}/layouts/${name}`,
-			source: themeName
-		}));
-	} catch (err) {
-		console.warn(`Failed to load theme ${themeName}:`, err);
-		return [];
-	}
-}
-/**
-* Discover all available layouts
-*
-* Priority order:
-* 1. Local layouts (can override theme)
-* 2. Theme layouts
-*/
-async function discoverLayouts(config, root) {
-	const layouts = /* @__PURE__ */ new Map();
-	if (config.theme) {
-		const themeLayouts = await loadThemeLayouts(config.theme, root);
-		for (const layout of themeLayouts) layouts.set(layout.name, layout);
-	}
-	const localLayouts = await scanLocalLayouts(config, root);
-	for (const layout of localLayouts) layouts.set(layout.name, layout);
-	return Array.from(layouts.values());
-}
-//#endregion
-//#region src/layouts/virtual.ts
-/**
-* Virtual module ID for generated layouts
-*/
-var VIRTUAL_LAYOUTS_ID = "virtual:generated-layouts";
-var RESOLVED_VIRTUAL_LAYOUTS_ID = "\0virtual:generated-layouts";
-/**
-* Normalize file path to use forward slashes (for ES module imports)
-*/
-function normalizePath(filePath) {
-	return filePath.replace(/\\/g, "/");
-}
-/**
-* Generate the virtual layouts module code
-*/
-function generateLayoutsModule(layouts, config) {
-	const imports = [];
-	const layoutEntries = [];
-	for (let i = 0; i < layouts.length; i++) {
-		const layout = layouts[i];
-		const importName = `Layout${i}`;
-		if (layout.source === "local") {
-			const normalizedFile = normalizePath(layout.file);
-			imports.push(`import ${importName} from '${normalizedFile}';`);
-		} else {
-			imports.push(`import { layouts as themeLayouts${i} } from '${layout.source}';`);
-			imports.push(`const ${importName} = themeLayouts${i}['${layout.name}'];`);
-		}
-		layoutEntries.push(`    '${layout.name}': ${importName}.default || ${importName}`);
-	}
-	return `
-import { component, signal, jsx } from 'sigx';
-import { useRoute } from '@sigx/router';
-${imports.join("\n")}
-
-/**
- * All available layouts
- */
-export const layouts = {
-${layoutEntries.join(",\n")}
-};
-
-/**
- * Default layout name
- */
-export const defaultLayout = '${config.defaultLayout || "default"}';
-
-/**
- * Check if a component is marked as lazy (created by lazy())
- */
-function isMarkedLazy(component) {
-    return component && component.__lazy === true;
-}
-
-/**
- * Check if a value is a Promise/thenable
- */
-function isPromise(value) {
-    return value && typeof value.then === 'function';
-}
-
-/**
- * Track hydration state - we're hydrating if the app container has SSR content
- */
-let isHydrating = typeof window !== 'undefined' && 
-    document.getElementById('app')?.innerHTML?.trim().length > 0;
-
-// After first render, we're no longer hydrating
-if (typeof window !== 'undefined') {
-    const markHydrationComplete = () => { isHydrating = false; };
-    if ('requestIdleCallback' in window) {
-        window.requestIdleCallback(markHydrationComplete);
-    } else {
-        setTimeout(markHydrationComplete, 0);
-    }
-}
-
-/**
- * Placeholder component that preserves existing DOM during hydration.
- */
-const HydrationPlaceholder = component(() => {
-    return () => null;
-}, { name: 'HydrationPlaceholder' });
-
-/**
- * Layout router component that preserves layouts across navigation.
- * 
- * This component renders the current route's layout and page content reactively.
- * When navigating between routes with the same layout, only the page content
- * updates - the layout (Navbar, Sidebar, Footer) persists without re-rendering.
- */
-export const LayoutRouter = component((ctx) => {
-    const route = useRoute();
-    
-    // Track loaded lazy components to avoid reloading
-    const loadedComponents = {};
-    
-    // Track if this is the initial hydration render
-    let initialRender = true;
-    
-    // HMR support: Listen for MDX updates and clear the component cache
-    if (typeof window !== 'undefined' && import.meta.hot) {
-        // Listen for sigx:mdx-hmr events dispatched by MDX files after they accept HMR
-        const handleMdxHmr = (event) => {
-            const { moduleId, newModule } = event.detail || {};
-            
-            // Clear all cached components to force reload with new module
-            for (const key in loadedComponents) {
-                delete loadedComponents[key];
-            }
-            
-            // If we have the new module directly from HMR, cache it for the matching route
-            if (newModule?.default) {
-                const currentPath = route.path;
-                loadedComponents[currentPath] = newModule.default;
-            }
-            
-            // Force re-render
-            ctx.update();
-        };
-        
-        window.addEventListener('sigx:mdx-hmr', handleMdxHmr);
-        
-        ctx.onUnmounted(() => {
-            window.removeEventListener('sigx:mdx-hmr', handleMdxHmr);
-        });
-    }
-    
-    return () => {
-        const matched = route.matched;
-        if (!matched || matched.length === 0) return null;
-        
-        const match = matched[0];
-        if (!match) return null;
-        
-        // Get layout name from route meta or use default
-        const layoutName = match.layout || match.meta?.layout || defaultLayout;
-        const Layout = layouts[layoutName];
-        
-        if (!Layout) {
-            console.warn(\`Layout "\${layoutName}" not found for route \${route.path}\`);
-            return null;
-        }
-        
-        // Get the original (unwrapped) component
-        const rawComponent = match.originalComponent || match.component;
-        const routePath = route.path;
-        
-        // Handle lazy/dynamic import components
-        if (isMarkedLazy(rawComponent) || (typeof rawComponent === 'function' && !rawComponent.__setup)) {
-            // Check if already loaded
-            if (loadedComponents[routePath]) {
-                const PageComponent = loadedComponents[routePath];
-                initialRender = false;
-                return jsx(Layout, { 
-                    meta: match.meta, 
-                    path: routePath, 
-                    key: layoutName,  // Key by layout to preserve layout across pages
-                    children: PageComponent({}) 
-                });
-            }
-            
-            // Load the component
-            const loadState = signal({ value: null, loading: true, error: null });
-            
-            try {
-                const result = rawComponent();
-                if (isPromise(result)) {
-                    result.then(module => {
-                        const Component = module.default || module;
-                        loadedComponents[routePath] = Component;
-                        loadState.value = Component;
-                        loadState.loading = false;
-                    }).catch(err => {
-                        console.error('Failed to load component for route:', routePath, err);
-                        loadState.error = err;
-                        loadState.loading = false;
-                    });
-                } else {
-                    // Not a promise, use directly
-                    loadedComponents[routePath] = rawComponent;
-                    loadState.value = rawComponent;
-                    loadState.loading = false;
-                }
-            } catch (err) {
-                loadState.error = err;
-                loadState.loading = false;
-            }
-            
-            // During hydration, preserve existing SSR content instead of showing loading state
-            if (loadState.loading) {
-                if (isHydrating && initialRender) {
-                    return jsx(Layout, { 
-                        meta: match.meta, 
-                        path: routePath, 
-                        key: layoutName,
-                        children: jsx(HydrationPlaceholder, {})
-                    });
-                }
-                return jsx(Layout, { 
-                    meta: match.meta, 
-                    path: routePath, 
-                    key: layoutName,
-                    children: null 
-                });
-            }
-            
-            if (loadState.error || !loadState.value) {
-                return jsx(Layout, { 
-                    meta: match.meta, 
-                    path: routePath, 
-                    key: layoutName,
-                    children: null 
-                });
-            }
-            
-            const PageComponent = loadState.value;
-            initialRender = false;
-            return jsx(Layout, { 
-                meta: match.meta, 
-                path: routePath, 
-                key: layoutName,
-                children: PageComponent({}) 
-            });
-        }
-        
-        // Eager component (has __setup)
-        // Check cache first for HMR-updated components
-        if (loadedComponents[routePath]) {
-            const PageComponent = loadedComponents[routePath];
-            initialRender = false;
-            return jsx(Layout, { 
-                meta: match.meta, 
-                path: routePath, 
-                key: layoutName,
-                children: PageComponent({}) 
-            });
-        }
-        
-        initialRender = false;
-        return jsx(Layout, { 
-            meta: match.meta, 
-            path: routePath, 
-            key: layoutName,
-            children: rawComponent({}) 
-        });
-    };
-}, { name: 'LayoutRouter' });
-
-/**
- * Setup layouts for routes
- *
- * This function now simply annotates routes with their layout information.
- * The actual layout wrapping is handled by LayoutRouter, which preserves
- * layouts across navigation.
- */
-export function setupLayouts(routes) {
-    const availableLayoutNames = Object.keys(layouts);
-    
-    return routes.map(route => {
-        const layoutName = route.layout || route.meta?.layout || defaultLayout;
-        const Layout = layouts[layoutName];
-
-        if (!Layout) {
-            console.error(
-                \`❌ SSG103: Layout "\${layoutName}" not found for route \${route.path}\\n\` +
-                \`   📁 \${route.file || 'unknown'}\\n\` +
-                \`   💡 Available layouts: \${availableLayoutNames.join(', ') || 'none'}\\n\` +
-                \`      Create src/layouts/\${layoutName}.tsx or set a valid layout in frontmatter.\`
-            );
-            return route;
-        }
-
-        // Store layout info on the route, but don't wrap the component
-        // LayoutRouter will handle layout rendering
-        return {
-            ...route,
-            layout: layoutName,
-            originalComponent: route.component,
-            meta: {
-                ...route.meta,
-                layout: layoutName,
-            },
-        };
-    });
-}
-
-export default layouts;
-`;
-}
-//#endregion
-//#region src/vite/virtual-entries.ts
-/**
-* Virtual Entry Point Generation
-* 
-* Generates auto-configured client and server entry points for zero-config mode.
-* Users can override by providing their own entry files.
-*/
-/**
-* Virtual module IDs
-* Note: We use a special path format that Vite can resolve from HTML
-*/
-var VIRTUAL_CLIENT_ID = "virtual:ssg-client";
-var RESOLVED_VIRTUAL_CLIENT_ID = "\0" + VIRTUAL_CLIENT_ID + ".tsx";
-var SSG_CLIENT_ENTRY_PATH = "/@ssg/client.tsx";
-var VIRTUAL_SERVER_ID = "virtual:ssg-server";
-var RESOLVED_VIRTUAL_SERVER_ID = "\0" + VIRTUAL_SERVER_ID + ".tsx";
-/**
-* Detect if user has custom entry points
-*/
-function detectCustomEntries(root, config) {
-	const clientPaths = [
-		"src/main.tsx",
-		"src/main.ts",
-		"src/entry-client.tsx",
-		"src/entry-client.ts",
-		"src/entry.tsx",
-		"src/entry.ts"
-	];
-	const serverPaths = ["src/entry-server.tsx", "src/entry-server.ts"];
-	const htmlPaths = ["index.html"];
-	const cssPaths = [
-		"src/styles/global.css",
-		"src/styles/main.css",
-		"src/styles/index.css",
-		"src/style.css",
-		"src/global.css",
-		"src/index.css"
-	];
-	let customClientPath;
-	let customServerPath;
-	let customHtmlPath;
-	let globalCssPath;
-	for (const p of clientPaths) {
-		const fullPath = path.join(root, p);
-		if (fsSync.existsSync(fullPath)) {
-			customClientPath = fullPath;
-			break;
-		}
-	}
-	for (const p of serverPaths) {
-		const fullPath = path.join(root, p);
-		if (fsSync.existsSync(fullPath)) {
-			customServerPath = fullPath;
-			break;
-		}
-	}
-	for (const p of htmlPaths) {
-		const fullPath = path.join(root, p);
-		if (fsSync.existsSync(fullPath)) {
-			customHtmlPath = fullPath;
-			break;
-		}
-	}
-	for (const p of cssPaths) {
-		const fullPath = path.join(root, p);
-		if (fsSync.existsSync(fullPath)) {
-			globalCssPath = "/" + p.replace(/\\/g, "/");
-			break;
-		}
-	}
-	return {
-		useVirtualClient: !customClientPath,
-		useVirtualServer: !customServerPath,
-		useVirtualHtml: !customHtmlPath,
-		customClientPath,
-		customServerPath,
-		customHtmlPath,
-		globalCssPath
-	};
-}
-/**
-* Generate virtual client entry code
-*/
-function generateClientEntry(config, detection) {
-	const cssImport = detection.globalCssPath ? `import '${detection.globalCssPath}';\n` : "";
-	const additionalImports = (config.clientImports ?? []).map((imp) => `import '${imp}';`).join("\n");
-	const additionalImportsBlock = additionalImports ? `\n${additionalImports}\n` : "";
-	const prefetchDelay = typeof config.prefetch === "object" ? config.prefetch.delay ?? 100 : 100;
-	const prefetchEnabled = config.prefetch !== false;
-	return `/**
- * Auto-generated client entry point
- * This file is generated by @sigx/ssg when no custom entry is detected.
- * To customize, create src/main.tsx or src/entry-client.tsx
- */
-${cssImport}${additionalImportsBlock}
-import { defineApp, component } from 'sigx';
-import { createRouter, createWebHistory } from '@sigx/router';
-import { ssrClientPlugin } from '@sigx/ssg/client';
-import routes from 'virtual:ssg-routes';
-import { setupLayouts, LayoutRouter } from 'virtual:generated-layouts';
-${prefetchEnabled ? `import { setupPrefetch } from '@sigx/ssg/client';` : ""}
-
-// Apply layouts to routes (annotates routes with layout info)
-const layoutRoutes = setupLayouts(routes);
-
-// Create router with browser history
-const router = createRouter({
-    history: createWebHistory('${config.base || "/"}'),
-    routes: layoutRoutes,
-});
-
-// Root app component - uses LayoutRouter which preserves layouts across navigation
-const App = component(() => {
-    return () => <LayoutRouter />;
-});
-
-// Hydrate the server-rendered HTML
-defineApp(<App />)
-    .use(router)
-    .use(ssrClientPlugin)
-    .hydrate('#app');
-
-${prefetchEnabled ? `// Enable link prefetching for faster navigation
-setupPrefetch({ delay: ${prefetchDelay} });` : ""}
-`;
-}
-/**
-* Generate virtual server entry code
-*/
-function generateServerEntry(config) {
-	return `/**
- * Auto-generated server entry point
- * This file is generated by @sigx/ssg when no custom entry is detected.
- * To customize, create src/entry-server.tsx
- */
-import { renderToString } from '@sigx/server-renderer/server';
-import { defineApp } from 'sigx';
-import { createRouter, createMemoryHistory } from '@sigx/router';
-import routes from 'virtual:ssg-routes';
-import { setupLayouts, LayoutRouter } from 'virtual:generated-layouts';
-
-// Pre-process routes with layouts once at module load time (not per-render)
-const routesWithLayouts = setupLayouts(routes);
-
-/**
- * Render the app to HTML string for a given URL
- */
-export async function render(url, context) {
-    // Create router with memory history for SSR
-    // Note: We must create a new router per render because history is URL-specific
-    const router = createRouter({
-        routes: routesWithLayouts,
-        history: createMemoryHistory({ initialLocation: url || '/' }),
-    });
-
-    // Create app with router - router's install() sets up DI via app.defineProvide()
-    const app = defineApp(<LayoutRouter />).use(router);
-    
-    const html = await renderToString(app);
-    return html;
-}
-`;
-}
-/**
-* Generate virtual HTML template
-*/
-function generateHtmlTemplate(config) {
-	const site = config.site || {};
-	const lang = site.lang || "en";
-	const title = site.title || "SignalX App";
-	const description = site.description || "";
-	const favicon = site.favicon || "/favicon.ico";
-	const themeColor = site.themeColor || "#000000";
-	const ogImage = site.ogImage || "";
-	const url = site.url || "";
-	const twitter = site.twitter || "";
-	const fonts = site.fonts || [];
-	let fontLinks = "";
-	if (fonts.length > 0) fontLinks = `
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link href="https://fonts.googleapis.com/css2?family=${fonts.join("&family=")}&display=swap" rel="stylesheet" />`;
-	let ogTags = "";
-	if (url || ogImage) ogTags = `
-    <!-- Open Graph -->
-    <meta property="og:type" content="website" />
-    <meta property="og:title" content="${title}" />
-    <meta property="og:description" content="${description}" />${url ? `
-    <meta property="og:url" content="${url}" />` : ""}${ogImage ? `
-    <meta property="og:image" content="${ogImage}" />` : ""}`;
-	let twitterTags = "";
-	if (twitter || ogImage) twitterTags = `
-    <!-- Twitter Card -->
-    <meta name="twitter:card" content="${ogImage ? "summary_large_image" : "summary"}" />${twitter ? `
-    <meta name="twitter:site" content="@${twitter}" />` : ""}
-    <meta name="twitter:title" content="${title}" />
-    <meta name="twitter:description" content="${description}" />${ogImage ? `
-    <meta name="twitter:image" content="${ogImage}" />` : ""}`;
-	return `<!DOCTYPE html>
-<html lang="${lang}">
-<head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta name="description" content="${description}" />
-    <meta name="theme-color" content="${themeColor}" />
-    <link rel="icon" type="image/x-icon" href="${favicon}" />${fontLinks}${ogTags}${twitterTags}
-    <title>${title}</title>
-    <!--head-tags-->
-</head>
-<body>
-    <div id="app"><!--app-html--></div>
-    <script type="module" src="/@ssg/client.tsx"><\/script>
-</body>
-</html>
-`;
-}
-/**
-* Generate HTML template for production build
-* Uses the actual client entry path instead of virtual module
-*/
-function generateProductionHtmlTemplate(config, clientEntryPath) {
-	const site = config.site || {};
-	const lang = site.lang || "en";
-	const title = site.title || "SignalX App";
-	const description = site.description || "";
-	const favicon = site.favicon || "/favicon.ico";
-	const themeColor = site.themeColor || "#000000";
-	const ogImage = site.ogImage || "";
-	const url = site.url || "";
-	const twitter = site.twitter || "";
-	const fonts = site.fonts || [];
-	let fontLinks = "";
-	if (fonts.length > 0) fontLinks = `
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-    <link href="https://fonts.googleapis.com/css2?family=${fonts.join("&family=")}&display=swap" rel="stylesheet" />`;
-	let ogTags = "";
-	if (url || ogImage) ogTags = `
-    <!-- Open Graph -->
-    <meta property="og:type" content="website" />
-    <meta property="og:title" content="${title}" />
-    <meta property="og:description" content="${description}" />${url ? `
-    <meta property="og:url" content="${url}" />` : ""}${ogImage ? `
-    <meta property="og:image" content="${ogImage}" />` : ""}`;
-	let twitterTags = "";
-	if (twitter || ogImage) twitterTags = `
-    <!-- Twitter Card -->
-    <meta name="twitter:card" content="${ogImage ? "summary_large_image" : "summary"}" />${twitter ? `
-    <meta name="twitter:site" content="@${twitter}" />` : ""}
-    <meta name="twitter:title" content="${title}" />
-    <meta name="twitter:description" content="${description}" />${ogImage ? `
-    <meta name="twitter:image" content="${ogImage}" />` : ""}`;
-	return `<!DOCTYPE html>
-<html lang="${lang}">
-<head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta name="description" content="${description}" />
-    <meta name="theme-color" content="${themeColor}" />
-    <link rel="icon" type="image/x-icon" href="${favicon}" />${fontLinks}${ogTags}${twitterTags}
-    <title>${title}</title>
-    <!--head-tags-->
-</head>
-<body>
-    <div id="app"><!--app-html--></div>
-    <script type="module" src="${clientEntryPath}"><\/script>
-</body>
-</html>
-`;
-}
-//#endregion
-export { resolveConfigPaths as A, extractParams as C, parseFrontmatter as D, extractTitleFromContent as E, defineSSGConfig as O, expandDynamicRoute as S, scanPages as T, generateNavigationModule as _, VIRTUAL_SERVER_ID as a, generateLazyRoutesModule as b, generateHtmlTemplate as c, RESOLVED_VIRTUAL_LAYOUTS_ID as d, VIRTUAL_LAYOUTS_ID as f, VIRTUAL_NAVIGATION_ID as g, RESOLVED_VIRTUAL_NAVIGATION_ID as h, VIRTUAL_CLIENT_ID as i, loadConfig as k, generateProductionHtmlTemplate as l, discoverLayouts as m, RESOLVED_VIRTUAL_SERVER_ID as n, detectCustomEntries as o, generateLayoutsModule as p, SSG_CLIENT_ENTRY_PATH as r, generateClientEntry as s, RESOLVED_VIRTUAL_CLIENT_ID as t, generateServerEntry as u, RESOLVED_VIRTUAL_ROUTES_ID as v, isDynamicRoute as w, generateRoutesModule as x, VIRTUAL_ROUTES_ID as y };
-
-//# sourceMappingURL=virtual-entries-TuNN2It1.js.map