gofront 1.6.0 → 1.7.0

package/src/backend/js/stdlib/fmt.js

@@ -3,16 +3,30 @@
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
 const _SSCAN_LOOP =
-	`let n = 0; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { ` +
-	`const t = tokens[i]; const p = ptrs[i]; ` +
-	`if (typeof p.value === "number") p.value = Number(t); ` +
-	`else if (typeof p.value === "boolean") p.value = t === "true"; ` +
+	`let n = 0, err = null; for (let i = 0; i < ptrs.length && i < tokens.length; i++) { ` +
+	`const item = tokens[i]; const t = typeof item === "object" && item !== null ? item.t : item; const verb = item?.verb; const p = ptrs[i]; ` +
+	`if (verb === "%c") { p.value = t.codePointAt ? t.codePointAt(0) : t; } ` +
+	`else if (verb === "%x" || verb === "%X") { const clean = t.replace(/^0[xX]/, ""); const v = parseInt(clean, 16); if (isNaN(v)) { err = __error("expected hex number"); break; } p.value = typeof p.value === "bigint" ? BigInt("0x" + clean) : v; } ` +
+	`else if (verb === "%o") { const clean = t.replace(/^0[oO]?/, ""); const v = parseInt(clean, 8); if (isNaN(v)) { err = __error("expected octal number"); break; } p.value = typeof p.value === "bigint" ? BigInt("0o" + clean) : v; } ` +
+	`else if (verb === "%b") { const clean = t.replace(/^0[bB]/, ""); const v = parseInt(clean, 2); if (isNaN(v)) { err = __error("expected binary number"); break; } p.value = typeof p.value === "bigint" ? BigInt("0b" + clean) : v; } ` +
+	`else if (typeof p.value === "number") { const v = Number(t); if (Number.isNaN(v) || !/^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?$/.test(t)) { err = __error("expected number"); break; } p.value = v; } ` +
+	`else if (typeof p.value === "bigint") { try { if (!/^[+-]?\\d+$/.test(t)) throw 1; p.value = BigInt(t); } catch { err = __error("expected integer"); break; } } ` +
+	`else if (typeof p.value === "boolean") { const tl = String(t).toLowerCase(); if (tl === "true" || tl === "1" || tl === "t") p.value = true; else if (tl === "false" || tl === "0" || tl === "f") p.value = false; else { err = __error("expected boolean"); break; } } ` +
 	`else p.value = t; n++; }`;
 
 /** @type {ThisType<CodeGen>} */
 export const fmtMethods = {
+	_fmtArgJs(e) {
+		const js = this.genExpr(e);
+		const base =
+			e?._type?.kind === "named" ? (e._type.underlying ?? e._type) : e?._type;
+		return base?.kind === "slice" ? `(${js} ?? [])` : js;
+	},
+
 	_genFmt(fn, _a, expr) {
-		const fmtArgs = expr.args.map((e) => this.genExpr(e)).join(", ");
+		const fmtArgs = expr.args
+			.map((e, idx) => (idx === 0 ? this.genExpr(e) : this._fmtArgJs(e)))
+			.join(", ");
 		switch (fn) {
 			case "Sprintf":
 				this.useHelper("sprintf");
@@ -42,29 +56,72 @@ export const fmtMethods = {
 			case "Fprint":
 				return this._genFmtFprint(fn, expr);
 			case "Sscan": {
+				this.useHelper("error");
 				const strArg = this.genExpr(expr.args[0]);
 				const restArgs = expr.args
 					.slice(1)
 					.map((e) => this.genExpr(e))
 					.join(", ");
-				return `((str, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, n < ptrs.length ? "unexpected EOF" : null]; })(${strArg}, ${restArgs})`;
+				return `((str, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, err ? err : (n < ptrs.length ? __error("unexpected EOF") : null)]; })(${strArg}, ${restArgs})`;
 			}
 			case "Sscanln": {
+				this.useHelper("error");
 				const strArg = this.genExpr(expr.args[0]);
 				const restArgs = expr.args
 					.slice(1)
 					.map((e) => this.genExpr(e))
 					.join(", ");
-				return `((str, ...ptrs) => { const tokens = str.split("\\n")[0].trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, n < ptrs.length ? "unexpected EOF" : null]; })(${strArg}, ${restArgs})`;
+				return `((str, ...ptrs) => { const tokens = str.split("\\n")[0].trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, err ? err : (n < ptrs.length ? __error("unexpected EOF") : null)]; })(${strArg}, ${restArgs})`;
 			}
 			case "Sscanf": {
+				this.useHelper("error");
 				const strArg = this.genExpr(expr.args[0]);
 				const fmtArg = this.genExpr(expr.args[1]);
 				const restArgs = expr.args
 					.slice(2)
 					.map((e) => this.genExpr(e))
 					.join(", ");
-				return `((str, _fmt, ...ptrs) => { const tokens = str.trim().split(/\\s+/).filter(Boolean); ${_SSCAN_LOOP} return [n, n < ptrs.length ? "input does not match format" : null]; })(${strArg}, ${fmtArg}, ${restArgs})`;
+				return (
+					`((str, fmt, ...ptrs) => { ` +
+					`const s = String(str); const f = String(fmt); ` +
+					`let si = 0, fi = 0; const tokens = []; let parseErr = null; ` +
+					`while (fi < f.length) { ` +
+					`if (/\\s/.test(f[fi])) { ` +
+					`while (fi < f.length && /\\s/.test(f[fi])) fi++; ` +
+					`while (si < s.length && /\\s/.test(s[si])) si++; ` +
+					`continue; ` +
+					`} ` +
+					`if (f[fi] === "%") { ` +
+					`if (fi + 1 < f.length && f[fi + 1] === "%") { ` +
+					`if (s[si] !== "%") { parseErr = __error("input does not match format"); break; } ` +
+					`si++; fi += 2; continue; ` +
+					`} ` +
+					`const vm = f.slice(fi).match(/^%[vdsfqtxXbcoeEfFgG]/); ` +
+					`if (vm) { ` +
+					`const verb = vm[0]; fi += verb.length; ` +
+					`if (verb !== "%c") { while (si < s.length && /\\s/.test(s[si])) si++; } ` +
+					`if (si >= s.length) break; ` +
+					`let tokRe = /^\\S+/; ` +
+					`if (verb === "%d" || verb === "%i") tokRe = /^[+-]?\\d+/; ` +
+					`else if (verb === "%o") tokRe = /^[+-]?(?:0[oO])?[0-7]+/; ` +
+					`else if (verb === "%b") tokRe = /^[+-]?(?:0[bB])?[01]+/; ` +
+					`else if (verb === "%f" || verb === "%F" || verb === "%e" || verb === "%E" || verb === "%g" || verb === "%G") tokRe = /^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?/; ` +
+					`else if (verb === "%t") tokRe = /^(?:true|false|1|0|t|f|T|F|TRUE|FALSE)/; ` +
+					`else if (verb === "%x" || verb === "%X") tokRe = /^[+-]?(?:0x)?[0-9a-fA-F]+/; ` +
+					`else if (verb === "%c") tokRe = /^[\\s\\S]/; ` +
+					`const m = s.slice(si).match(tokRe); ` +
+					`if (!m) { parseErr = __error("input does not match format"); break; } ` +
+					`tokens.push({ t: m[0], verb }); si += m[0].length; continue; ` +
+					`} ` +
+					`} ` +
+					`if (si >= s.length) break; ` +
+					`if (s[si] !== f[fi]) { parseErr = __error("input does not match format"); break; } ` +
+					`si++; fi++; ` +
+					`} ` +
+					`${_SSCAN_LOOP} ` +
+					`return [n, parseErr || err || (n < ptrs.length ? __error("unexpected EOF") : null)]; ` +
+					`})(${strArg}, ${fmtArg}, ${restArgs})`
+				);
 			}
 			default:
 				return undefined;
@@ -75,7 +132,7 @@ export const fmtMethods = {
 		this.useHelper("sprintf");
 		const writerArg = expr.args[0];
 		const rest = expr.args.slice(1);
-		const restJs = rest.map((e) => this.genExpr(e)).join(", ");
+		const restJs = rest.map((e) => this._fmtArgJs(e)).join(", ");
 		const writerType = writerArg._type;
 		const targetTypeName =
 			writerType?.name ??
@@ -84,16 +141,16 @@ export const fmtMethods = {
 		if (targetTypeName === "strings.Builder") {
 			const w = this.genExpr(writerArg);
 			const base = this._unboxWriter(w);
-			return `(${base}._buf += ${sprintfCall})`;
+			return `((__b, __s) => { __b._buf += __s; return [__s.length, null]; })(${base}, ${sprintfCall})`;
 		}
 		if (targetTypeName === "bytes.Buffer") {
 			const w = this.genExpr(writerArg);
 			const base = this._unboxWriter(w);
-			return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, ${sprintfCall})`;
+			return `((__b, __s) => { const __bytes = new TextEncoder().encode(__s); for (let i = 0; i < __bytes.length; i++) __b._buf.push(__bytes[i]); return [__bytes.length, null]; })(${base}, ${sprintfCall})`;
 		}
 		// Generic io.Writer fallback — call .WriteString if available
 		const w = this.genExpr(writerArg);
-		return `${w}.WriteString(${sprintfCall})`;
+		return `((__w, __s) => typeof __w.WriteString === "function" ? __w.WriteString(__s) : __w.Write(new TextEncoder().encode(__s)))(${w}, ${sprintfCall})`;
 	},
 
 	_genStdoutWrite(strJs) {
@@ -106,7 +163,7 @@ export const fmtMethods = {
 		const argc = expr.args.length;
 		if (argc === 0) return JSON.stringify(suffix);
 		const fmt = Array(argc).fill("%v").join(sep) + suffix;
-		const args = expr.args.map((e) => this.genExpr(e)).join(", ");
+		const args = expr.args.map((e) => this._fmtArgJs(e)).join(", ");
 		return `__sprintf(${JSON.stringify(fmt)}, ${args})`;
 	},
 

package/src/backend/js/stdlib/hex.js

@@ -0,0 +1,17 @@
+// src/backend/js/stdlib/hex.js
+// CodeGen for Go encoding/hex package.
+
+export const hexMethods = {
+	_genHex(fn, a) {
+		this.useHelper("hex");
+		this.useHelper("error");
+		const args = a();
+		if (fn === "EncodeToString") return `__hex_encode_to_string(${args[0]})`;
+		if (fn === "DecodeString") return `__hex_decode_string(${args[0]})`;
+		if (fn === "Encode") return `__hex_encode(${args[0]}, ${args[1]})`;
+		if (fn === "Decode") return `__hex_decode(${args[0]}, ${args[1]})`;
+		if (fn === "EncodedLen") return `(${args[0]} * 2)`;
+		if (fn === "DecodedLen") return `Math.floor(${args[0]} / 2)`;
+		return undefined;
+	},
+};

package/src/backend/js/stdlib/html.js

@@ -12,7 +12,7 @@ export const htmlMethods = {
 			}
 			case "UnescapeString": {
 				const [s] = a();
-				return `${s}.replace(/&#39;/g,"'").replace(/&#34;/g,'"').replace(/&gt;/g,">").replace(/&lt;/g,"<").replace(/&amp;/g,"&")`;
+				return `(${s}).replace(/&(?:quot|apos|#39|#34|gt|lt|amp|#(?:[0-9]+|[xX][0-9a-fA-F]+));/g, m => { switch (m) { case "&quot;": case "&#34;": return '"'; case "&apos;": case "&#39;": return "'"; case "&gt;": return ">"; case "&lt;": return "<"; case "&amp;": return "&"; default: { if (m.startsWith("&#")) { const raw = m.slice(2, -1); const cp = (raw.startsWith("x") || raw.startsWith("X")) ? parseInt(raw.slice(1), 16) : parseInt(raw, 10); return (cp >= 0 && cp <= 0x10FFFF && !(cp >= 0xD800 && cp <= 0xDFFF)) ? String.fromCodePoint(cp) : "\\uFFFD"; } return m; } } })`;
 			}
 		}
 		return undefined;

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

@@ -1,25 +1,32 @@
 // CodeGen stdlib call generation — installed as a mixin on CodeGen.prototype.
 // One file per Go package under ./stdlib/. This index merges them.
 
+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";
@@ -49,8 +56,16 @@ const STDLIB_METHOD_MAP = {
 	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 = {
@@ -71,6 +86,12 @@ 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 isNamespace = expr.func?.expr?._type?.kind === "namespace";
+		if (isNamespace && ns !== "fmt" && ns !== "errors") {
+			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];
@@ -95,6 +116,7 @@ export const stdlibGenMethods = {
 	...randMethods,
 	...regexpMethods,
 	...sharedMethods,
+	...simdMethods,
 	...slicesMethods,
 	...sortMethods,
 	...strconvMethods,
@@ -103,5 +125,11 @@ export const stdlibGenMethods = {
 	...unicodeMethods,
 	...utf8Methods,
 	...testingMethods,
+	...syncMethods,
+	...sha256Methods,
+	...binaryMethods,
+	...hexMethods,
+	...base64Methods,
+	...jsonMethods,
 	...dispatchMethods,
 };

package/src/backend/js/stdlib/io.js

@@ -5,6 +5,7 @@
 /** @type {ThisType<CodeGen>} */
 export const ioMethods = {
 	_genIo(fn, _a, expr) {
+		if (fn === "ReadAll") this.useHelper("error");
 		switch (fn) {
 			case "WriteString": {
 				const writerArg = expr.args[0];
@@ -19,15 +20,116 @@ export const ioMethods = {
 					return `((b,s) => { b._buf += s; return [s.length, null]; })(${base}, ${s})`;
 				}
 				if (typeName === "bytes.Buffer") {
-					return `((b,s) => { b._buf.push(...new TextEncoder().encode(s)); return [s.length, null]; })(${base}, ${s})`;
+					return `((b,s) => { const bytes = new TextEncoder().encode(s); for (let i = 0; i < bytes.length; i++) b._buf.push(bytes[i]); return [bytes.length, null]; })(${base}, ${s})`;
 				}
 				// Generic: auto-dereference pointer, then dispatch on concrete writer type.
 				// strings.Builder has { _buf: string }, bytes.Buffer has { _buf: [] }.
-				return `((b,s) => { const w = b?.value ?? b; if (typeof w.WriteString === "function") return [w.WriteString(s), null]; if (typeof w._buf === "string") { w._buf += s; return [s.length, null]; } if (Array.isArray(w._buf)) { w._buf.push(...new TextEncoder().encode(s)); return [s.length, null]; } return [0, "io.WriteString: unsupported writer"]; })(${w}, ${s})`;
+				return `((b,s) => { const w = b?.value ?? b; if (typeof w.WriteString === "function") return w.WriteString(s); if (typeof w._buf === "string") { w._buf += s; return [s.length, null]; } if (Array.isArray(w._buf)) { const bytes = new TextEncoder().encode(s); for (let i = 0; i < bytes.length; i++) w._buf.push(bytes[i]); return [bytes.length, null]; } if (typeof w.Write === "function") return w.Write(new TextEncoder().encode(s)); return [0, "io.WriteString: unsupported writer"]; })(${w}, ${s})`;
 			}
 			case "ReadAll": {
+				this.useHelper("ioEOF");
 				const r = this.genExpr(expr.args[0]);
-				return `((r) => { const w = r?.value ?? r; if (typeof w._src === "string") { const s = w._src.slice(w._pos); w._pos = w._src.length; return [[...s].map(c => c.charCodeAt(0)), null]; } if (Array.isArray(w._src)) { const b = w._src.slice(w._pos); w._pos = w._src.length; return [b, null]; } const chunks = []; const buf = new Array(4096); let err = null; while (!err) { const [n, e] = w.Read(buf); if (n > 0) chunks.push(...buf.slice(0, n)); err = e; } return [chunks, err === "EOF" ? null : err]; })(${r})`;
+				return `((r) => { const w = r?.value ?? r; const chunks = []; const buf = new Uint8Array(512); let err = null; while (!err) { const [n, e] = w.Read(buf); if (n > 0) { for (let i = 0; i < n; i++) chunks.push(buf[i]); } if (n === 0 && !e) break; err = e; } return [new Uint8Array(chunks), (err === "EOF" || err === __io_eof || err?._msg === "EOF") ? null : err]; })(${r})`;
+			}
+			case "LimitReader": {
+				this.useHelper("ioEOF");
+				const r = this.genExpr(expr.args[0]);
+				const n = this.genExpr(expr.args[1]);
+				return `((r, n) => {
+					let rem = typeof n === "bigint" ? Number(n) : Number(n);
+					const reader = r?.value ?? r;
+					return {
+						Read(buf) {
+							if (rem <= 0) return [0, __io_eof];
+							const max = buf.length > rem ? rem : buf.length;
+							const slice = buf.subarray ? buf.subarray(0, max) : buf.slice(0, max);
+							const [readN, err] = reader.Read(slice);
+							if (readN > 0) {
+								if (buf.set && slice !== buf) buf.set(slice.subarray(0, readN), 0);
+								rem -= readN;
+							}
+							return [readN, err];
+						}
+					};
+				})(${r}, ${n})`;
+			}
+			case "Copy": {
+				this.useHelper("ioEOF");
+				const dst = this.genExpr(expr.args[0]);
+				const src = this.genExpr(expr.args[1]);
+				return `((dst, src) => {
+					const w = dst?.value ?? dst;
+					const r = src?.value ?? src;
+					const writeChunk = (chunk) => {
+						if (typeof w?.Write === "function") return w.Write(chunk);
+						if (Array.isArray(w?._buf)) {
+							for (let i = 0; i < chunk.length; i++) w._buf.push(chunk[i]);
+							return [chunk.length, null];
+						}
+						if (typeof w?._buf === "string") {
+							w._buf += new TextDecoder().decode(chunk);
+							return [chunk.length, null];
+						}
+						return [0, "unsupported writer"];
+					};
+					const buf = new Uint8Array(32 * 1024);
+					let total = 0;
+					while (true) {
+						const [n, rerr] = r.Read(buf);
+						if (n > 0) {
+							const chunk = buf.subarray(0, n);
+							const [wn, werr] = writeChunk(chunk);
+							total += wn;
+							if (werr) return [total, werr];
+						}
+						if (rerr) {
+							if (rerr === "EOF" || rerr === __io_eof || rerr?._msg === "EOF") return [total, null];
+							return [total, rerr];
+						}
+					}
+				})(${dst}, ${src})`;
+			}
+			case "CopyN": {
+				this.useHelper("ioEOF");
+				const dst = this.genExpr(expr.args[0]);
+				const src = this.genExpr(expr.args[1]);
+				const n = this.genExpr(expr.args[2]);
+				return `((dst, src, n) => {
+					const w = dst?.value ?? dst;
+					const r = src?.value ?? src;
+					const writeChunk = (chunk) => {
+						if (typeof w?.Write === "function") return w.Write(chunk);
+						if (Array.isArray(w?._buf)) {
+							for (let i = 0; i < chunk.length; i++) w._buf.push(chunk[i]);
+							return [chunk.length, null];
+						}
+						if (typeof w?._buf === "string") {
+							w._buf += new TextDecoder().decode(chunk);
+							return [chunk.length, null];
+						}
+						return [0, "unsupported writer"];
+					};
+					let rem = typeof n === "bigint" ? Number(n) : Number(n);
+					let total = 0;
+					const buf = new Uint8Array(32 * 1024);
+					while (rem > 0) {
+						const toRead = rem < buf.length ? rem : buf.length;
+						const [rn, rerr] = r.Read(buf.subarray(0, toRead));
+						if (rn > 0) {
+							const [wn, werr] = writeChunk(buf.subarray(0, rn));
+							total += wn;
+							rem -= wn;
+							if (werr) return [total, werr];
+						}
+						if (rerr) {
+							if ((rerr === "EOF" || rerr === __io_eof || rerr?._msg === "EOF") && rem === 0) {
+								return [total, null];
+							}
+							return [total, rerr];
+						}
+					}
+					return [total, null];
+				})(${dst}, ${src}, ${n})`;
 			}
 		}
 		return undefined;