gofront 0.0.9 → 1.0.1

package/src/codegen/templ.js

@@ -0,0 +1,284 @@
+// Templ (.templ file) code-generation mixin for CodeGen.
+// Mounts an HTML/expression tree onto a parent DOM node by emitting plain
+// document.createElement / appendChild / setAttribute calls.
+
+import { Parser } from "../parser/index.js";
+import { T, Token } from "../tokens.js";
+
+/** @typedef {import('./index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
+export const templGenMethods = {
+	genTemplDecl(decl) {
+		const params = decl.params
+			.map((p, i) =>
+				p.variadic && i === decl.params.length - 1 ? `...${p.name}` : p.name,
+			)
+			.join(", ");
+		this.line(`function ${decl.name}(${params}) {`);
+		this.indented(() => {
+			this.line(`return {Mount(___p) {`);
+			this.indented(() => {
+				this._genTemplNodes(decl.body, "___p");
+			});
+			this.line(`}};`);
+		});
+		this.line("}");
+	},
+
+	// Emit mount statements for an array of TemplNodes into parent variable `p`.
+	_genTemplNodes(nodes, p) {
+		if (!nodes || nodes.length === 0) return;
+		if (nodes.length === 1) {
+			this._genTemplNodeMount(nodes[0], p);
+			return;
+		}
+		// Wrap multiple root nodes in a fragment div? No — emit each directly.
+		for (const node of nodes) {
+			this._genTemplNodeMount(node, p);
+		}
+	},
+
+	// Emit JS to mount a single TemplNode onto parent `p`.
+	_genTemplNodeMount(node, p) {
+		switch (node.kind) {
+			case "TemplElement":
+				return this._genTemplElement(node, p);
+			case "TemplText":
+				return this.line(
+					`${p}.appendChild(document.createTextNode(${JSON.stringify(node.value)}));`,
+				);
+			case "TemplExpr":
+				return this.line(
+					`${p}.appendChild(document.createTextNode(String(${this._genTemplTokenExpr(node.tokens)})));`,
+				);
+			case "TemplComponent":
+				return this._genTemplComponentMount(node, p);
+			case "TemplChildren":
+				// children is a variadic gom.Node param — mount each child
+				return this.line(
+					`if(typeof children!=="undefined")(Array.isArray(children)?children:[...children]).forEach(___c=>___c?.Mount?.(${p}));`,
+				);
+			case "TemplIf":
+				return this._genTemplIf(node, p);
+			case "TemplFor":
+				return this._genTemplFor(node, p);
+			case "TemplSwitch":
+				return this._genTemplSwitch(node, p);
+			default:
+				break;
+		}
+	},
+
+	_genTemplComponentMount(node, p) {
+		// Special case: @templ.Raw(expr) → insertAdjacentHTML
+		const toks = node.tokens;
+		if (
+			toks.length >= 4 &&
+			toks[0]?.value === "templ" &&
+			toks[1]?.type === T.DOT &&
+			toks[2]?.value === "Raw" &&
+			toks[3]?.type === T.LPAREN
+		) {
+			const argTokens = toks.slice(4, toks.length - 1);
+			const argJs = this._genTemplTokenExpr(argTokens);
+			return this.line(`${p}.insertAdjacentHTML("beforeend", ${argJs});`);
+		}
+		return this.line(
+			`(${this._genTemplTokenCallExpr(node.tokens)}).Mount(${p});`,
+		);
+	},
+
+	_genTemplElement(node, p) {
+		const { tag, attrs, children } = node;
+		const elVar = this._freshVar("e");
+		this.line(
+			`const ${elVar} = document.createElement(${JSON.stringify(tag)});`,
+		);
+		for (const attr of attrs) {
+			this._genTemplAttr(attr, elVar);
+		}
+		this._genTemplNodes(children, elVar);
+		this.line(`${p}.appendChild(${elVar});`);
+	},
+
+	_genTemplAttr(attr, el) {
+		const { name } = attr;
+		if (attr.kind === "static") {
+			if (name === "class") {
+				this.line(`${el}.className = ${JSON.stringify(attr.value)};`);
+			} else {
+				this.line(
+					`${el}.setAttribute(${JSON.stringify(name)}, ${JSON.stringify(attr.value)});`,
+				);
+			}
+		} else if (attr.kind === "expr") {
+			const exprJs = this._genTemplTokenExpr(attr.tokens);
+			if (name === "class") {
+				this.line(`${el}.className = ${exprJs};`);
+			} else {
+				this.line(
+					`${el}.setAttribute(${JSON.stringify(name)}, String(${exprJs}));`,
+				);
+			}
+		} else if (attr.kind === "bool") {
+			this.line(`${el}.setAttribute(${JSON.stringify(name)}, "");`);
+		} else if (attr.kind === "cond-bool") {
+			const exprJs = this._genTemplTokenExpr(attr.tokens);
+			this.line(
+				`if(${exprJs})${el}.setAttribute(${JSON.stringify(name)}, "");`,
+			);
+		}
+	},
+
+	_genTemplIf(node, p) {
+		const condJs = this._genTemplCondTokens(node.condTokens);
+		this.line(`if (${condJs}) {`);
+		this.indented(() => this._genTemplNodes(node.then, p));
+		this._genTemplIfElse(node.else_, p);
+	},
+
+	_genTemplIfElse(else_, p) {
+		if (!else_ || else_.length === 0) {
+			this.line(`}`);
+			return;
+		}
+		if (else_.length === 1 && else_[0].kind === "TemplIf") {
+			const elseIf = else_[0];
+			this.line(`} else if (${this._genTemplCondTokens(elseIf.condTokens)}) {`);
+			this.indented(() => this._genTemplNodes(elseIf.then, p));
+			this._genTemplIfElse(elseIf.else_, p);
+		} else {
+			this.line(`} else {`);
+			this.indented(() => this._genTemplNodes(else_, p));
+			this.line(`}`);
+		}
+	},
+
+	_genTemplSwitch(node, p) {
+		const { exprTokens, cases } = node;
+		if (cases.length === 0) return;
+		const exprJs = this._genTemplTokenExpr(exprTokens);
+		this.line(`switch (${exprJs}) {`);
+		this.indented(() => {
+			for (const c of cases) {
+				const label =
+					c.caseTokens === null
+						? "default"
+						: `case ${this._genTemplTokenExpr(c.caseTokens)}`;
+				this.line(`${label}: {`);
+				this.indented(() => this._genTemplNodes(c.body, p));
+				this.line(`break; }`);
+			}
+		});
+		this.line(`}`);
+	},
+
+	_genTemplFor(node, p) {
+		// stmtTokens include the `for` keyword plus the range clause (no body).
+		// Strip any trailing semicolons (inserted by the Go lexer on newlines),
+		// then add a fake empty body `{ }` so the parser can complete the ForStmt.
+		let tokens = node.stmtTokens;
+		while (tokens.length > 0 && tokens[tokens.length - 1].type === T.SEMICOLON)
+			tokens = tokens.slice(0, -1);
+		const eofTok = new Token(T.EOF, "", 1, 1);
+		const lbrace = new Token(T.LBRACE, "{", 1, 1);
+		const rbrace = new Token(T.RBRACE, "}", 1, 1);
+		const semi = new Token(T.SEMICOLON, ";", 1, 1);
+		const withFor =
+			tokens[0]?.type === T.FOR
+				? [...tokens, lbrace, rbrace, semi, eofTok]
+				: [
+						new Token(T.FOR, "for", 1, 1),
+						...tokens,
+						lbrace,
+						rbrace,
+						semi,
+						eofTok,
+					];
+		try {
+			const p2 = new Parser(withFor);
+			const forStmt = p2.parseFor();
+			this._genTemplRangeFor(forStmt, node.body, p);
+		} catch {
+			// Fallback for non-range loops: emit a comment + skip
+			this.line(`/* templ for: ${this._tokensToSource(tokens)} */`);
+		}
+	},
+
+	_genTemplRangeFor(forStmt, templBody, mountParent) {
+		const init = forStmt.init;
+		if (!init?.rhs?.[0] || init.rhs[0].kind !== "RangeExpr") {
+			// Plain for loop (cond-only or three-clause)
+			const condJs = forStmt.cond ? this.genExpr(forStmt.cond) : "true";
+			this.line(`while (${condJs}) {`);
+			this.indented(() => this._genTemplNodes(templBody, mountParent));
+			this.line("}");
+			return;
+		}
+		// Range for: for key, val := range iter
+		const range = init.rhs[0];
+		const iterJs = this.genExpr(range.expr);
+		const lhs = init.lhs.map((e) => e.name ?? "_");
+		const keyName = lhs[0] ?? "_";
+		const valName = lhs[1] ?? null;
+
+		const loopHeader = this._genTemplRangeHeader(keyName, valName, iterJs);
+		this.line(loopHeader);
+		this.indented(() => this._genTemplNodes(templBody, mountParent));
+		this.line("}");
+	},
+
+	_genTemplRangeHeader(keyName, valName, iterJs) {
+		if (valName === null || valName === undefined) {
+			return `for (const ${keyName === "_" ? "_$" : keyName} of ${iterJs}) {`;
+		}
+		if (keyName === "_" && valName === "_")
+			return `for (const _$ of ${iterJs}) {`;
+		if (keyName === "_") return `for (const ${valName} of ${iterJs}) {`;
+		if (valName === "_")
+			return `for (const [${keyName}] of Object.entries(${iterJs})) {`;
+		// Default to .entries() for arrays, Object.entries for objects
+		this._usesSliceGuard = true;
+		return `for (const [${keyName}, ${valName}] of __s(${iterJs}).entries()) {`;
+	},
+
+	// Parse a token array as a Go expression and emit JS.
+	_genTemplTokenExpr(tokens) {
+		if (!tokens || tokens.length === 0) return '""';
+		const eofTok = new Token(T.EOF, "", 1, 1);
+		const p = new Parser([...tokens, eofTok]);
+		const ast = p.parseExpr();
+		return this.genExpr(ast);
+	},
+
+	// Parse a token array as a Go call expression and emit JS.
+	_genTemplTokenCallExpr(tokens) {
+		if (!tokens || tokens.length === 0) return "null";
+		const eofTok = new Token(T.EOF, "", 1, 1);
+		const p = new Parser([...tokens, eofTok]);
+		const ast = p.parseExpr();
+		return this.genExpr(ast);
+	},
+
+	// Extract condition JS from condTokens (which may start with `if`).
+	_genTemplCondTokens(tokens) {
+		if (!tokens || tokens.length === 0) return "false";
+		let toks = tokens;
+		if (toks[0]?.type === T.IF) toks = toks.slice(1); // skip `if` keyword
+		const eofTok = new Token(T.EOF, "", 1, 1);
+		const p = new Parser([...toks, eofTok]);
+		const ast = p.parseExpr();
+		return this.genExpr(ast);
+	},
+
+	_tokensToSource(tokens) {
+		return tokens.map((t) => t.value).join(" ");
+	},
+
+	// Fresh variable name counter
+	_freshVar(prefix = "v") {
+		this._templVarCount = (this._templVarCount ?? 0) + 1;
+		return `___${prefix}${this._templVarCount}`;
+	},
+};

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)
@@ -17,14 +19,14 @@
 
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
-import { CodeGen } from "./codegen.js";
+import { CodeGen } from "./codegen/index.js";
 import { parseDts } from "./dts-parser.js";
 import { Lexer } from "./lexer.js";
-import { Parser } from "./parser.js";
+import { Parser } from "./parser/index.js";
 import { isLocalPath, resolveAll, resolveGwDir } from "./resolver.js";
 import { TemplLexer } from "./templ-lexer.js";
 import { TemplParser } from "./templ-parser.js";
-import { TypeChecker } from "./typechecker.js";
+import { TypeChecker } from "./typechecker/index.js";
 
 // ── Parse cache ──────────────────────────────────────────────
 
@@ -41,29 +43,20 @@ export function parseCacheSize() {
 
 // ── Helpers ──────────────────────────────────────────────────
 
-function parseFile(filePath) {
+function parseGoFrontFile(filePath) {
 	const mtime = statSync(filePath).mtimeMs;
 	const cached = _parseCache.get(filePath);
 	if (cached && cached.mtime === mtime) return cached.ast;
 
 	const source = readFileSync(filePath, "utf8");
 	const filename = basename(filePath);
-	const tokens = new Lexer(source, filename).tokenize();
-	const ast = new Parser(tokens, filename, source).parse();
-	ast._source = source;
-	_parseCache.set(filePath, { mtime, ast });
-	return ast;
-}
-
-function parseTemplFile(filePath) {
-	const mtime = statSync(filePath).mtimeMs;
-	const cached = _parseCache.get(filePath);
-	if (cached && cached.mtime === mtime) return cached.ast;
-
-	const source = readFileSync(filePath, "utf8");
-	const filename = basename(filePath);
-	const tokens = new TemplLexer(source, filename).tokenize();
-	const ast = new TemplParser(tokens, filename, source).parse();
+	const isTempl = filePath.endsWith(".templ");
+	const tokens = isTempl
+		? new TemplLexer(source, filename).tokenize()
+		: new Lexer(source, filename).tokenize();
+	const ast = isTempl
+		? new TemplParser(tokens, filename, source).parse()
+		: new Parser(tokens, filename, source).parse();
 	ast._source = source;
 	_parseCache.set(filePath, { mtime, ast });
 	return ast;
@@ -76,53 +69,27 @@ function gwFilesIn(dir) {
 		.map((f) => join(dir, f));
 }
 
-// ── Main entry points ─────────────────────────────────────────
-
-export function compileDir(dir, options = {}) {
-	const files = gwFilesIn(dir);
-	if (files.length === 0) throw new Error(`No .go files found in ${dir}`);
-	return compileFiles(files, { ...options, fromDir: dir });
-}
-
-export function compileFiles(files, options = {}) {
-	const fromDir = options.fromDir ?? dirname(resolve(files[0]));
-
-	// ── 1. Parse ─────────────────────────────────────────────────
-	const parseErrors = [];
-	const programs = [];
-	for (const f of files) {
-		try {
-			programs.push(f.endsWith(".templ") ? parseTemplFile(f) : parseFile(f));
-		} catch (e) {
-			parseErrors.push(e.message);
-		}
-	}
-	if (parseErrors.length > 0) {
-		throw new Error(parseErrors.join("\n"));
-	}
-
-	// Validate consistent package name
-	const pkgNames = [...new Set(programs.map((p) => p.pkg.name))];
-	if (pkgNames.length > 1)
-		throw new Error(
-			`Mixed package names in ${fromDir}: ${pkgNames.join(", ")}`,
-		);
-	const pkgName = pkgNames[0];
-
-	// ── 2. Resolve imports ────────────────────────────────────────
-	const checker = new TypeChecker();
-	const jsImports = new Map(); // npm imports → exported names (for ESM emit)
-	const bundledPackages = new Set(); // package names whose code is inlined
-	const preambles = []; // JS code from compiled sub-packages
+// ── Import resolution ─────────────────────────────────────────
+//
+// Shared by compileFiles (multi-file) and the single-file path in index.js.
+// Mutates checker, jsImports, bundledPackages, and preambles in place.
 
+export function resolveImports(
+	programs,
+	fromFile,
+	checker,
+	jsImports,
+	bundledPackages,
+	preambles,
+) {
+	const fromDir = dirname(resolve(fromFile));
 	const allImports = programs.flatMap((p) => p.imports);
-	const dummyFromFile = join(fromDir, "_dummy.go");
 
 	// js: prefix — local .d.ts files
 	for (const imp of allImports) {
 		for (const { path, alias } of imp.imports) {
 			if (!path.startsWith("js:")) continue;
-			if (alias === "_") continue; // side-effect import — no type definitions
+			if (alias === "_") continue;
 			const dtsPath = join(fromDir, path.slice(3));
 			try {
 				const { types, values } = parseDts(readFileSync(dtsPath, "utf8"));
@@ -133,12 +100,12 @@ export function compileFiles(files, options = {}) {
 		}
 	}
 
-	// npm packages — exclude side-effect imports (alias "_") from type resolution
+	// npm packages — exclude side-effect imports from type resolution
 	const allImportsNoSideEffect = allImports.map((imp) => ({
 		...imp,
 		imports: imp.imports.filter(({ alias }) => alias !== "_"),
 	}));
-	const resolved = resolveAll(allImportsNoSideEffect, dummyFromFile, parseDts);
+	const resolved = resolveAll(allImportsNoSideEffect, fromFile, parseDts);
 	for (const [path, info] of resolved) {
 		if (!info) continue;
 		checker.addDefinitions(info.types, info.values);
@@ -152,29 +119,20 @@ export function compileFiles(files, options = {}) {
 			for (const { path, alias, _line } of imp.imports) {
 				if (!isLocalPath(path) || seenLocalPaths.has(path)) continue;
 				seenLocalPaths.add(path);
-
-				const depDir = resolveGwDir(path, dummyFromFile);
+				const depDir = resolveGwDir(path, fromFile);
 				if (!depDir) {
 					console.error(
 						`gofront: warning: cannot find local package '${path}' relative to ${fromDir}`,
 					);
 					continue;
 				}
-
-				// Recursively compile dependency
 				const dep = compileDir(depDir);
 				preambles.push(dep.js);
-				if (alias === "_") continue; // side-effect import — bundle code but don't expose namespace
-
-				// Dot import: flatten all exported symbols into global scope
+				if (alias === "_") continue;
 				if (alias === ".") {
 					checker.addDefinitions(dep.exportedTypes, dep.exportedSymbols);
-					// All dep symbols must be treated as bundled so codegen
-					// can emit them without a qualifier.  We DON'T add a
-					// namespace, so SelectorExpr never appears for these.
 					continue;
 				}
-
 				const nameUsed = alias ?? dep.pkgName;
 				bundledPackages.add(nameUsed);
 				checker.addPackageNamespace(
@@ -186,6 +144,113 @@ export function compileFiles(files, options = {}) {
 			}
 		}
 	}
+}
+
+// ── 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}`);
+	return compileFiles(files, { ...options, fromDir: dir });
+}
+
+export function compileFiles(files, options = {}) {
+	const fromDir = options.fromDir ?? dirname(resolve(files[0]));
+
+	// ── 1. Parse ─────────────────────────────────────────────────
+	const parseErrors = [];
+	const programs = [];
+	for (const f of files) {
+		try {
+			programs.push(parseGoFrontFile(f));
+		} catch (e) {
+			parseErrors.push(e.message);
+		}
+	}
+	if (parseErrors.length > 0) {
+		throw new Error(parseErrors.join("\n"));
+	}
+
+	// Validate consistent package name
+	const pkgNames = [...new Set(programs.map((p) => p.pkg.name))];
+	if (pkgNames.length > 1)
+		throw new Error(
+			`Mixed package names in ${fromDir}: ${pkgNames.join(", ")}`,
+		);
+	const pkgName = pkgNames[0];
+
+	// ── 2. Resolve imports ────────────────────────────────────────
+	const checker = new TypeChecker();
+	const jsImports = new Map(); // npm imports → exported names (for ESM emit)
+	const bundledPackages = new Set(); // package names whose code is inlined
+	const preambles = []; // JS code from compiled sub-packages
+
+	const dummyFromFile = join(fromDir, "_dummy.go");
+	resolveImports(
+		programs,
+		dummyFromFile,
+		checker,
+		jsImports,
+		bundledPackages,
+		preambles,
+	);
 
 	// ── 3. Type-check ─────────────────────────────────────────────
 	const errors = checker.checkAll(programs);