gofront 1.0.0 → 1.1.0

package/src/compiler.js

@@ -1,9 +1,11 @@
-// Multi-file GoFront package compiler.
+// GoFront package compiler.
 //
-// compileDir(dir, options)   — compile all *.go in a directory as one package
-// compileFiles(files, options) — compile an explicit list of .go files
+// compileSingleFile(path, options) — compile one .go file
+// compileDir(dir, options)         — compile all *.go in a directory as one package
+// compileFiles(files, options)     — compile an explicit list of .go files
 //
-// Both return:
+// compileSingleFile returns: { js } (or { tokens } / { ast } for debug modes)
+// compileDir / compileFiles return:
 //   {
 //     pkgName:         string,
 //     js:              string,          // generated JS bundle (may include dep preamble)
@@ -146,6 +148,63 @@ export function resolveImports(
 
 // ── Main entry points ─────────────────────────────────────────
 
+export function compileSingleFile(inputPath, options = {}) {
+	const {
+		sourceMap = false,
+		outputFile = null,
+		dumpTokens = false,
+		dumpAst = false,
+	} = options;
+
+	let source;
+	try {
+		source = readFileSync(inputPath, "utf8");
+	} catch (e) {
+		throw new Error(`cannot read '${inputPath}': ${e.message}`);
+	}
+
+	const tokens = new Lexer(source, basename(inputPath)).tokenize();
+	if (dumpTokens) return { tokens };
+
+	const ast = new Parser(tokens, basename(inputPath), source).parse();
+	ast._source = source;
+	if (dumpAst) return { ast };
+
+	const checker = new TypeChecker();
+	const jsImports = new Map();
+	const bundledPackages = new Set();
+	const preambles = [];
+
+	resolveImports(
+		[ast],
+		inputPath,
+		checker,
+		jsImports,
+		bundledPackages,
+		preambles,
+	);
+
+	const errors = checker.check(ast);
+	checker.reportUnusedImports();
+	if (errors.length > 0) {
+		throw new Error(errors.map((e) => e.message).join("\n"));
+	}
+
+	const cg = new CodeGen(checker, jsImports, bundledPackages);
+	let js = cg.generate(ast);
+
+	if (sourceMap) {
+		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
+		const srcPath = relative(outputDir, inputPath);
+		const map = cg.getSourceMap(srcPath, [source]);
+		const b64 = Buffer.from(map).toString("base64");
+		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
+	}
+
+	const output = preambles.length > 0 ? `${preambles.join("\n")}\n${js}` : js;
+	return { js: output };
+}
+
 export function compileDir(dir, options = {}) {
 	const files = gwFilesIn(dir);
 	if (files.length === 0) throw new Error(`No .go files found in ${dir}`);

package/src/dev-server.js

@@ -1,11 +1,11 @@
 // Minimal dev server for gofront --serve watch mode.
 // Serves static files and pushes a reload event via SSE after each build.
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { createServer } from "node:http";
-import { extname, join } from "node:path";
+import { extname, join, resolve } from "node:path";
 
-const MIME = {
+export const MIME = {
 	".html": "text/html; charset=utf-8",
 	".js": "application/javascript; charset=utf-8",
 	".css": "text/css; charset=utf-8",
@@ -22,42 +22,97 @@ const MIME = {
 // Injected at the bottom of compiled JS in serve mode.
 export const liveReloadClient = `(function(){var es=new EventSource('/_gofront/events');es.addEventListener('reload',function(){location.reload();});})();`;
 
-export function createDevServer(serveDir, port) {
-	const clients = new Set();
+export function handleDevRequest(req, res, serveDir, clients = new Set()) {
+	// SSE endpoint — browser connects here to receive reload events
+	if (req.url === "/_gofront/events") {
+		res.writeHead(200, {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+		});
+		res.write(": connected\n\n");
+		clients.add(res);
+		req.on?.("close", () => clients.delete(res));
+		return;
+	}
 
-	const server = createServer((req, res) => {
-		// SSE endpoint — browser connects here to receive reload events
-		if (req.url === "/_gofront/events") {
-			res.writeHead(200, {
-				"Content-Type": "text/event-stream",
-				"Cache-Control": "no-cache",
-				Connection: "keep-alive",
-			});
-			res.write(": connected\n\n");
-			clients.add(res);
-			req.on("close", () => clients.delete(res));
-			return;
-		}
+	let urlPath = req.url.split("?")[0].split("#")[0];
+	try {
+		urlPath = decodeURIComponent(urlPath);
+	} catch {
+		// Ignore malformed URL encoding and use raw path
+	}
+
+	if (urlPath === "/" || urlPath === "") urlPath = "/index.html";
 
-		let urlPath = req.url.split("?")[0];
-		if (urlPath === "/" || urlPath === "") urlPath = "/index.html";
+	const resolvedServe = resolve(serveDir);
+	const filePath = resolve(serveDir, `.${urlPath}`);
+	if (!filePath.startsWith(resolvedServe)) {
+		res.writeHead(403, { "Content-Type": "text/plain" });
+		res.end("Forbidden");
+		return;
+	}
+
+	if (!existsSync(filePath)) {
+		// SPA fallback: clean paths with no file extension fall back to index.html
+		const ext = extname(urlPath);
+		if (!ext) {
+			const indexPath = join(serveDir, "index.html");
+			if (existsSync(indexPath)) {
+				try {
+					const data = readFileSync(indexPath);
+					res.writeHead(200, { "Content-Type": MIME[".html"] });
+					res.end(data);
+					return;
+				} catch {
+					res.writeHead(500, { "Content-Type": "text/plain" });
+					res.end("Server error");
+					return;
+				}
+			}
+		}
+		res.writeHead(404, { "Content-Type": "text/plain" });
+		res.end("Not found");
+		return;
+	}
 
-		const filePath = join(serveDir, urlPath);
-		if (!existsSync(filePath)) {
+	try {
+		const stat = statSync(filePath);
+		if (stat.isDirectory()) {
+			const dirIndex = join(filePath, "index.html");
+			if (existsSync(dirIndex)) {
+				const data = readFileSync(dirIndex);
+				res.writeHead(200, { "Content-Type": MIME[".html"] });
+				res.end(data);
+				return;
+			}
+			const rootIndex = join(serveDir, "index.html");
+			if (existsSync(rootIndex)) {
+				const data = readFileSync(rootIndex);
+				res.writeHead(200, { "Content-Type": MIME[".html"] });
+				res.end(data);
+				return;
+			}
 			res.writeHead(404, { "Content-Type": "text/plain" });
 			res.end("Not found");
 			return;
 		}
 
-		try {
-			const data = readFileSync(filePath);
-			const mime = MIME[extname(filePath)] ?? "application/octet-stream";
-			res.writeHead(200, { "Content-Type": mime });
-			res.end(data);
-		} catch {
-			res.writeHead(500, { "Content-Type": "text/plain" });
-			res.end("Server error");
-		}
+		const data = readFileSync(filePath);
+		const mime = MIME[extname(filePath)] ?? "application/octet-stream";
+		res.writeHead(200, { "Content-Type": mime });
+		res.end(data);
+	} catch {
+		res.writeHead(500, { "Content-Type": "text/plain" });
+		res.end("Server error");
+	}
+}
+
+export function createDevServer(serveDir, port = 3000) {
+	const clients = new Set();
+
+	const server = createServer((req, res) => {
+		handleDevRequest(req, res, serveDir, clients);
 	});
 
 	server.on("error", (err) => {
@@ -70,8 +125,12 @@ export function createDevServer(serveDir, port) {
 		}
 		process.exit(1);
 	});
+
 	server.listen(port, () => {
-		console.error(`gofront: dev server → http://localhost:${port}`);
+		const actualPort = server.address()?.port ?? port;
+		if (port !== 0) {
+			console.error(`gofront: dev server → http://localhost:${actualPort}`);
+		}
 	});
 
 	function notify() {
@@ -80,5 +139,9 @@ export function createDevServer(serveDir, port) {
 		}
 	}
 
-	return { notify };
+	return {
+		notify,
+		server,
+		close: () => new Promise((res) => server.close(res)),
+	};
 }

package/src/index.js

@@ -13,27 +13,16 @@
 //   gofront <file.go> --tokens     — dump tokens of first file (debug)
 //   gofront init [dir]             — scaffold a new GoFront project
 
-import {
-	existsSync,
-	mkdirSync,
-	readFileSync,
-	statSync,
-	watch,
-	writeFileSync,
-} from "node:fs";
 import { createRequire } from "node:module";
 
 const _require = createRequire(import.meta.url);
 const { version } = _require("../package.json");
 
-import { basename, dirname, join, relative, resolve } from "node:path";
-import { CodeGen } from "./codegen/index.js";
-import { compileDir, resolveImports } from "./compiler.js";
+import { mkdirSync, statSync, watch, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { copyAssets } from "./asset-manager.js";
+import { handleInit, handlePrep, maybeMinify, runCompile } from "./cli-core.js";
 import { createDevServer, liveReloadClient } from "./dev-server.js";
-import { Lexer } from "./lexer.js";
-import { minify } from "./minifier.js";
-import { Parser } from "./parser/index.js";
-import { TypeChecker } from "./typechecker/index.js";
 
 // ── Parse CLI args ───────────────────────────────────────────
 
@@ -56,11 +45,13 @@ Usage:
   gofront <input> --watch        Watch for changes and recompile
   gofront <input> -o out.js --serve          Watch + serve with live reload (default port 3000)
   gofront <input> -o out.js --serve --port 8080  Use a custom port
+  gofront <input> -o out.js --copy-assets    Compile and synchronize static assets
   gofront <input> --source-map   Append inline source map to output
   gofront <input> --minify       Minify output
   gofront <input> --minify --mangle  Minify and mangle identifiers
   gofront <file.go> --ast        Dump AST (debug)
   gofront <file.go> --tokens     Dump tokens (debug)
+  gofront prep [dir]             Copy static assets and bundle vendor dependencies
   gofront init [dir]             Scaffold a new GoFront project
   gofront --version              Print version
 `.trim(),
@@ -68,45 +59,42 @@ Usage:
 	process.exit(0);
 }
 
-// ── init subcommand ──────────────────────────────────────────
+// ── prep / vendor subcommand ──────────────────────────────────
 
-if (args[0] === "init") {
+if (args[0] === "prep" || args[0] === "vendor") {
 	const targetArg = args[1] ?? ".";
 	const targetDir = resolve(targetArg);
-
-	if (targetArg !== ".") {
-		try {
-			mkdirSync(targetDir, { recursive: true });
-		} catch (e) {
-			console.error(`gofront: cannot create '${targetArg}': ${e.message}`);
-			process.exit(1);
+	try {
+		const { assets, vendor } = await handlePrep(targetDir);
+		if (assets.copied > 0 || assets.skipped > 0) {
+			console.error(
+				`gofront: copied ${assets.copied} assets (${assets.skipped} skipped)`,
+			);
 		}
-	}
-
-	const mainPath = join(targetDir, "main.go");
-	if (existsSync(mainPath)) {
-		console.error(`gofront: ${mainPath} already exists — nothing written`);
+		if (vendor.bundled?.length > 0) {
+			console.error(
+				`gofront: bundled ${vendor.bundled.length} vendor dependencies → ${vendor.dest}`,
+			);
+		}
+	} catch (e) {
+		console.error(`gofront: ${e.message}`);
 		process.exit(1);
 	}
+	process.exit(0);
+}
 
-	const pkgName =
-		targetArg === "." ? basename(resolve(".")) : basename(targetDir);
-	// package names must be valid identifiers
-	const safePkg = pkgName.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^[0-9]/, "_");
-
-	const template = `package ${safePkg}
+// ── init subcommand ──────────────────────────────────────────
 
-func main() {
-\tconsole.log("Hello from GoFront!")
-}
-`;
+if (args[0] === "init") {
+	const targetArg = args[1] ?? ".";
+	const targetDir = resolve(targetArg);
+	let mainPath;
 	try {
-		writeFileSync(mainPath, template);
+		({ mainPath } = handleInit(targetDir));
 	} catch (e) {
-		console.error(`gofront: cannot write '${mainPath}': ${e.message}`);
+		console.error(`gofront: ${e.message}`);
 		process.exit(1);
 	}
-
 	console.error(`gofront: created ${mainPath}`);
 	console.error(
 		`gofront: run  gofront ${targetArg === "." ? "main.go" : `${targetArg}/main.go`}  to compile`,
@@ -123,6 +111,7 @@ const dumpTokens = args.includes("--tokens");
 const sourceMap = args.includes("--source-map");
 const serveMode = args.includes("--serve");
 const watchMode = args.includes("--watch") || serveMode;
+const copyAssetsFlag = args.includes("--copy-assets");
 const minifyOutput = args.includes("--minify");
 const mangleOutput = args.includes("--mangle");
 const portFlag = args.indexOf("--port");
@@ -139,95 +128,32 @@ try {
 	process.exit(1);
 }
 
-// ── Compile function (used for initial build and re-builds) ──
-
-function runCompile() {
-	if (isDir) {
-		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
-		return compileDir(inputPath, { sourceMap, outputDir });
-	}
-
-	// Single-file mode
-	let source;
-	try {
-		source = readFileSync(inputPath, "utf8");
-	} catch (e) {
-		throw new Error(`cannot read '${inputArg}': ${e.message}`);
-	}
-
-	const tokens = new Lexer(source, basename(inputPath)).tokenize();
-
-	if (dumpTokens) {
-		for (const tok of tokens) console.log(tok.toString());
-		process.exit(0);
-	}
-
-	const ast = new Parser(tokens, basename(inputPath), source).parse();
-	ast._source = source;
-
-	if (dumpAst) {
-		console.log(JSON.stringify(ast, null, 2));
-		process.exit(0);
-	}
-
-	const checker = new TypeChecker();
-	const jsImports = new Map();
-	const bundledPackages = new Set();
-	const preambles = [];
-
-	resolveImports(
-		[ast],
-		inputPath,
-		checker,
-		jsImports,
-		bundledPackages,
-		preambles,
-	);
-
-	const errors = checker.check(ast);
-	checker.reportUnusedImports();
-	if (errors.length > 0) {
-		throw new Error(errors.map((e) => e.message).join("\n"));
-	}
-
-	const cg = new CodeGen(checker, jsImports, bundledPackages);
-	let js = cg.generate(ast);
-
-	if (sourceMap) {
-		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
-		const srcPath = relative(outputDir, inputPath);
-		const map = cg.getSourceMap(srcPath, [source]);
-		const b64 = Buffer.from(map).toString("base64");
-		js += `\n//# sourceMappingURL=data:application/json;base64,${b64}`;
-	}
-
-	const output = preambles.length > 0 ? `${preambles.join("\n")}\n${js}` : js;
-	return { js: output };
-}
-
-// ── Minify helper ────────────────────────────────────────────
-
-function maybeMinify(js) {
-	if (!minifyOutput) return js;
-	if (sourceMap) {
-		console.error("gofront: --source-map and --minify cannot be used together");
-		process.exit(1);
-	}
-	return minify(js, { mangle: mangleOutput });
-}
-
 // ── Single-shot mode ─────────────────────────────────────────
 
 if (!watchMode) {
 	let result;
 	const startMs = performance.now();
 	try {
-		result = runCompile();
+		result = runCompile(inputPath, isDir, {
+			sourceMap,
+			outputFile,
+			dumpTokens,
+			dumpAst,
+		});
 	} catch (e) {
 		console.error(`gofront: ${e.message}`);
 		process.exit(1);
 	}
 
+	if (result.tokens) {
+		for (const tok of result.tokens) console.log(tok.toString());
+		process.exit(0);
+	}
+	if (result.ast) {
+		console.log(JSON.stringify(result.ast, null, 2));
+		process.exit(0);
+	}
+
 	if (checkOnly) {
 		const elapsedMs = (performance.now() - startMs).toFixed(0);
 		console.error(`gofront: ${inputArg} — OK (${elapsedMs}ms)`);
@@ -236,7 +162,11 @@ if (!watchMode) {
 
 	let js;
 	try {
-		js = maybeMinify(result.js);
+		js = maybeMinify(result.js, {
+			minify: minifyOutput,
+			mangle: mangleOutput,
+			sourceMap,
+		});
 	} catch (e) {
 		console.error(`gofront: minify failed: ${e.message}`);
 		process.exit(1);
@@ -246,6 +176,7 @@ if (!watchMode) {
 
 	if (outputFile) {
 		try {
+			mkdirSync(dirname(resolve(outputFile)), { recursive: true });
 			writeFileSync(outputFile, `${js}\n`);
 			console.error(`gofront: wrote ${outputFile} (${elapsedMs}ms)`);
 		} catch (e) {
@@ -255,6 +186,19 @@ if (!watchMode) {
 	} else {
 		console.log(js);
 	}
+
+	if (copyAssetsFlag) {
+		try {
+			const projectDir = resolve(".");
+			const { copied, skipped } = copyAssets(projectDir);
+			if (copied > 0 || skipped > 0) {
+				console.error(`gofront: copied ${copied} assets (${skipped} skipped)`);
+			}
+		} catch (e) {
+			console.error(`gofront: asset copy failed: ${e.message}`);
+		}
+	}
+
 	process.exit(0);
 }
 
@@ -278,8 +222,12 @@ if (serveMode) {
 function buildOnce(changedFile = null) {
 	try {
 		const startMs = performance.now();
-		const result = runCompile();
-		let js = maybeMinify(result.js);
+		const result = runCompile(inputPath, isDir, { sourceMap, outputFile });
+		let js = maybeMinify(result.js, {
+			minify: minifyOutput,
+			mangle: mangleOutput,
+			sourceMap,
+		});
 		if (serveMode) {
 			// Insert live reload client before the source map comment so it stays last
 			const smIdx = js.lastIndexOf("\n//# sourceMappingURL=");
@@ -304,6 +252,15 @@ function buildOnce(changedFile = null) {
 				`[${timestamp()}] gofront: OK (${elapsedMs}ms${changeNote})`,
 			);
 		}
+
+		if (copyAssetsFlag) {
+			try {
+				copyAssets(resolve("."));
+			} catch (e) {
+				console.error(`gofront: asset copy failed: ${e.message}`);
+			}
+		}
+
 		devServer?.notify();
 	} catch (e) {
 		console.error(`[${timestamp()}] gofront: ERROR`);