blumenjs 0.1.7 → 0.2.1

package/dist/templates/scripts/generate-routes.ts

@@ -15,19 +15,22 @@
  *   - index.tsx       → "/"  (index route for folders)
  *   - NotFound.tsx    → skipped (reserved 404)
  *   - _app.tsx        → skipped (reserved prefix)
+ *   - _layout.tsx     → layout metadata (not a route, metadata cascades to children)
  *
  * Usage:  npx tsx scripts/generate-routes.ts
  */
 
 import * as fs from "fs";
 import * as path from "path";
+import * as ts from "typescript";
+import { generateAPIRoutes } from "./generate-api-routes";
 
 const PAGES_DIR = path.resolve("app/pages");
 const SSR_OUTPUT = path.resolve("node-ssr/generated-routes.ts");
 const CLIENT_OUTPUT = path.resolve("app/client/generated-routes.ts");
 
 // Reserved filenames that should not become routes
-const RESERVED = new Set(["NotFound", "NotFound.tsx"]);
+const RESERVED = new Set(["NotFound", "NotFound.tsx", "loading.tsx"]);
 
 interface RouteEntry {
 	/** The URL path, e.g. "/" or "/users/[id]" */
@@ -40,6 +43,75 @@ interface RouteEntry {
 	patternStr: string;
 	/** Extracted parameter keys */
 	keys: string[];
+	/** Whether this page exports a getServerProps function */
+	hasGetServerProps: boolean;
+	/** Whether this page exports a static metadata object */
+	hasMetadata: boolean;
+	/** Whether this page exports a generateMetadata function */
+	hasGenerateMetadata: boolean;
+	/** Whether a loading.tsx file exists in the same directory */
+	hasLoading: boolean;
+	/** Import path for the loading component (if hasLoading) */
+	loadingImportPath?: string;
+	/** Whether this page exports dynamic = 'force-static' for SSG */
+	isStatic: boolean;
+}
+
+interface LayoutEntry {
+	/** Directory path relative to PAGES_DIR, e.g. "" (root) or "docs" */
+	dirPath: string;
+	/** The URL prefix this layout applies to, e.g. "/" or "/docs" */
+	routePrefix: string;
+	/** Import path for the layout file (without extension) */
+	importPath: string;
+	/** Safe identifier for imports */
+	layoutId: string;
+	/** Whether this layout exports a static metadata object */
+	hasMetadata: boolean;
+	/** Whether this layout exports a generateMetadata function */
+	hasGenerateMetadata: boolean;
+}
+
+/**
+ * Check if a file exports a named identifier at the top level.
+ * Uses TypeScript AST to avoid false positives from strings/comments.
+ */
+function hasNamedExport(filePath: string, content: string, exportName: string): boolean {
+	const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+	let found = false;
+	
+	ts.forEachChild(sourceFile, (node) => {
+		// 1. Function declaration: export [async] function name() {}
+		if (ts.isFunctionDeclaration(node)) {
+			const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+			if (isExported && node.name?.text === exportName) {
+				found = true;
+			}
+		} 
+		// 2. Variable declaration: export const name = ...
+		else if (ts.isVariableStatement(node)) {
+			const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+			if (isExported) {
+				for (const decl of node.declarationList.declarations) {
+					if (ts.isIdentifier(decl.name) && decl.name.text === exportName) {
+						found = true;
+					}
+				}
+			}
+		} 
+		// 3. Export declaration: export { name } or export { x as name }
+		else if (ts.isExportDeclaration(node)) {
+			if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+				for (const element of node.exportClause.elements) {
+					if (element.name.text === exportName) {
+						found = true;
+					}
+				}
+			}
+		}
+	});
+	
+	return found;
 }
 
 function scanDir(dir: string, baseDir: string = dir): RouteEntry[] {
@@ -87,16 +159,83 @@ function scanDir(dir: string, baseDir: string = dir): RouteEntry[] {
 				patternStr = `^${patternStr}$`;
 			}
 
+			// Check if the page exports getServerProps, metadata, or generateMetadata
+			const fileContent = fs.readFileSync(fullPath, "utf-8");
+			const hasGetServerProps = hasNamedExport(fullPath, fileContent, "getServerProps");
+			const hasMetadata = hasNamedExport(fullPath, fileContent, "metadata");
+			const hasGenerateMetadata = hasNamedExport(fullPath, fileContent, "generateMetadata");
+			const hasDynamic = hasNamedExport(fullPath, fileContent, "dynamic");
+			const isStatic = hasDynamic && fileContent.includes("force-static");
+
+			// Check for a loading.tsx file in the same directory
+			const pageDir = path.dirname(fullPath);
+			const loadingFile = path.join(pageDir, "loading.tsx");
+			const hasLoading = fs.existsSync(loadingFile);
+			const loadingImportPath = hasLoading
+				? path.relative(baseDir, loadingFile).replace(".tsx", "").replace(/\\/g, "/")
+				: undefined;
+
 			results.push({
 				route: routePath,
 				componentId,
 				importPath: relPath.replace(".tsx", "").replace(/\\/g, "/"),
 				patternStr,
-				keys
+				keys,
+				hasGetServerProps,
+				hasMetadata,
+				hasGenerateMetadata,
+				hasLoading,
+				loadingImportPath,
+				isStatic,
+			});
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Scan for _layout.tsx files in the pages directory tree.
+ * These files can export metadata/generateMetadata that cascades to child pages.
+ */
+function scanLayouts(dir: string, baseDir: string = dir): LayoutEntry[] {
+	let results: LayoutEntry[] = [];
+	const items = fs.readdirSync(dir, { withFileTypes: true });
+
+	// Check for _layout.tsx in this directory
+	const layoutFile = path.join(dir, "_layout.tsx");
+	if (fs.existsSync(layoutFile)) {
+		const relDir = path.relative(baseDir, dir).replace(/\\/g, "/");
+		const routePrefix = relDir === "" ? "/" : "/" + relDir.toLowerCase();
+		const layoutId = relDir === "" ? "Layout_root" : "Layout_" + relDir.replace(/[^a-zA-Z0-9]/g, "_");
+		const importPath = relDir === "" ? "_layout" : relDir + "/_layout";
+
+		const content = fs.readFileSync(layoutFile, "utf-8");
+		const hasMetadata = hasNamedExport(layoutFile, content, "metadata");
+		const hasGenerateMetadata = hasNamedExport(layoutFile, content, "generateMetadata");
+
+		if (hasMetadata || hasGenerateMetadata) {
+			results.push({
+				dirPath: relDir,
+				routePrefix,
+				importPath,
+				layoutId,
+				hasMetadata,
+				hasGenerateMetadata,
 			});
 		}
 	}
 
+	// Recurse into subdirectories
+	for (const item of items) {
+		if (item.isDirectory() && !item.name.startsWith("_")) {
+			results = results.concat(scanLayouts(path.join(dir, item.name), baseDir));
+		}
+	}
+
+	// Sort by depth (root first, then deeper segments)
+	results.sort((a, b) => a.dirPath.split("/").length - b.dirPath.split("/").length);
+
 	return results;
 }
 
@@ -120,6 +259,7 @@ function discoverPages(): RouteEntry[] {
 
 function generateRouteFile(
 	routes: RouteEntry[],
+	layouts: LayoutEntry[],
 	importPathPrefix: string,
 	isServer: boolean,
 ): string {
@@ -139,6 +279,56 @@ function generateRouteFile(
 			`import ${r.componentId} from "${importPathPrefix}/${r.importPath}";`,
 	);
 
+	// For SSR: import getServerProps from pages that export it
+	const gspImports: string[] = [];
+	const gspRoutes = routes.filter(r => r.hasGetServerProps);
+	if (isServer && gspRoutes.length > 0) {
+		for (const r of gspRoutes) {
+			const gspId = "gsp_" + r.componentId.replace("Page_", "");
+			gspImports.push(
+				`import { getServerProps as ${gspId} } from "${importPathPrefix}/${r.importPath}";`,
+			);
+		}
+	}
+
+	// For SSR: import metadata and generateMetadata from pages that export them
+	const metaImports: string[] = [];
+	const metaRoutes = routes.filter(r => r.hasMetadata);
+	const genMetaRoutes = routes.filter(r => r.hasGenerateMetadata);
+	if (isServer) {
+		for (const r of metaRoutes) {
+			const metaId = "meta_" + r.componentId.replace("Page_", "");
+			metaImports.push(
+				`import { metadata as ${metaId} } from "${importPathPrefix}/${r.importPath}";`,
+			);
+		}
+		for (const r of genMetaRoutes) {
+			const genMetaId = "genMeta_" + r.componentId.replace("Page_", "");
+			metaImports.push(
+				`import { generateMetadata as ${genMetaId} } from "${importPathPrefix}/${r.importPath}";`,
+			);
+		}
+	}
+
+	// For SSR: import metadata and generateMetadata from layout files
+	const layoutImports: string[] = [];
+	if (isServer) {
+		for (const l of layouts) {
+			if (l.hasMetadata) {
+				const metaId = "layoutMeta_" + l.layoutId;
+				layoutImports.push(
+					`import { metadata as ${metaId} } from "${importPathPrefix}/${l.importPath}";`,
+				);
+			}
+			if (l.hasGenerateMetadata) {
+				const genMetaId = "layoutGenMeta_" + l.layoutId;
+				layoutImports.push(
+					`import { generateMetadata as ${genMetaId} } from "${importPathPrefix}/${l.importPath}";`,
+				);
+			}
+		}
+	}
+
 	const hasApp = fs.existsSync(path.join(PAGES_DIR, "_app.tsx"));
 	const hasDoc = fs.existsSync(path.join(PAGES_DIR, "_document.tsx"));
 
@@ -153,16 +343,123 @@ function generateRouteFile(
 			: `import { DefaultDocument } from "${importPathPrefix}/../shared/DefaultDocument";\nexport const Document = DefaultDocument;`;
 	}
 
+	// Import loading components (client-side only)
+	const loadingImports: string[] = [];
+	const loadingRoutes = routes.filter(r => r.hasLoading);
+	if (!isServer && loadingRoutes.length > 0) {
+		for (const r of loadingRoutes) {
+			const loadingId = "Loading_" + r.componentId.replace("Page_", "");
+			loadingImports.push(
+				`import ${loadingId} from "${importPathPrefix}/${r.loadingImportPath}";`,
+			);
+		}
+	}
+
 	const routeObjects = routes.map(r => {
 		const keysArray = r.keys.length > 0 ? `["${r.keys.join('", "')}"]` : "[]";
+		const loadingId = r.hasLoading ? "Loading_" + r.componentId.replace("Page_", "") : null;
+		const loadingLine = !isServer && loadingId ? `,\n\t\tloading: ${loadingId}` : "";
 		return `\t{
 \t\tpath: "${r.route}",
 \t\tpattern: new RegExp("${r.patternStr.replace(/\\/g, '\\\\')}"),
 \t\tkeys: ${keysArray},
-\t\tcomponent: ${r.componentId}
+\t\tcomponent: ${r.componentId}${loadingLine}
 \t}`;
 	});
 
+	// Generate serverPropsMap for SSR routes
+	let serverPropsMapStr = "";
+	if (isServer && gspRoutes.length > 0) {
+		const entries = gspRoutes.map(r => {
+			const gspId = "gsp_" + r.componentId.replace("Page_", "");
+			return `\t"${r.route}": ${gspId},`;
+		});
+		serverPropsMapStr = [
+			"",
+			"// Map of routes that export getServerProps",
+			"// Used by the SSR server to run data fetching before rendering",
+			"export const serverPropsMap: Record<string, Function> = {",
+			...entries,
+			"};",
+		].join("\n");
+	} else if (isServer) {
+		serverPropsMapStr = "\nexport const serverPropsMap: Record<string, Function> = {};";
+	}
+
+	// Generate metadataMap and generateMetadataMap for SSR routes
+	let metadataMapStr = "";
+	if (isServer) {
+		// Static metadata map
+		if (metaRoutes.length > 0) {
+			const entries = metaRoutes.map(r => {
+				const metaId = "meta_" + r.componentId.replace("Page_", "");
+				return `\t"${r.route}": ${metaId},`;
+			});
+			metadataMapStr += [
+				"",
+				"// Map of routes with static metadata exports",
+				"export const metadataMap: Record<string, any> = {",
+				...entries,
+				"};",
+			].join("\n");
+		} else {
+			metadataMapStr += "\nexport const metadataMap: Record<string, any> = {};";
+		}
+
+		// Dynamic generateMetadata map
+		if (genMetaRoutes.length > 0) {
+			const entries = genMetaRoutes.map(r => {
+				const genMetaId = "genMeta_" + r.componentId.replace("Page_", "");
+				return `\t"${r.route}": ${genMetaId},`;
+			});
+			metadataMapStr += [
+				"",
+				"// Map of routes with dynamic generateMetadata exports",
+				"export const generateMetadataMap: Record<string, Function> = {",
+				...entries,
+				"};",
+			].join("\n");
+		} else {
+			metadataMapStr += "\nexport const generateMetadataMap: Record<string, Function> = {};";
+		}
+
+		// Layout static metadata map
+		const layoutMetaEntries = layouts.filter(l => l.hasMetadata);
+		if (layoutMetaEntries.length > 0) {
+			const entries = layoutMetaEntries.map(l => {
+				const metaId = "layoutMeta_" + l.layoutId;
+				return `\t"${l.routePrefix}": ${metaId},`;
+			});
+			metadataMapStr += [
+				"",
+				"// Layout metadata — cascades to all child pages in the directory",
+				"export const layoutMetadataMap: Record<string, any> = {",
+				...entries,
+				"};",
+			].join("\n");
+		} else {
+			metadataMapStr += "\nexport const layoutMetadataMap: Record<string, any> = {};";
+		}
+
+		// Layout dynamic generateMetadata map
+		const layoutGenMetaEntries = layouts.filter(l => l.hasGenerateMetadata);
+		if (layoutGenMetaEntries.length > 0) {
+			const entries = layoutGenMetaEntries.map(l => {
+				const genMetaId = "layoutGenMeta_" + l.layoutId;
+				return `\t"${l.routePrefix}": ${genMetaId},`;
+			});
+			metadataMapStr += [
+				"",
+				"// Layout dynamic metadata — cascades to all child pages",
+				"export const layoutGenerateMetadataMap: Record<string, Function> = {",
+				...entries,
+				"};",
+			].join("\n");
+		} else {
+			metadataMapStr += "\nexport const layoutGenerateMetadataMap: Record<string, Function> = {};";
+		}
+	}
+
 	const map = [
 		"",
 		"export interface RouteDef {",
@@ -170,6 +467,7 @@ function generateRouteFile(
 		"\tpattern: RegExp;",
 		"\tkeys: string[];",
 		"\tcomponent: React.ComponentType<any>;",
+		"\tloading?: React.ComponentType<any>;",
 		"}",
 		"",
 		"export const routes: RouteDef[] = [",
@@ -178,10 +476,12 @@ function generateRouteFile(
 		"",
 		appImport,
 		docImport,
+		serverPropsMapStr,
+		metadataMapStr,
 		"",
 	];
 
-	return [...header, ...imports, ...map].join("\n");
+	return [...header, ...imports, ...gspImports, ...metaImports, ...layoutImports, ...loadingImports, ...map].join("\n");
 }
 
 function main() {
@@ -189,31 +489,79 @@ function main() {
 	console.log(`   Scanning: ${PAGES_DIR}`);
 
 	const routes = discoverPages();
+	const layouts = scanLayouts(PAGES_DIR);
 
 	if (routes.length === 0) {
 		console.error("   ❌ No pages found!");
 		process.exit(1);
 	}
 
+	// Print detected layouts
+	if (layouts.length > 0) {
+		console.log(`   Found ${layouts.length} layout(s) with metadata:`);
+		for (const l of layouts) {
+			const tags: string[] = [];
+			if (l.hasMetadata) tags.push("metadata");
+			if (l.hasGenerateMetadata) tags.push("generateMetadata");
+			const scope = l.routePrefix === "/" ? "(all pages)" : `(${l.routePrefix}/*)` ;
+			console.log(`     📐 ${l.importPath}.tsx [${tags.join(", ")}] ${scope}`);
+		}
+	}
+
 	console.log(`   Found ${routes.length} route(s):`);
 	for (const r of routes) {
-		console.log(`     ${r.route.padEnd(25)} → ${r.importPath}.tsx`);
+		const tags: string[] = [];
+		if (r.hasGetServerProps) tags.push("getServerProps");
+		if (r.hasMetadata) tags.push("metadata");
+		if (r.hasGenerateMetadata) tags.push("generateMetadata");
+		if (r.hasLoading) tags.push("loading");
+		if (r.isStatic) tags.push("ssg");
+		const tagStr = tags.length > 0 ? ` [${tags.join(", ")}]` : "";
+		console.log(`     ${r.route.padEnd(25)} → ${r.importPath}.tsx${tagStr}`);
 	}
 
 	// Generate SSR routes (node-ssr/ → ../app/pages)
-	const ssrContent = generateRouteFile(routes, "../app/pages", true);
+	const ssrContent = generateRouteFile(routes, layouts, "../app/pages", true);
 	fs.mkdirSync(path.dirname(SSR_OUTPUT), { recursive: true });
 	fs.writeFileSync(SSR_OUTPUT, ssrContent, "utf-8");
 	console.log(`   ✅ Written: ${path.relative(process.cwd(), SSR_OUTPUT)}`);
 
 	// Generate Client routes (app/client/ → ../pages)
-	const clientContent = generateRouteFile(routes, "../pages", false);
+	const clientContent = generateRouteFile(routes, layouts, "../pages", false);
 	fs.mkdirSync(path.dirname(CLIENT_OUTPUT), { recursive: true });
 	fs.writeFileSync(CLIENT_OUTPUT, clientContent, "utf-8");
 	console.log(
 		`   ✅ Written: ${path.relative(process.cwd(), CLIENT_OUTPUT)}`,
 	);
 
+	// Generate API routes (app/api/ → node-ssr/generated-api-routes.ts)
+	console.log("   →  Scanning API routes...");
+	const apiRoutes = generateAPIRoutes();
+	if (apiRoutes.length > 0) {
+		console.log(`   Found ${apiRoutes.length} API route(s):`);
+		for (const r of apiRoutes) {
+			console.log(`     ${r.methods.join("|").padEnd(20)} ${r.route}`);
+		}
+		console.log(`   ✅ Written: node-ssr/generated-api-routes.ts`);
+	} else {
+		console.log("   No API routes found (app/api/ is empty or missing)");
+	}
+
+	// Write SSG manifest for the build step
+	const ssgRoutes = routes.filter(r => r.isStatic);
+	if (ssgRoutes.length > 0) {
+		const ssgManifest = {
+			pages: ssgRoutes.map(r => ({
+				route: r.route,
+				componentId: r.componentId,
+				hasGetServerProps: r.hasGetServerProps,
+			}))
+		};
+		fs.mkdirSync("dist", { recursive: true });
+		fs.writeFileSync("dist/ssg-manifest.json", JSON.stringify(ssgManifest, null, 2));
+		console.log(`   📄 SSG: ${ssgRoutes.length} page(s) will be pre-rendered at build time`);
+	}
+
 	console.log("   🎉 Routes generated successfully!");
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blumenjs",
-	"version": "0.1.7",
+	"version": "0.2.1",
 	"description": "The React framework powered by Go. Lightning-fast SSR with the DX you deserve.",
 	"type": "module",
 	"bin": {
@@ -26,9 +26,9 @@
 		"dev:legacy": "npm run routes && concurrently \"npm run dev:client\" \"npm run dev:ssr\" \"npm run dev:go\"",
 		"dev:client": "webpack serve --mode development",
 		"dev:ssr": "NODE_ENV=development tsx watch node-ssr/server.ts",
-		"dev:go": "go run go-server/main.go",
+		"dev:go": "go run go-server/main.go go-server/image.go go-server/cache.go",
 		"build:client": "webpack --mode production",
-		"build:ssr": "esbuild node-ssr/server.ts --bundle --platform=node --format=esm --outfile=dist/ssr-server.js --external:react --external:react-dom",
+		"build:ssr": "esbuild node-ssr/server.ts --bundle --platform=node --format=esm --outfile=dist/ssr-server.js --packages=external",
 		"clean": "rm -rf dist static/js/bundle.js"
 	},
 	"keywords": [
@@ -49,9 +49,11 @@
 	},
 	"homepage": "",
 	"dependencies": {
-		"lucide-react": "^1.14.0",
-		"react": "^18.2.0",
-		"react-dom": "^18.2.0"
+		"lucide-react": "^1.14.0"
+	},
+	"peerDependencies": {
+		"react": "^18.2.0 || ^19.0.0",
+		"react-dom": "^18.2.0 || ^19.0.0"
 	},
 	"devDependencies": {
 		"@babel/core": "^7.29.0",
@@ -64,12 +66,16 @@
 		"@types/react-dom": "^18.2.0",
 		"babel-loader": "^10.1.1",
 		"concurrently": "^8.2.2",
+		"css-loader": "^7.1.4",
 		"esbuild": "^0.19.0",
+		"mini-css-extract-plugin": "^2.10.2",
 		"react-refresh": "^0.18.0",
+		"style-loader": "^4.0.0",
 		"ts-loader": "^9.5.1",
 		"tsx": "^4.6.0",
 		"typescript": "^5.3.0",
 		"webpack": "^5.89.0",
+		"webpack-bundle-analyzer": "^5.3.0",
 		"webpack-cli": "^5.1.4",
 		"webpack-dev-server": "^5.2.3"
 	},