gofront 1.3.12 → 1.5.1

package/src/parser/index.js

@@ -114,6 +114,8 @@ export class Parser {
 			pkg,
 			imports,
 			decls,
+			target: this.tokens?.target ?? null,
+			_targetDirective: this.tokens?.targetDirective ?? null,
 			_filename: this.filename,
 			_source: this.source,
 		};
@@ -130,7 +132,9 @@ export class Parser {
 		this.expect(T.IMPORT);
 		const imports = [];
 		const parseOne = () => {
-			const _line = this.peek().line;
+			const tok = this.peek();
+			const _line = tok.line;
+			const _col = tok.col;
 			let alias = null;
 			if (this.check(T.IDENT)) {
 				alias = this.advance().value;
@@ -138,8 +142,9 @@ export class Parser {
 				alias = ".";
 				this.advance();
 			}
-			const path = this.expect(T.STRING).value;
-			return { path, alias, _line };
+			const pathTok = this.expect(T.STRING);
+			const path = pathTok.value;
+			return { path, alias, _line, _col, line: pathTok.line, col: pathTok.col };
 		};
 		if (this.match(T.LPAREN)) {
 			while (!this.check(T.RPAREN) && !this.check(T.EOF)) {

package/src/resolver.js

@@ -33,6 +33,7 @@ const BUILTIN_PACKAGES = new Set([
 	"strconv",
 	"sort",
 	"math",
+	"math/bits",
 	"math/rand",
 	"errors",
 	"time",
@@ -65,7 +66,9 @@ export function resolveGwDir(importPath, fromFile) {
 	const fromDir = dirname(resolve(fromFile));
 	const dir = resolve(fromDir, importPath);
 	if (!existsSync(dir)) return null;
-	const gwFiles = readdirSync(dir).filter((f) => f.endsWith(".go"));
+	const gwFiles = readdirSync(dir).filter(
+		(f) => f.endsWith(".go") || f.endsWith(".templ"),
+	);
 	return gwFiles.length > 0 ? dir : null;
 }
 

package/src/templ-lexer.js

@@ -35,6 +35,8 @@ export const TT = {
 	TEMPL_CASE: "TEMPL_CASE", // case expr:
 	TEMPL_DEFAULT: "TEMPL_DEFAULT", // default:
 	TEMPL_END: "TEMPL_END", // closing } of if/for/switch/templ body
+	CSS_KW: "css",
+	CSS_BODY: "CSS_BODY",
 };
 
 // Describes a parsed HTML attribute
@@ -123,6 +125,13 @@ export class TemplLexer {
 				continue;
 			}
 
+			// Detect `css` keyword at identifier boundaries
+			if (this._matchKeyword("css")) {
+				this.tokens.push(new Token(TT.CSS_KW, "css", this.line, this.col));
+				this._lexCssDecl();
+				continue;
+			}
+
 			// Everything else: scan to end of top-level declaration using the
 			// raw Go lexer, accumulating tokens until the next `templ` keyword
 			// or EOF.
@@ -135,7 +144,7 @@ export class TemplLexer {
 
 	// ── Go chunk lexing ──────────────────────────────────────────
 
-	// Scan ahead to find the next `templ ` keyword at top level (not inside
+	// Scan ahead to find the next `templ ` or `css ` keyword at top level (not inside
 	// braces/parens/strings/comments). Collect all source text up to that
 	// point, lex it as normal Go, and append the tokens.
 	_lexGoChunk() {
@@ -143,8 +152,12 @@ export class TemplLexer {
 		let depth = 0; // brace depth
 
 		while (!this.eof()) {
-			// Check for `templ` keyword at top level (depth === 0)
-			if (depth === 0 && this._peekKeyword("templ")) break;
+			// Check for `templ` or `css` keyword at top level (depth === 0)
+			if (
+				depth === 0 &&
+				(this._peekKeyword("templ") || this._peekKeyword("css"))
+			)
+				break;
 
 			const ch = this.peek();
 
@@ -222,6 +235,97 @@ export class TemplLexer {
 		this._lexHtmlBody(1);
 	}
 
+	// ── CSS declaration lexing ───────────────────────────────────
+
+	_lexCssDecl() {
+		this.skipWhitespace();
+
+		// Name (identifier)
+		const nameStart = this.pos;
+		while (!this.eof() && /\w/.test(this.peek())) this.advance();
+		const name = this.src.slice(nameStart, this.pos);
+		if (!name) this.err("expected name after 'css'");
+		this.tokens.push(new Token(T.IDENT, name, this.line, this.col));
+
+		this.skipWhitespace();
+
+		// Parameter list (balanced parens)
+		if (this.peek() !== "(") this.err("expected '(' after css name");
+		const paramStart = this.pos;
+		this._skipBalanced("(", ")");
+		const paramSrc = this.src.slice(paramStart, this.pos);
+		for (const t of this._goTokens(paramSrc)) this.tokens.push(t);
+
+		this.skipWhitespace();
+
+		// Opening { of body
+		if (this.peek() !== "{") this.err("expected '{' after css params");
+		this.advance(); // consume {
+		this.tokens.push(new Token(T.LBRACE, "{", this.line, this.col));
+
+		this._lexCssBody();
+	}
+
+	_skipCssString(quote) {
+		this.advance(); // consume opening quote
+		while (!this.eof()) {
+			const ch = this.peek();
+			if (ch === "\\") {
+				this.advance();
+				if (!this.eof()) this.advance();
+				continue;
+			}
+			if (ch === quote) {
+				this.advance();
+				return;
+			}
+			if (ch === "\n") {
+				this.err("unterminated string in css block");
+			}
+			this.advance();
+		}
+		this.err("unterminated string in css block");
+	}
+
+	_lexCssBody() {
+		const start = this.pos;
+		let depth = 1;
+		while (!this.eof()) {
+			const ch = this.peek();
+			// Skip CSS comments /* ... */
+			if (ch === "/" && this.peek(1) === "*") {
+				this.advance();
+				this.advance();
+				this.skipBlockComment();
+				continue;
+			}
+			// Skip strings
+			if (ch === '"' || ch === "'") {
+				this._skipCssString(ch);
+				continue;
+			}
+			if (ch === "{") {
+				depth++;
+				this.advance();
+			} else if (ch === "}") {
+				depth--;
+				if (depth === 0) {
+					const cssText = this.src.slice(start, this.pos);
+					this.tokens.push(
+						new Token(TT.CSS_BODY, cssText, this.line, this.col),
+					);
+					this.advance(); // consume closing }
+					this.tokens.push(new Token(T.RBRACE, "}", this.line, this.col));
+					return;
+				}
+				this.advance();
+			} else {
+				this.advance();
+			}
+		}
+		this.err("unclosed css block");
+	}
+
 	// Lex the HTML body of a templ declaration.
 	// depth: current brace depth (starts at 1 for the opening { of templ)
 	_lexHtmlBody(depth) {

package/src/templ-parser.js

@@ -42,9 +42,38 @@ export class TemplParser extends Parser {
 
 	parseTopDecl() {
 		if (this.check(TT.TEMPL_KW)) return this.parseTemplDecl();
+		if (this.check(TT.CSS_KW)) return this.parseCssDecl();
 		return super.parseTopDecl();
 	}
 
+	// ── CssDecl ───────────────────────────────────────────────────
+
+	parseCssDecl() {
+		const _line = this.peek().line;
+		this.advance(); // consume CSS_KW
+
+		const name = this.expect(T.IDENT).value;
+
+		// Parse parameter list (standard Go params: LPAREN...RPAREN)
+		const params = this.parseParamList();
+
+		// Optional semicolon between ) and {
+		this.semi();
+
+		// Consume opening {
+		this.expect(T.LBRACE);
+
+		// Consume CSS_BODY
+		const bodyToken = this.expect(TT.CSS_BODY);
+		const cssText = bodyToken.value;
+
+		// Consume closing }
+		this.expect(T.RBRACE);
+		this.semi();
+
+		return { kind: "CssDecl", name, params, cssText, _line };
+	}
+
 	// ── TemplDecl ─────────────────────────────────────────────────
 
 	parseTemplDecl() {

package/src/test-runner.js

@@ -6,8 +6,13 @@ import { statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { HELPER_SPRINTF, HELPER_TESTING } from "./backend/js/runtime.js";
 import { colorEnabled, createColors, formatDiagnostic } from "./colors.js";
-import { compilePackageTests, gwFilesIn } from "./compiler.js";
+import {
+	compilePackageTests,
+	compilePackageTestsWasm,
+	gwFilesIn,
+} from "./compiler.js";
 
 export function isTestFunc(decl) {
 	if (decl.kind !== "FuncDecl") return false;
@@ -78,7 +83,16 @@ globalThis.document = globalThis.document ?? null;
 `
 }
 globalThis.__gofront_verbose = ${verbose};
-
+${
+	options.wasmBytes
+		? `
+// ── WASM module (tests run inside app.wasm; *testing.T stays in JS) ──
+${HELPER_SPRINTF}
+${HELPER_TESTING}
+globalThis.__GOFRONT_WASM_BYTES = Uint8Array.from(atob(${JSON.stringify(Buffer.from(options.wasmBytes).toString("base64"))}), (c) => c.charCodeAt(0));
+`
+		: ""
+}
 // ── Compiled Package Bundle ──
 ${bundleJs}
 // ─────────────────────────────
@@ -281,6 +295,44 @@ function spawnTestRunner(resolvedDir, harnessJs, testCount, options) {
 	});
 }
 
+function reportBuildFailure(err, resolvedDir, options) {
+	const msg = err?.message ?? String(err);
+	if (options.captureOutput) {
+		const out = `FAIL\t${basename(resolvedDir)} [build failed]\n${msg}\n`;
+		return { exitCode: 1, stdout: "", stderr: out };
+	}
+	const dest = options.stderr ?? process.stderr;
+	const c = colorsFor(options, dest);
+	dest.write(
+		`${c.bold(c.red("FAIL"))}\t${basename(resolvedDir)} ${c.red("[build failed]")}\n${formatDiagnostic(msg, c)}\n`,
+	);
+	return { exitCode: 1 };
+}
+
+// `both` packages run twice (JS and wasm) so the two backends are kept in
+// agreement; output of both runs is concatenated.
+async function runDualTarget(compiled, resolvedDir, runHarness, options) {
+	let wasmCompiled;
+	try {
+		wasmCompiled = compilePackageTestsWasm(resolvedDir, options);
+	} catch (err) {
+		return reportBuildFailure(err, resolvedDir, options);
+	}
+	const label = compiled.pkgName;
+	const jsRun = await runHarness(compiled.js, `${label} [js]`, null);
+	const wasmRun = await runHarness(
+		wasmCompiled.js,
+		`${label} [wasm]`,
+		wasmCompiled.wasm,
+	);
+	return {
+		exitCode: jsRun.exitCode !== 0 ? jsRun.exitCode : wasmRun.exitCode,
+		stdout: jsRun.stdout + wasmRun.stdout,
+		stderr: jsRun.stderr + wasmRun.stderr,
+		testCount: jsRun.testCount + wasmRun.testCount,
+	};
+}
+
 export async function runTests(targetDir, options = {}) {
 	let resolvedDir = resolve(targetDir);
 	try {
@@ -304,17 +356,7 @@ export async function runTests(targetDir, options = {}) {
 	try {
 		compiled = compilePackageTests(resolvedDir, options);
 	} catch (err) {
-		const msg = err?.message ?? String(err);
-		if (options.captureOutput) {
-			const out = `FAIL\t${basename(resolvedDir)} [build failed]\n${msg}\n`;
-			return { exitCode: 1, stdout: "", stderr: out };
-		}
-		const dest = options.stderr ?? process.stderr;
-		const c = colorsFor(options, dest);
-		dest.write(
-			`${c.bold(c.red("FAIL"))}\t${basename(resolvedDir)} ${c.red("[build failed]")}\n${formatDiagnostic(msg, c)}\n`,
-		);
-		return { exitCode: 1 };
+		return reportBuildFailure(err, resolvedDir, options);
 	}
 
 	const { pkgName, js, programs } = compiled;
@@ -324,12 +366,24 @@ export async function runTests(targetDir, options = {}) {
 		return reportEmptyTests(pkgName, "no tests to run", options);
 	}
 
-	const harnessJs = generateTestHarness(js, testNames, {
-		...options,
-		pkgName,
-		jsdomPath,
-		color: colorsFor(options, options.stdout ?? process.stdout).enabled,
-	});
+	const runHarness = (bundleJs, label, wasmBytes) =>
+		spawnTestRunner(
+			resolvedDir,
+			generateTestHarness(bundleJs, testNames, {
+				...options,
+				pkgName: label,
+				jsdomPath,
+				wasmBytes,
+				color: colorsFor(options, options.stdout ?? process.stdout).enabled,
+			}),
+			testNames.length,
+			options,
+		);
 
-	return spawnTestRunner(resolvedDir, harnessJs, testNames.length, options);
+	// `wasm` packages run inside the linked app.wasm; `js` packages that import
+	// wasm packages need the linked module too (hybrid packages).
+	if (compiled.target === "both") {
+		return runDualTarget(compiled, resolvedDir, runHarness, options);
+	}
+	return runHarness(js, pkgName, compiled.wasm ?? null);
 }

package/src/typechecker/expressions.js

@@ -3,6 +3,7 @@
 import {
 	ANY,
 	BOOL,
+	BROWSER_GLOBALS,
 	COMPLEX128,
 	ERROR,
 	FLOAT64,
@@ -126,6 +127,26 @@ export const expressionCheckMethods = {
 				const t = scope.lookup(expr.name);
 				if (!t) return this.err(`Undefined: '${expr.name}'`, expr);
 				if (this.types.has(expr.name)) expr._isTypeRef = true;
+				if (
+					(this.target === "wasm" || this.target === "both") &&
+					BROWSER_GLOBALS.has(expr.name) &&
+					scope.lookup(expr.name) === this.globals.lookup(expr.name)
+				) {
+					this.recordBlocker("browser global", expr.name);
+					this.err(
+						`'${expr.name}' is not available in wasm packages`,
+						expr,
+						`(package '${this.pkgName}' is //gofront:target ${this.target} — browser globals are only available in js packages)`,
+					);
+				}
+				if (
+					(this.target === "wasm" || this.target === "both") &&
+					expr.name === "gom" &&
+					scope.lookup(expr.name) === this.globals.lookup(expr.name)
+				) {
+					this.recordBlocker("gom usage", "gom");
+					this.err("package 'gom' is not available in wasm packages", expr);
+				}
 				return t;
 			}
 			case "BinaryExpr": {
@@ -136,8 +157,16 @@ export const expressionCheckMethods = {
 					return this.binaryResultType(expr.op, ANY, ANY, expr);
 				return this.binaryResultType(expr.op, lt, rt, expr);
 			}
-			case "AwaitExpr":
+			case "AwaitExpr": {
+				if (this.target === "wasm" || this.target === "both") {
+					this.recordBlocker("async function");
+					this.err(
+						"async functions are not supported in wasm packages; keep async code in a js package",
+						expr,
+					);
+				}
 				return this.checkExpr(expr.expr, scope);
+			}
 			case "InstantiationExpr":
 				return this._checkInstantiationExpr(expr, scope);
 			default: {
@@ -280,6 +309,16 @@ export const expressionCheckMethods = {
 	},
 
 	_checkFuncLit(expr, scope) {
+		if (
+			(this.target === "wasm" || this.target === "both") &&
+			(expr.async || expr.isAsync)
+		) {
+			this.recordBlocker("async function");
+			this.err(
+				"async functions are not supported in wasm packages; keep async code in a js package",
+				expr,
+			);
+		}
 		const inner = new Scope(scope);
 		for (const p of expr.params)
 			inner.define(p.name, p.type ? this.resolveTypeNode(p.type, scope) : ANY);