gofront 1.0.1 → 1.2.0

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

@@ -18,9 +18,16 @@ import { createRequire } from "node:module";
 const _require = createRequire(import.meta.url);
 const { version } = _require("../package.json");
 
-import { statSync, watch, writeFileSync } from "node:fs";
+import { mkdirSync, statSync, watch, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { handleInit, maybeMinify, runCompile } from "./cli-core.js";
+import { copyAssets } from "./asset-manager.js";
+import {
+	handleInit,
+	handlePrep,
+	handleTest,
+	maybeMinify,
+	runCompile,
+} from "./cli-core.js";
 import { createDevServer, liveReloadClient } from "./dev-server.js";
 
 // ── Parse CLI args ───────────────────────────────────────────
@@ -44,11 +51,14 @@ 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 test [dir] [--dom]     Run unit tests (-v verbose, -run <regex>)
+  gofront prep [dir] [--minify]  Copy static assets and bundle vendor dependencies
   gofront init [dir]             Scaffold a new GoFront project
   gofront --version              Print version
 `.trim(),
@@ -56,6 +66,39 @@ Usage:
 	process.exit(0);
 }
 
+// ── prep / vendor subcommand ──────────────────────────────────
+
+if (args[0] === "prep" || args[0] === "vendor") {
+	const hasMinify = args.includes("--minify");
+	const filteredArgs = args.slice(1).filter((a) => !a.startsWith("--"));
+	const targetArg = filteredArgs[0] ?? ".";
+	const targetDir = resolve(targetArg);
+	try {
+		const vendorConfig = hasMinify ? { minify: true } : {};
+		const { assets, vendor } = await handlePrep(targetDir, {
+			vendorConfig,
+		});
+		if (assets.copied > 0 || assets.skipped > 0) {
+			console.error(
+				`gofront: copied ${assets.copied} assets (${assets.skipped} skipped)`,
+			);
+		}
+		if (vendor.bundled?.length > 0) {
+			const destStr = Array.isArray(vendor.dest)
+				? vendor.dest.join(", ")
+				: vendor.dest;
+			const minStr = vendor.minify ? " (minified)" : "";
+			console.error(
+				`gofront: bundled ${vendor.bundled.length} vendor dependencies → ${destStr}${minStr}`,
+			);
+		}
+	} catch (e) {
+		console.error(`gofront: ${e.message}`);
+		process.exit(1);
+	}
+	process.exit(0);
+}
+
 // ── init subcommand ──────────────────────────────────────────
 
 if (args[0] === "init") {
@@ -75,6 +118,45 @@ if (args[0] === "init") {
 	process.exit(0);
 }
 
+// ── test subcommand ───────────────────────────────────────────
+
+if (args[0] === "test") {
+	const flags = args.slice(1);
+	let targetDir = ".";
+	let runFilter = null;
+	const nonFlagArgs = [];
+	for (let i = 0; i < flags.length; i++) {
+		const arg = flags[i];
+		if (arg === "-run" || arg === "--run") {
+			runFilter = flags[++i] ?? null;
+			continue;
+		}
+		if (arg.startsWith("-run=") || arg.startsWith("--run=")) {
+			runFilter = arg.slice(arg.indexOf("=") + 1);
+			continue;
+		}
+		if (arg.startsWith("-")) continue;
+		nonFlagArgs.push(arg);
+	}
+	if (nonFlagArgs.length > 0) {
+		targetDir = nonFlagArgs[0];
+	}
+	const verbose = flags.includes("-v");
+	const dom = flags.includes("--dom");
+
+	try {
+		const result = await handleTest(targetDir, {
+			verbose,
+			dom,
+			run: runFilter,
+		});
+		process.exit(result.exitCode);
+	} catch (e) {
+		console.error(`gofront: ${e.message}`);
+		process.exit(1);
+	}
+}
+
 const inputArg = args[0];
 const outputFlag = args.indexOf("-o");
 const outputFile = outputFlag !== -1 ? args[outputFlag + 1] : null;
@@ -84,6 +166,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");
@@ -148,6 +231,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) {
@@ -157,6 +241,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);
 }
 
@@ -210,6 +307,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`);

package/src/resolver.js

@@ -47,6 +47,7 @@ const BUILTIN_PACKAGES = new Set([
 	"regexp",
 	"path",
 	"path/filepath",
+	"testing",
 ]);
 
 // Returns true for local relative paths (start with ./ or ../)

package/src/test-runner.js

@@ -0,0 +1,335 @@
+// GoFront native test runner and harness generator.
+// Handles test function discovery, test harness emission, and subprocess execution.
+
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { basename, join, resolve } from "node:path";
+import { compilePackageTests, gwFilesIn } from "./compiler.js";
+
+export function isTestFunc(decl) {
+	if (decl.kind !== "FuncDecl") return false;
+	if (!decl.name.startsWith("Test")) return false;
+	if (decl.params?.length !== 1) return false;
+	const pType = decl.params[0].type;
+	if (pType?.kind === "PointerType" && pType.base?.name === "testing.T")
+		return true;
+	if (pType?.kind === "TypeName" && pType.name === "testing.T") return true;
+	return false;
+}
+
+export function discoverTests(programs) {
+	const testNames = [];
+	for (const p of programs) {
+		for (const d of p.decls) {
+			if (isTestFunc(d) && !testNames.includes(d.name)) {
+				testNames.push(d.name);
+			}
+		}
+	}
+	return testNames;
+}
+
+export function generateTestHarness(bundleJs, testNames, options = {}) {
+	const runRegex = options.run ? options.run : null;
+	const verbose = Boolean(options.verbose);
+	const dom = Boolean(options.dom);
+	const pkgName = options.pkgName ?? "main";
+
+	return `
+${
+	dom
+		? `import { JSDOM } from "jsdom";
+const __dom = new JSDOM("<!DOCTYPE html><html><body></body></html>", {
+  url: "http://localhost/",
+  pretendToBeVisual: true,
+});
+globalThis.window = __dom.window;
+globalThis.document = __dom.window.document;
+try {
+  Object.defineProperty(globalThis, "navigator", {
+    value: __dom.window.navigator,
+    configurable: true,
+    writable: true,
+  });
+} catch {
+  try { globalThis.navigator = __dom.window.navigator; } catch {}
+}
+globalThis.location = __dom.window.location;
+globalThis.history = __dom.window.history;
+globalThis.HTMLElement = __dom.window.HTMLElement;
+globalThis.Element = __dom.window.Element;
+globalThis.Node = __dom.window.Node;
+globalThis.customElements = __dom.window.customElements;
+`
+		: `globalThis.window = globalThis.window ?? null;
+globalThis.document = globalThis.document ?? null;
+`
+}
+globalThis.__gofront_verbose = ${verbose};
+
+// ── Compiled Package Bundle ──
+${bundleJs}
+// ─────────────────────────────
+
+async function __runGoFrontSuite() {
+  const allTests = ${JSON.stringify(testNames)};
+  const runFilter = ${runRegex ? `new RegExp(${JSON.stringify(runRegex)})` : "null"};
+  const verbose = ${verbose};
+  const pkgName = ${JSON.stringify(pkgName)};
+
+  const testsToRun = runFilter
+    ? allTests.filter((name) => runFilter.test(name))
+    : allTests;
+
+  if (testsToRun.length === 0) {
+    if (allTests.length > 0 && runFilter) {
+      console.log("testing: warning: no tests to run matching " + ${JSON.stringify(runRegex)});
+    }
+    console.log("PASS");
+    console.log("ok  \\t" + pkgName + "\\t0.000s");
+    process.exit(0);
+  }
+
+  let totalFailures = 0;
+  let totalSkipped = 0;
+  const suiteStart = typeof performance !== "undefined" ? performance.now() : Date.now();
+
+  globalThis.__onSubtestStart = (name) => {
+    if (verbose) {
+      console.log("=== RUN   " + name);
+    }
+  };
+
+  globalThis.__onSubtestEnd = (subT) => {
+    const elapsed = (((typeof performance !== "undefined" ? performance.now() : Date.now()) - subT._start) / 1000).toFixed(2);
+    if (subT.skipped) {
+      console.log("--- SKIP: " + subT._name + " (" + elapsed + "s)");
+      for (const log of subT._logs) {
+        console.log("    " + log);
+      }
+    } else if (subT.failed) {
+      if (!verbose) {
+        console.log("=== RUN   " + subT._name);
+      }
+      for (const log of subT._logs) {
+        console.log("    " + log);
+      }
+      console.log("--- FAIL: " + subT._name + " (" + elapsed + "s)");
+    } else if (verbose) {
+      for (const log of subT._logs) {
+        console.log("    " + log);
+      }
+      console.log("--- PASS: " + subT._name + " (" + elapsed + "s)");
+    }
+  };
+
+  const __testRegistry = {
+${testNames.map((n) => `    ${JSON.stringify(n)}: typeof ${n} !== "undefined" ? ${n} : null`).join(",\n")}
+  };
+
+  for (const name of testsToRun) {
+    const fn = __testRegistry[name] ?? (typeof globalThis[name] === "function" ? globalThis[name] : null);
+    if (typeof fn !== "function") {
+      console.error("testing: cannot find test function " + name);
+      totalFailures++;
+      continue;
+    }
+
+    const t = new __GoFront_T(name);
+    if (verbose) {
+      console.log("=== RUN   " + name);
+    }
+
+    try {
+      const res = fn(t);
+      if (res && typeof res.then === "function") {
+        await res;
+      }
+    } catch (e) {
+      if (e instanceof __GoFront_FailNow) {
+        // expected on FailNow
+      } else if (e instanceof __GoFront_SkipNow) {
+        // expected on SkipNow
+      } else {
+        t.Fail();
+        t.Log("panic: " + (e?.message ?? String(e)));
+      }
+    }
+
+    const elapsed = (((typeof performance !== "undefined" ? performance.now() : Date.now()) - t._start) / 1000).toFixed(2);
+
+    if (t.skipped) {
+      totalSkipped++;
+      console.log("--- SKIP: " + name + " (" + elapsed + "s)");
+      for (const log of t._logs) {
+        console.log("    " + log);
+      }
+    } else if (t.failed) {
+      totalFailures++;
+      if (!verbose) {
+        console.log("=== RUN   " + name);
+      }
+      for (const log of t._logs) {
+        console.log("    " + log);
+      }
+      console.log("--- FAIL: " + name + " (" + elapsed + "s)");
+    } else {
+      if (verbose) {
+        for (const log of t._logs) {
+          console.log("    " + log);
+        }
+        console.log("--- PASS: " + name + " (" + elapsed + "s)");
+      }
+    }
+  }
+
+  const suiteElapsed = (((typeof performance !== "undefined" ? performance.now() : Date.now()) - suiteStart) / 1000).toFixed(3);
+
+  if (totalFailures > 0) {
+    console.log("FAIL");
+    console.log("FAIL\\t" + pkgName + "\\t" + suiteElapsed + "s");
+    process.exit(1);
+  } else {
+    console.log("PASS");
+    console.log("ok  \\t" + pkgName + "\\t" + suiteElapsed + "s");
+    process.exit(0);
+  }
+}
+
+__runGoFrontSuite();
+`;
+}
+
+function validateTestOptions(options, resolvedDir) {
+	if (options.run) {
+		try {
+			new RegExp(options.run);
+		} catch (e) {
+			throw new Error(`gofront: invalid regex for -run: ${e.message}`);
+		}
+	}
+
+	if (options.dom) {
+		let jsdomFound = false;
+		try {
+			const req = createRequire(join(resolvedDir, "dummy.js"));
+			req.resolve("jsdom");
+			jsdomFound = true;
+		} catch {}
+		if (!jsdomFound) {
+			try {
+				const req = createRequire(import.meta.url);
+				req.resolve("jsdom");
+				jsdomFound = true;
+			} catch {}
+		}
+		if (!jsdomFound) {
+			throw new Error(
+				"gofront: --dom requires 'jsdom' to be installed. Run 'npm install --save-dev jsdom' to enable DOM testing.",
+			);
+		}
+	}
+}
+
+function reportEmptyTests(label, reason, options) {
+	const out = `?   \t${label}\t[${reason}]\n`;
+	if (options.captureOutput) {
+		return { exitCode: 0, stdout: out, stderr: "", noTests: true };
+	}
+	const dest = options.stdout ?? process.stdout;
+	dest.write(out);
+	return { exitCode: 0, noTests: true };
+}
+
+function spawnTestRunner(resolvedDir, harnessJs, testCount, options) {
+	return new Promise((resolvePromise, rejectPromise) => {
+		const child = spawn(process.execPath, ["--input-type=module", "-"], {
+			cwd: resolvedDir,
+			env: process.env,
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+
+		let stdout = "";
+		let stderr = "";
+
+		child.stdout.on("data", (chunk) => {
+			const str = chunk.toString();
+			if (options.captureOutput) {
+				stdout += str;
+			} else {
+				(options.stdout ?? process.stdout).write(str);
+			}
+		});
+
+		child.stderr.on("data", (chunk) => {
+			const str = chunk.toString();
+			if (options.captureOutput) {
+				stderr += str;
+			} else {
+				(options.stderr ?? process.stderr).write(str);
+			}
+		});
+
+		child.on("error", (err) => {
+			rejectPromise(err);
+		});
+
+		child.on("close", (exitCode) => {
+			resolvePromise({
+				exitCode: exitCode ?? 0,
+				stdout,
+				stderr,
+				testCount,
+			});
+		});
+
+		child.stdin.on("error", () => {});
+		child.stdin.end(harnessJs);
+	});
+}
+
+export async function runTests(targetDir, options = {}) {
+	const resolvedDir = resolve(targetDir);
+	validateTestOptions(options, resolvedDir);
+
+	const allFiles = gwFilesIn(resolvedDir, { includeTests: true });
+	if (allFiles.length === 0) {
+		throw new Error(`No .go files found in ${targetDir}`);
+	}
+
+	const testFiles = allFiles.filter((f) => f.endsWith("_test.go"));
+	if (testFiles.length === 0) {
+		return reportEmptyTests(basename(resolvedDir), "no test files", options);
+	}
+
+	let compiled;
+	try {
+		compiled = compilePackageTests(resolvedDir, options);
+	} catch (err) {
+		const out = `FAIL\t${basename(resolvedDir)} [build failed]\n${err?.message ?? String(err)}\n`;
+		if (options.captureOutput) {
+			return { exitCode: 1, stdout: "", stderr: out };
+		}
+		const dest = options.stderr ?? process.stderr;
+		dest.write(out);
+		return { exitCode: 1 };
+	}
+
+	const { pkgName, js, programs } = compiled;
+	const testNames = discoverTests(programs);
+
+	if (testNames.length === 0) {
+		return reportEmptyTests(pkgName, "no tests to run", options);
+	}
+
+	const harnessJs = generateTestHarness(bundleJsClean(js), testNames, {
+		...options,
+		pkgName,
+	});
+
+	return spawnTestRunner(resolvedDir, harnessJs, testNames.length, options);
+}
+
+function bundleJsClean(js) {
+	return js;
+}

package/src/typechecker/index.js

@@ -225,7 +225,19 @@ export class TypeChecker {
 	_checkTopDeclsPass(programs) {
 		for (const p of programs) {
 			this._setCurrentFile(p);
-			for (const d of p.decls) this.checkTopDecl(d, this.globals);
+			for (const d of p.decls) {
+				if (d.kind === "VarDecl" || d.kind === "ConstDecl") {
+					this.checkTopDecl(d, this.globals);
+				}
+			}
+		}
+		for (const p of programs) {
+			this._setCurrentFile(p);
+			for (const d of p.decls) {
+				if (d.kind === "FuncDecl" || d.kind === "MethodDecl") {
+					this.checkTopDecl(d, this.globals);
+				}
+			}
 		}
 	}