gofront 1.7.0 → 1.9.0

package/src/backend/js/stdlib/index.js

@@ -1,74 +1,56 @@
 // CodeGen stdlib call generation — installed as a mixin on CodeGen.prototype.
-// One file per Go package under ./stdlib/. This index merges them.
+// Dispatches `gofront/shared` and `gofront/simd` calls to inline JS.
 
-import { base64Methods } from "./base64.js";
-import { binaryMethods } from "./binary.js";
-import { bitsMethods } from "./bits.js";
-import { builderMethods } from "./builder.js";
-import { bytesMethods } from "./bytes.js";
-import { errorsMethods } from "./errors.js";
-import { fmtMethods } from "./fmt.js";
-import { gomMethods } from "./gom.js";
-import { hexMethods } from "./hex.js";
-import { htmlMethods } from "./html.js";
-import { ioMethods } from "./io.js";
-import { jsonMethods } from "./json.js";
-import { mapsMethods } from "./maps.js";
-import { mathMethods } from "./math.js";
-import { osMethods } from "./os.js";
-import { pathMethods } from "./path.js";
-import { randMethods } from "./rand.js";
-import { regexpMethods } from "./regexp.js";
-import { sha256Methods } from "./sha256.js";
-import { sharedMethods } from "./shared.js";
-import { simdMethods } from "./simd.js";
-import { slicesMethods } from "./slices.js";
-import { sortMethods } from "./sort.js";
-import { strconvMethods } from "./strconv.js";
-import { stringsMethods } from "./strings.js";
-import { syncMethods } from "./sync.js";
-import { testingMethods } from "./testing.js";
-import { timeMethods } from "./time.js";
-import { unicodeMethods } from "./unicode.js";
-import { utf8Methods } from "./utf8.js";
+import { SHARED_KINDS } from "../../../typechecker/stdlib/shared.js";
 
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
 // Stdlib namespace → handler method name. Used by _genStdlibCall to dispatch
 // dynamically without creating static call edges.
 const STDLIB_METHOD_MAP = {
-	fmt: "_genFmt",
-	strings: "_genStrings",
-	bytes: "_genBytes",
-	strconv: "_genStrconv",
-	sort: "_genSort",
-	math: "_genMath",
-	bits: "_genBits",
-	unicode: "_genUnicode",
-	os: "_genOs",
-	errors: "_genErrors",
-	time: "_genTime",
-	regexp: "_genRegexp",
-	slices: "_genSlices",
-	maps: "_genMaps",
-	html: "_genHtml",
-	io: "_genIo",
-	rand: "_genRand",
-	utf8: "_genUtf8",
-	path: "_genPath",
-	filepath: "_genPath",
-	testing: "_genTesting",
 	shared: "_genShared",
-	sync: "_genSync",
-	sha256: "_genSha256",
-	binary: "_genBinary",
-	hex: "_genHex",
-	base64: "_genBase64",
-	json: "_genJson",
 	simd: "_genSimd",
 };
 
 const dispatchMethods = {
+	// `gofront/shared`: in js packages a shared buffer is just a TypedArray (no
+	// linear memory is involved); in wasm packages the facade hands out
+	// zero-copy views onto the module memory.
+	_genShared(fn, a) {
+		if (!fn.startsWith("New")) return undefined;
+		const info = SHARED_KINDS[fn.slice(3)];
+		if (!info) return undefined;
+		return `new ${info.ctor}(${a()[0]})`;
+	},
+
+	// `gofront/simd` in JS packages.
+	_genSimd(fn, a) {
+		this.useHelper("simd");
+		const args = a();
+		switch (fn) {
+			case "Splat":
+				return `__simd_splat(${args[0]})`;
+			case "NewF32x4":
+				return `__simd_f32x4(${args[0]}, ${args[1]}, ${args[2]}, ${args[3]})`;
+			case "Select":
+				return `__simd_select(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "Shuffle":
+				return `__simd_shuffle(${args.join(", ")})`;
+			case "LoadF32x4":
+				return `__simd_load(${args[0]}, ${args[1]})`;
+			case "StoreF32x4":
+				return `__simd_store(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "LoadF32x4Slice":
+				return `__simd_load_slice(${args[0]}, ${args[1]})`;
+			case "StoreF32x4Slice":
+				return `__simd_store_slice(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "Pad4":
+				return `(Math.floor((${args[0]} + 3) / 4) * 4)`;
+			default:
+				return undefined;
+		}
+	},
+
 	typeComment(typeNode) {
 		if (!typeNode) return "unknown";
 		switch (typeNode.kind) {
@@ -86,50 +68,25 @@ const dispatchMethods = {
 	// Dispatch table for stdlib namespace calls (pkg.Func → inline JS).
 	// Returns the generated JS string, or undefined if not handled.
 	_genStdlibCall(ns, fn, expr) {
-		// Stdlib shims take raw values; only fmt and errors use the interface box
-		// of a named value (Error() dispatch, error comparisons).
+		const method = STDLIB_METHOD_MAP[ns];
+		if (!method) return undefined;
+		// A member written in Go is an ordinary call of its mangled name.
+		if (expr.func?._stdName) return undefined;
+		// Stdlib shims take raw values, not the interface box of a named value.
 		const isNamespace = expr.func?.expr?._type?.kind === "namespace";
-		if (isNamespace && ns !== "fmt" && ns !== "errors") {
+		if (isNamespace) {
 			for (const e of expr.args) if (e) e._noNamedBox = true;
 		}
 		const a = () => expr.args.map((e) => this.genExpr(e));
-		if (ns === "gom") return this._genGom(fn, expr);
-		const method = STDLIB_METHOD_MAP[ns];
-		return method ? this[method](fn, a, expr) : undefined;
+		const res = this[method](fn, a, expr);
+		if (res === undefined && isNamespace) {
+			for (const e of expr.args) if (e) delete e._noNamedBox;
+		}
+		return res;
 	},
 };
 
 /** @type {ThisType<CodeGen>} */
 export const stdlibGenMethods = {
-	...bitsMethods,
-	...builderMethods,
-	...bytesMethods,
-	...errorsMethods,
-	...fmtMethods,
-	...gomMethods,
-	...htmlMethods,
-	...ioMethods,
-	...mapsMethods,
-	...mathMethods,
-	...osMethods,
-	...pathMethods,
-	...randMethods,
-	...regexpMethods,
-	...sharedMethods,
-	...simdMethods,
-	...slicesMethods,
-	...sortMethods,
-	...strconvMethods,
-	...stringsMethods,
-	...timeMethods,
-	...unicodeMethods,
-	...utf8Methods,
-	...testingMethods,
-	...syncMethods,
-	...sha256Methods,
-	...binaryMethods,
-	...hexMethods,
-	...base64Methods,
-	...jsonMethods,
 	...dispatchMethods,
 };

package/src/backend/js/templ.js

@@ -2,9 +2,6 @@
 // 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>} */
@@ -16,13 +13,22 @@ export const templGenMethods = {
 			)
 			.join(", ");
 		this.line(`function ${decl.name}(${params}) {`);
+		const prevBoxed = this._boxedVars;
+		this._boxedVars = new Set(this._boxedGlobals);
 		this.indented(() => {
+			// `@W(xs...)` passes `{ __sp: xs }` like any Go variadic call.
+			const last = decl.params[decl.params.length - 1];
+			if (last?.variadic && last.name && last.name !== "_") {
+				this.useHelper("va");
+				this.line(`${last.name} = __va(${last.name});`);
+			}
 			this.line(`return {Mount(___p, ___refs) {`);
 			this.indented(() => {
 				this._genTemplNodes(decl.body, "___p");
 			});
 			this.line(`}};`);
 		});
+		this._boxedVars = prevBoxed;
 		this.line("}");
 	},
 
@@ -79,15 +85,21 @@ export const templGenMethods = {
 				);
 			case "TemplExpr":
 				return this.line(
-					`${p}.appendChild(document.createTextNode(String(${this._genTemplTokenExpr(node.tokens)})));`,
+					`${p}.appendChild(document.createTextNode(String(${this._genTemplExpr(node, '""')})));`,
 				);
 			case "TemplComponent":
 				return this._genTemplComponentMount(node, p);
-			case "TemplChildren":
-				// children is a variadic gom.Node param — mount each child
+			case "TemplChildren": {
+				// `{ name... }`: mount each node of a variadic gom.Node parameter
+				// (nil mounts nothing). `children` may also be absent altogether.
+				const slot =
+					node.name === "children"
+						? `(typeof children!=="undefined"?children:null)`
+						: this._genTemplExpr(node, "null");
 				return this.line(
-					`if(typeof children!=="undefined")(Array.isArray(children)?children:[...children]).forEach(___c=>___c?.Mount?.(${p}));`,
+					`for (const ___c of ${slot} ?? []) ___c?.Mount?.(${p});`,
 				);
+			}
 			case "TemplIf":
 				return this._genTemplIf(node, p);
 			case "TemplFor":
@@ -101,20 +113,12 @@ export const templGenMethods = {
 
 	_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);
+		if (node.raw) {
+			const argJs = this._genTemplExpr(node, '""');
 			return this.line(`${p}.insertAdjacentHTML("beforeend", ${argJs});`);
 		}
 		return this.line(
-			`(${this._genTemplTokenCallExpr(node.tokens)}).Mount(${p}, ___refs);`,
+			`(${this._genTemplExpr(node, "null")}).Mount(${p}, ___refs);`,
 		);
 	},
 
@@ -160,7 +164,7 @@ export const templGenMethods = {
 				);
 			}
 		} else if (attr.kind === "expr") {
-			const exprJs = this._genTemplTokenExpr(attr.tokens);
+			const exprJs = this._genTemplExpr(attr, '""');
 			if (name === "class") {
 				this.line(setClass(exprJs));
 			} else {
@@ -171,7 +175,7 @@ export const templGenMethods = {
 		} else if (attr.kind === "bool") {
 			this.line(`${el}.setAttribute(${JSON.stringify(name)}, "");`);
 		} else if (attr.kind === "cond-bool") {
-			const exprJs = this._genTemplTokenExpr(attr.tokens);
+			const exprJs = this._genTemplExpr(attr, '""');
 			this.line(
 				`if(${exprJs})${el}.setAttribute(${JSON.stringify(name)}, "");`,
 			);
@@ -179,7 +183,7 @@ export const templGenMethods = {
 	},
 
 	_genTemplIf(node, p) {
-		const condJs = this._genTemplCondTokens(node.condTokens);
+		const condJs = this._genTemplExpr(node, "false");
 		this.line(`if (${condJs}) {`);
 		this.indented(() => this._genTemplNodes(node.then, p));
 		this._genTemplIfElse(node.else_, p);
@@ -192,7 +196,7 @@ export const templGenMethods = {
 		}
 		if (else_.length === 1 && else_[0].kind === "TemplIf") {
 			const elseIf = else_[0];
-			this.line(`} else if (${this._genTemplCondTokens(elseIf.condTokens)}) {`);
+			this.line(`} else if (${this._genTemplExpr(elseIf, "false")}) {`);
 			this.indented(() => this._genTemplNodes(elseIf.then, p));
 			this._genTemplIfElse(elseIf.else_, p);
 		} else {
@@ -203,17 +207,20 @@ export const templGenMethods = {
 	},
 
 	_genTemplSwitch(node, p) {
-		const { exprTokens, cases } = node;
+		const { cases } = node;
 		if (cases.length === 0) return;
-		const exprJs = this._genTemplTokenExpr(exprTokens);
+		// `switch { case cond: }` compares each condition with `true`.
+		const exprJs = this._genTemplExpr(node, "true");
 		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}: {`);
+				if (c.caseTokens === null) this.line("default: {");
+				else {
+					// One JS label per value of `case a, b:`.
+					if (c.exprError) throw c.exprError;
+					const labels = (c.exprs ?? []).map((e) => `case ${this.genExpr(e)}:`);
+					this.line(`${labels.join(" ") || 'case "":'} {`);
+				}
 				this.indented(() => this._genTemplNodes(c.body, p));
 				this.line(`break; }`);
 			}
@@ -221,106 +228,48 @@ export const templGenMethods = {
 		this.line(`}`);
 	},
 
+	// The header is a parsed Go `for` statement, so it goes through the regular
+	// loop generator; its body is a statement that mounts the templ nodes.
 	_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]?.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("}");
+		if (node.forError) throw node.forError;
+		if (!node.forStmt)
+			throw new Error("templ for header was not parsed by TemplParser");
+		const mount = { kind: "TemplMount", parent: p };
+		// Hidden from the generic AST walkers: they know no templ node kinds.
+		Object.defineProperty(mount, "nodes", { value: node.body });
+		this.genFor({
+			...node.forStmt,
+			body: { kind: "Block", stmts: [mount] },
+		});
 	},
 
-	_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.useHelper("sliceGuard");
-		return `for (const [${keyName}, ${valName}] of __s(${iterJs}).entries()) {`;
+	_genTemplMountStmt(stmt) {
+		this._genTemplNodes(stmt.nodes, stmt.parent);
 	},
 
-	// 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);
+	// Emit JS for the Go expression TemplParser parsed onto `node`. `emptyJs` is
+	// the value when the node holds no tokens. A parse error is raised here,
+	// not in the parser, so it surfaces at the same point as it always did.
+	_genTemplExpr(node, emptyJs) {
+		if (node.exprError) throw node.exprError;
+		if (node.expr === undefined)
+			throw new Error("templ expression was not parsed by TemplParser");
+		return node.expr ? this.genExpr(node.expr) : emptyJs;
 	},
 
-	// 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);
+	// Rename handlers for `_renameReservedIdents`: templ bodies keep their Go
+	// expressions in non-enumerable props (see parser/templ.js), which its
+	// generic walk does not visit, so `class` in `{ class }` would stay unsafe.
+	_renameTemplExprNode(node) {
+		this._renameReservedIdents(node.expr);
 	},
 
-	// 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);
+	_renameTemplForNode(node) {
+		this._renameReservedIdents(node.forStmt);
 	},
 
-	_tokensToSource(tokens) {
-		return tokens.map((t) => t.value).join(" ");
+	_renameTemplElementNode(node) {
+		for (const attr of node.attrs ?? []) this._renameReservedIdents(attr.expr);
 	},
 
 	// Fresh variable name counter