gofront 1.2.2 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.2.2",
+	"version": "1.3.0",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {
@@ -35,16 +35,18 @@
 		"build:reactive": "node src/index.js example/reactive/src -o example/reactive/app.js",
 		"build:gom": "node src/index.js example/gom/src -o example/gom/app.js",
 		"build:templ": "node src/index.js example/templ/src -o example/templ/app.js",
-		"build:all": "npm run build:simple && npm run build:reactive && npm run build:gom && npm run build:templ",
+		"build:webgl": "node src/index.js example/webgl/src -o example/webgl/app.js",
+		"build:all": "npm run build:simple && npm run build:reactive && npm run build:gom && npm run build:templ && npm run build:webgl",
 		"test": "npm run test:unit",
-		"test:all": "npm run test:unit && npm run test:examples && npm run test:examples:dom && npm run test:e2e",
+		"test:all": "npm run test:unit && npm run test:perf && npm run test:examples && npm run test:examples:dom && npm run test:e2e",
 		"test:unit": "node test/unit/run.js",
+		"test:perf": "node test/e2e/perf/zero-alloc.js",
 		"test:examples": "node src/index.js test example/simple/src && node src/index.js test example/simple/src/utils && node src/index.js test example/reactive/src && node src/index.js test example/reactive/src/utils && node src/index.js test example/gom/src && node src/index.js test example/gom/src/utils && node src/index.js test example/templ/src && node src/index.js test example/templ/src/utils",
 		"test:examples:dom": "node src/index.js test --dom example/simple/src && node src/index.js test --dom example/gom/src && node src/index.js test --dom example/templ/src",
 		"test:coverage": "c8 --include='src/**' --reporter=text --reporter=lcov node test/unit/run.js",
 		"test:e2e": "npm run build:all && playwright test",
 		"format": "biome format --write .",
-		"check": "biome check . && sentrux check && sentrux gate && node src/index.js example/simple/src --check && node src/index.js example/reactive/src --check && node src/index.js example/gom/src --check && node src/index.js example/templ/src --check",
+		"check": "biome check . && sentrux check && sentrux gate && node src/index.js example/simple/src --check && node src/index.js example/reactive/src --check && node src/index.js example/gom/src --check && node src/index.js example/templ/src --check && node src/index.js example/webgl/src --check",
 		"prepare": "lefthook install"
 	},
 	"devDependencies": {

package/src/cli-core.js

@@ -1,11 +1,31 @@
 // CLI compilation core — extracted for direct import in tests.
 // index.js retains only arg parsing, file I/O, watch mode, and process.exit.
 
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
+import {
+	copyFileSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	rmSync,
+	statSync,
+	watch,
+	writeFileSync,
+} from "node:fs";
+import {
+	basename,
+	dirname,
+	isAbsolute,
+	join,
+	relative,
+	resolve,
+	sep,
+} from "node:path";
 import { copyAssets } from "./asset-manager.js";
 import { compileDir, compileSingleFile } from "./compiler.js";
+import { createDevServer } from "./dev-server.js";
 import { minify } from "./minifier.js";
+import { generatePwa } from "./pwa.js";
 import { runTests } from "./test-runner.js";
 import { bundleVendor } from "./vendor.js";
 
@@ -42,6 +62,84 @@ export function maybeMinify(js, options) {
 	return minify(js, { mangle });
 }
 
+function sanitizeProjectName(dirPath) {
+	const base = basename(resolve(dirPath));
+	const clean = base
+		.toLowerCase()
+		.replace(/[^a-z0-9_-]/g, "-")
+		.replace(/^[0-9_-]+/, "");
+	return clean || "gofront-app";
+}
+
+function checkScaffoldConflicts(targetDir, filePaths) {
+	const legacyMain = join(targetDir, "main.go");
+	const allToCheck = [...filePaths, legacyMain];
+	for (const p of allToCheck) {
+		if (existsSync(p)) {
+			throw new Error(`${p} already exists — nothing written`);
+		}
+	}
+}
+
+function getScaffoldTemplates(targetDir) {
+	const projName = sanitizeProjectName(targetDir);
+	const indexPath = join(targetDir, "app", "index.html");
+	const mainPath = join(targetDir, "app", "src", "main.go");
+	const gitignorePath = join(targetDir, ".gitignore");
+	const pkgPath = join(targetDir, "package.json");
+
+	const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${projName}</title>
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="app.js"></script>
+</body>
+</html>
+`;
+
+	const mainGo = `package main
+
+func main() {
+	console.log("Hello from GoFront!")
+}
+`;
+
+	const gitignore = `dist/
+public/
+app/vendor.js
+app/app.js
+node_modules/
+`;
+
+	const pkgJson = `${JSON.stringify(
+		{
+			name: projName,
+			type: "module",
+			scripts: {
+				dev: "gofront dev",
+				build: "gofront build",
+				test: "gofront test",
+				check: "gofront check",
+			},
+			dependencies: {},
+		},
+		null,
+		2,
+	)}\n`;
+
+	return [
+		{ path: indexPath, content: html },
+		{ path: mainPath, content: mainGo },
+		{ path: gitignorePath, content: gitignore },
+		{ path: pkgPath, content: pkgJson },
+	];
+}
+
 export function handleInit(targetDir) {
 	try {
 		mkdirSync(targetDir, { recursive: true });
@@ -49,22 +147,26 @@ export function handleInit(targetDir) {
 		throw new Error(`cannot create '${targetDir}': ${e.message}`);
 	}
 
-	const mainPath = join(targetDir, "main.go");
-	if (existsSync(mainPath)) {
-		throw new Error(`${mainPath} already exists — nothing written`);
-	}
-
-	const pkgName = basename(targetDir);
-	const safePkg = pkgName.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^[0-9]/, "_");
-	const template = `package ${safePkg}\n\nfunc main() {\n\tconsole.log("Hello from GoFront!")\n}\n`;
+	const templates = getScaffoldTemplates(targetDir);
+	checkScaffoldConflicts(
+		targetDir,
+		templates.map((t) => t.path),
+	);
 
-	try {
-		writeFileSync(mainPath, template);
-	} catch (e) {
-		throw new Error(`cannot write '${mainPath}': ${e.message}`);
+	for (const { path: filePath, content } of templates) {
+		try {
+			mkdirSync(dirname(filePath), { recursive: true });
+			writeFileSync(filePath, content);
+		} catch (e) {
+			throw new Error(`cannot write '${filePath}': ${e.message}`);
+		}
 	}
 
-	return { mainPath };
+	const mainPath = join(targetDir, "app", "src", "main.go");
+	return {
+		mainPath,
+		files: templates.map((t) => t.path),
+	};
 }
 
 export async function handlePrep(targetDir, options = {}) {
@@ -123,3 +225,406 @@ export function parseTestArgs(argv) {
 export function handleTest(targetDir, options = {}) {
 	return runTests(targetDir, options);
 }
+
+// ── Project detection ─────────────────────────────────────────
+
+function loadProjectConfig(projectRoot) {
+	const gofrontJson = join(projectRoot, "gofront.json");
+	if (existsSync(gofrontJson)) {
+		try {
+			return JSON.parse(readFileSync(gofrontJson, "utf8"));
+		} catch {}
+	}
+	const pkgJson = join(projectRoot, "package.json");
+	if (existsSync(pkgJson)) {
+		try {
+			const pkg = JSON.parse(readFileSync(pkgJson, "utf8"));
+			if (pkg.gofront && typeof pkg.gofront === "object") {
+				return pkg.gofront;
+			}
+		} catch {}
+	}
+	return {};
+}
+
+function resolveSrcDir(projectRoot, config) {
+	const src = config.src || config.input;
+	if (src) return isAbsolute(src) ? src : resolve(projectRoot, src);
+	if (existsSync(join(projectRoot, "app", "src"))) {
+		return join(projectRoot, "app", "src");
+	}
+	if (existsSync(join(projectRoot, "src"))) {
+		return join(projectRoot, "src");
+	}
+	if (existsSync(join(projectRoot, "main.go"))) {
+		return join(projectRoot, "main.go");
+	}
+	return projectRoot;
+}
+
+function resolveServeDir(projectRoot, config) {
+	const serve = config.serveDir;
+	if (serve) return isAbsolute(serve) ? serve : resolve(projectRoot, serve);
+	if (existsSync(join(projectRoot, "app", "index.html"))) {
+		return join(projectRoot, "app");
+	}
+	if (existsSync(join(projectRoot, "index.html"))) {
+		return projectRoot;
+	}
+	if (existsSync(join(projectRoot, "public", "index.html"))) {
+		return join(projectRoot, "public");
+	}
+	return existsSync(join(projectRoot, "app"))
+		? join(projectRoot, "app")
+		: projectRoot;
+}
+
+function resolveOutDir(projectRoot, config) {
+	const out =
+		config.outDir ||
+		config.dist ||
+		(typeof config.public === "string" ? config.public : null);
+	if (out) return isAbsolute(out) ? out : resolve(projectRoot, out);
+	return join(projectRoot, "public");
+}
+
+function resolveDevOutputFile(projectRoot, serveDir, config) {
+	const out = config.output;
+	if (out) return isAbsolute(out) ? out : resolve(projectRoot, out);
+	if (existsSync(join(projectRoot, "app"))) {
+		return join(projectRoot, "app", "app.js");
+	}
+	return join(serveDir, "app.js");
+}
+
+export function detectProject(dir = ".") {
+	const projectRoot = resolve(dir);
+	const config = loadProjectConfig(projectRoot);
+	const srcDir = resolveSrcDir(projectRoot, config);
+	const serveDir = resolveServeDir(projectRoot, config);
+	const devOutputFile = resolveDevOutputFile(projectRoot, serveDir, config);
+	const outDir = resolveOutDir(projectRoot, config);
+	const port = config.port || config.serverPort || 3000;
+
+	return {
+		projectRoot,
+		srcDir,
+		serveDir,
+		devOutputFile,
+		outDir,
+		port,
+		config,
+	};
+}
+
+// ── check command ─────────────────────────────────────────────
+
+export function parseCheckArgs(argv) {
+	const positional = argv.filter((a) => !a.startsWith("-"));
+	return {
+		targetDir: positional[0] ?? ".",
+	};
+}
+
+export function handleCheck(targetDir = ".", options = {}) {
+	const project = detectProject(targetDir);
+	const targetPath = resolve(targetDir);
+	let isDir = false;
+	try {
+		isDir = statSync(targetPath).isDirectory();
+	} catch (e) {
+		throw new Error(`cannot access '${targetDir}': ${e.message}`);
+	}
+
+	let compileTarget = targetPath;
+	if (
+		isDir &&
+		targetPath === project.projectRoot &&
+		project.srcDir !== project.projectRoot
+	) {
+		compileTarget = project.srcDir;
+	}
+
+	const targetIsDir = statSync(compileTarget).isDirectory();
+	const startMs = performance.now();
+	runCompile(compileTarget, targetIsDir, { ...options });
+	const elapsedMs = (performance.now() - startMs).toFixed(0);
+	return { target: targetDir, compileTarget, elapsedMs };
+}
+
+// ── build command ─────────────────────────────────────────────
+
+export function parseBuildArgs(argv) {
+	let outDir = null;
+	const positional = [];
+	const pwa = argv.includes("--pwa");
+	const sourceMap = argv.includes("--source-map");
+	const noMinify = argv.includes("--no-minify");
+	const noMangle = argv.includes("--no-mangle");
+
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "-o" || arg === "--out-dir" || arg === "--out") {
+			outDir = argv[++i] ?? null;
+		} else if (arg.startsWith("--out-dir=")) {
+			outDir = arg.slice(arg.indexOf("=") + 1);
+		} else if (!arg.startsWith("-")) {
+			positional.push(arg);
+		}
+	}
+
+	return {
+		targetDir: positional[0] ?? ".",
+		outDir,
+		pwa,
+		sourceMap,
+		minify: !noMinify,
+		mangle: !noMangle && !noMinify,
+	};
+}
+
+function isSubdirectory(parent, child) {
+	const rel = relative(parent, child);
+	return (
+		rel !== "" &&
+		rel !== ".." &&
+		!rel.startsWith(`..${sep}`) &&
+		!isAbsolute(rel)
+	);
+}
+
+function cleanOutputDir(outDir, projectRoot, srcDir) {
+	const resolvedOut = resolve(outDir);
+	const resolvedRoot = resolve(projectRoot);
+	const resolvedSrc = resolve(srcDir);
+
+	const isSafe =
+		resolvedOut !== resolvedRoot &&
+		resolvedOut !== resolvedSrc &&
+		!isSubdirectory(resolvedOut, resolvedRoot) &&
+		!isSubdirectory(resolvedOut, resolvedSrc);
+
+	if (isSafe && existsSync(resolvedOut)) {
+		rmSync(resolvedOut, { recursive: true, force: true });
+	}
+	mkdirSync(resolvedOut, { recursive: true });
+}
+
+function copyReleaseAssets(project, outDir, assetConfig) {
+	const assetResult = copyAssets(project.projectRoot, assetConfig);
+
+	const candidates = [
+		join(project.serveDir, "index.html"),
+		join(project.projectRoot, "index.html"),
+		join(project.projectRoot, "app", "index.html"),
+	];
+	const destIndex = join(outDir, "index.html");
+	for (const candidate of candidates) {
+		if (existsSync(candidate) && resolve(candidate) !== resolve(destIndex)) {
+			copyFileSync(candidate, destIndex);
+			break;
+		}
+	}
+	return assetResult;
+}
+
+function collectOutputFiles(outDir) {
+	const files = [];
+	try {
+		for (const name of readdirSync(outDir)) {
+			const filePath = join(outDir, name);
+			const stat = statSync(filePath);
+			if (stat.isFile()) {
+				files.push({ name, size: stat.size, path: filePath });
+			}
+		}
+	} catch {}
+	return files;
+}
+
+export function formatBuildSummary({ outDir, elapsedMs, files, pwa }) {
+	const lines = [`build complete in ${elapsedMs}ms → ${outDir}`];
+	for (const f of files) {
+		const sizeKb = (f.size / 1024).toFixed(1);
+		lines.push(`  ${f.name} (${sizeKb} kB)`);
+	}
+	if (pwa) {
+		lines.push(
+			`  pwa: generated sw.js (${pwa.assetsCount} cached assets, ${pwa.version})`,
+		);
+	}
+	return lines;
+}
+
+export async function handleBuild(targetDir = ".", options = {}) {
+	const startMs = performance.now();
+	const project = detectProject(targetDir);
+	const outDir = options.outDir ? resolve(options.outDir) : project.outDir;
+	const srcDir = options.srcDir ? resolve(options.srcDir) : project.srcDir;
+
+	cleanOutputDir(outDir, project.projectRoot, srcDir);
+
+	const isDir = statSync(srcDir).isDirectory();
+	const outputFile = join(outDir, "app.js");
+	const compileResult = runCompile(srcDir, isDir, {
+		outputFile,
+		sourceMap: options.sourceMap ?? false,
+	});
+
+	const doMinify = options.minify ?? true;
+	const doMangle = options.mangle ?? true;
+	const js = maybeMinify(compileResult.js, {
+		minify: doMinify,
+		mangle: doMangle,
+		sourceMap: options.sourceMap ?? false,
+	});
+	writeFileSync(outputFile, `${js}\n`);
+
+	let vendor = null;
+	try {
+		vendor = await bundleVendor(project.projectRoot, {
+			dest: join(outDir, "vendor.js"),
+			minify: doMinify,
+			...options.vendorConfig,
+		});
+	} catch (e) {
+		console.warn(`gofront: vendor bundle warning: ${e.message}`);
+	}
+
+	const assets = copyReleaseAssets(project, outDir, options.assetConfig);
+
+	let pwa = null;
+	if (options.pwa) {
+		pwa = generatePwa(outDir);
+	}
+
+	const elapsedMs = (performance.now() - startMs).toFixed(0);
+	const files = collectOutputFiles(outDir);
+
+	return {
+		outDir,
+		srcDir,
+		elapsedMs,
+		files,
+		assets,
+		vendor,
+		pwa,
+	};
+}
+
+export { generatePwa };
+
+// ── dev command ───────────────────────────────────────────────
+
+export function parseDevArgs(argv) {
+	let port = null;
+	let outputFile = null;
+	const positional = [];
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "-p" || arg === "--port") {
+			port = parseInt(argv[++i], 10);
+		} else if (arg.startsWith("--port=")) {
+			port = parseInt(arg.slice(arg.indexOf("=") + 1), 10);
+		} else if (arg === "-o" || arg === "--output") {
+			outputFile = argv[++i] ?? null;
+		} else if (!arg.startsWith("-")) {
+			positional.push(arg);
+		}
+	}
+	return {
+		targetDir: positional[0] ?? ".",
+		port: Number.isNaN(port) ? null : port,
+		outputFile,
+	};
+}
+
+export async function handleDev(targetDir = ".", options = {}) {
+	const project = detectProject(targetDir);
+	const port = options.port ?? project.port ?? 3000;
+	const serveDir = options.serveDir
+		? resolve(options.serveDir)
+		: project.serveDir;
+	const srcDir = options.srcDir ? resolve(options.srcDir) : project.srcDir;
+	const outputFile = options.outputFile
+		? resolve(options.outputFile)
+		: project.devOutputFile;
+
+	copyAssets(project.projectRoot, options.assetConfig);
+
+	const devServer = createDevServer(serveDir, port, options);
+	const isDir = statSync(srcDir).isDirectory();
+	let initialError = null;
+
+	try {
+		const result = runCompile(srcDir, isDir, {
+			outputFile,
+			sourceMap: options.sourceMap ?? true,
+		});
+		mkdirSync(dirname(outputFile), { recursive: true });
+		writeFileSync(outputFile, `${result.js}\n`);
+	} catch (err) {
+		initialError = err;
+	}
+
+	let watcher = null;
+	if (options.watch !== false) {
+		const watchTarget = isDir ? srcDir : dirname(srcDir);
+		let debounce = null;
+		let cssDebounce = null;
+
+		function buildOnce(changedFile = null) {
+			try {
+				const startMs = performance.now();
+				const result = runCompile(srcDir, isDir, {
+					outputFile,
+					sourceMap: options.sourceMap ?? true,
+				});
+				mkdirSync(dirname(outputFile), { recursive: true });
+				writeFileSync(outputFile, `${result.js}\n`);
+				const elapsedMs = (performance.now() - startMs).toFixed(0);
+				const note = changedFile ? ` — ${changedFile} changed` : "";
+				console.error(
+					`gofront: OK — wrote ${outputFile} (${elapsedMs}ms${note})`,
+				);
+				devServer.notify();
+			} catch (e) {
+				console.error(`gofront: ERROR`);
+				for (const line of e.message.split("\n")) console.error(`  ${line}`);
+				devServer.notifyError(e);
+			}
+		}
+
+		function handleCss(filename) {
+			try {
+				copyAssets(project.projectRoot, options.assetConfig);
+			} catch {}
+			devServer.notifyCss(filename);
+		}
+
+		watcher = watch(watchTarget, { recursive: true }, (_event, filename) => {
+			if (!filename) return;
+			if (filename.endsWith(".css")) {
+				clearTimeout(cssDebounce);
+				cssDebounce = setTimeout(() => handleCss(filename), 50);
+				return;
+			}
+			if (!filename.endsWith(".go") && !filename.endsWith(".templ")) return;
+			clearTimeout(debounce);
+			debounce = setTimeout(() => buildOnce(filename), 80);
+		});
+	}
+
+	return {
+		devServer,
+		project,
+		serveDir,
+		srcDir,
+		outputFile,
+		initialError,
+		close: async () => {
+			if (watcher) watcher.close();
+			await devServer.close();
+		},
+	};
+}