gofront 1.0.0 → 1.0.1

package/README.md

@@ -634,7 +634,7 @@ Design documents for planned features are organised by release under `docs/v*/`
 ## Tests
 
 ```sh
-npm run test:unit   # unit tests only (~1118 tests, no browser required)
+npm run test:unit   # unit tests only (~1100 tests, no browser required)
 npm run test:e2e    # E2E tests (Playwright, headless Chromium)
 npm run test:all    # both
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.0.0",
+	"version": "1.0.1",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {

package/src/cli-core.js

@@ -0,0 +1,65 @@
+// 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 { compileDir, compileSingleFile } from "./compiler.js";
+import { minify } from "./minifier.js";
+
+export function runCompile(inputPath, isDir, options) {
+	const {
+		sourceMap = false,
+		outputFile = null,
+		dumpTokens = false,
+		dumpAst = false,
+	} = options ?? {};
+
+	if (isDir) {
+		const outputDir = outputFile ? dirname(resolve(outputFile)) : resolve(".");
+		return compileDir(inputPath, { sourceMap, outputDir });
+	}
+
+	return compileSingleFile(inputPath, {
+		sourceMap,
+		outputFile,
+		dumpTokens,
+		dumpAst,
+	});
+}
+
+export function maybeMinify(js, options) {
+	const {
+		minify: doMinify = false,
+		mangle = false,
+		sourceMap = false,
+	} = options ?? {};
+	if (!doMinify) return js;
+	if (sourceMap)
+		throw new Error("--source-map and --minify cannot be used together");
+	return minify(js, { mangle });
+}
+
+export function handleInit(targetDir) {
+	try {
+		mkdirSync(targetDir, { recursive: true });
+	} catch (e) {
+		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`;
+
+	try {
+		writeFileSync(mainPath, template);
+	} catch (e) {
+		throw new Error(`cannot write '${mainPath}': ${e.message}`);
+	}
+
+	return { mainPath };
+}

package/src/codegen/expressions.js

@@ -2,6 +2,8 @@
 
 import { ERROR, isComplex } from "../typechecker/types.js";
 
+/** @typedef {import('./index.js').CodeGen} CodeGen */
+
 // Namespace constants: pkg.Field → JS literal
 const NS_CONSTANTS = {
 	math: {
@@ -143,6 +145,7 @@ const EXPR_GEN_DELEGATE = {
 	TypeAssertExpr: "_genTypeAssertExpr",
 };
 
+/** @type {ThisType<CodeGen>} */
 export const expressionGenMethods = {
 	genExpr(expr) {
 		switch (expr.kind) {

package/src/codegen/statements.js

@@ -2,6 +2,8 @@
 
 import { isComplex } from "../typechecker/types.js";
 
+/** @typedef {import('./index.js').CodeGen} CodeGen */
+
 // Method-name dispatch for genStmt — string values add no static call edges.
 const STMT_GEN_DELEGATE = {
 	VarDecl: "genVarDecl",
@@ -15,6 +17,7 @@ const STMT_GEN_DELEGATE = {
 	BranchStmt: "_genBranchStmt",
 };
 
+/** @type {ThisType<CodeGen>} */
 export const statementGenMethods = {
 	genBlock(block) {
 		for (const stmt of block.stmts) this.genStmt(stmt);

package/src/codegen/stdlib/builder.js

@@ -1,5 +1,7 @@
 // CodeGen for `strings.Builder` and `bytes.Buffer` method calls.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const BUILDER_STR = {
 	WriteString: (b, a) => `(${b}._buf += ${a[0]}, [${a[0]}.length, null])`,
 	WriteByte: (b, a) => `(${b}._buf += String.fromCodePoint(${a[0]}))`,
@@ -22,6 +24,7 @@ const BUILDER_COMMON = {
 	Grow: () => "undefined",
 };
 
+/** @type {ThisType<CodeGen>} */
 export const builderMethods = {
 	_genBuilderCall(typeName, method, expr) {
 		const recv = expr.func.expr;

package/src/codegen/stdlib/bytes.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `bytes` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const __bs = `(b => String.fromCharCode(...b))`;
 const __sb = `(s => [...s].map(c => c.charCodeAt(0)))`;
 
@@ -54,6 +56,7 @@ const BYTES_DISPATCH = {
 		`{_src: ${a[0]}, _pos: 0, Read(p) { const n = Math.min(p.length, this._src.length - this._pos); for (let i = 0; i < n; i++) p[i] = this._src[this._pos + i]; this._pos += n; return [n, n === 0 ? "EOF" : null]; }, Len() { return this._src.length - this._pos; }, Reset(b) { this._src = b; this._pos = 0; }}`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const bytesMethods = {
 	_genBytes(fn, a) {
 		const gen = BYTES_DISPATCH[fn];

package/src/codegen/stdlib/errors.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `errors` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const errorsMethods = {
 	_genErrors(fn, a) {
 		const args = a();

package/src/codegen/stdlib/fmt.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `fmt` package — installed onto CodeGen.prototype via stdlibGenMethods.
 
+/** @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]; ` +
@@ -7,6 +9,7 @@ const _SSCAN_LOOP =
 	`else if (typeof p.value === "boolean") p.value = t === "true"; ` +
 	`else p.value = t; n++; }`;
 
+/** @type {ThisType<CodeGen>} */
 export const fmtMethods = {
 	_genFmt(fn, _a, expr) {
 		const fmtArgs = expr.args.map((e) => this.genExpr(e)).join(", ");

package/src/codegen/stdlib/gom.js

@@ -1,5 +1,7 @@
 // CodeGen for the GoFront-built-in `gom` DOM-rendering package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const GOM_ELEMENT_TAGS = {
 	Div: "div",
 	Section: "section",
@@ -85,6 +87,7 @@ const GOM_PROP_SETTERS = {
 	Placeholder: "placeholder",
 };
 
+/** @type {ThisType<CodeGen>} */
 export const gomMethods = {
 	_genGom(fn, expr) {
 		const a = () =>

package/src/codegen/stdlib/html.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `html` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const htmlMethods = {
 	_genHtml(fn, a) {
 		switch (fn) {

package/src/codegen/stdlib/index.js

@@ -22,6 +22,8 @@ import { timeMethods } from "./time.js";
 import { unicodeMethods } from "./unicode.js";
 import { utf8Methods } from "./utf8.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 = {
@@ -70,6 +72,7 @@ const dispatchMethods = {
 	},
 };
 
+/** @type {ThisType<CodeGen>} */
 export const stdlibGenMethods = {
 	...builderMethods,
 	...bytesMethods,

package/src/codegen/stdlib/io.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `io` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const ioMethods = {
 	_genIo(fn, _a, expr) {
 		switch (fn) {

package/src/codegen/stdlib/maps.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `maps` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const mapsMethods = {
 	_genMaps(fn, a) {
 		if (fn === "Equal") {

package/src/codegen/stdlib/math.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `math` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const MATH1 = {
 	Abs: "abs",
 	Floor: "floor",
@@ -41,6 +43,7 @@ const MATH_EXTRA = {
 	Remainder: ([x, y]) => `(${x} - Math.round(${x} / ${y}) * ${y})`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const mathMethods = {
 	_genMath(fn, a) {
 		const args = a();

package/src/codegen/stdlib/os.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `os` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const osMethods = {
 	_genOs(fn, a) {
 		const args = a();

package/src/codegen/stdlib/path.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `path` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const PATH_DISPATCH = {
 	Base: (a) =>
 		`((p) => { if (!p) return "."; const stripped = p.replace(/\\/+$/, ""); if (!stripped) return "/"; const i = stripped.lastIndexOf("/"); return i < 0 ? stripped : stripped.slice(i + 1) || "/"; })(${a[0]})`,
@@ -14,6 +16,7 @@ const PATH_DISPATCH = {
 		`((pat, name) => { try { const sp=/[.+^$()|[\\]\\\\]/g; const re = new RegExp("^" + pat.replace(sp, "\\\\$&").replace(/\\*/g, "[^/]*").replace(/\\?/g, "[^/]") + "$"); return [re.test(name), null]; } catch(e) { return [false, "syntax error in pattern"]; } })(${a[0]}, ${a[1]})`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const pathMethods = {
 	_genPath(fn, a, expr) {
 		if (fn === "Join") {

package/src/codegen/stdlib/rand.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `math/rand` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const RAND_DISPATCH = {
 	Intn: (a) => `Math.floor(Math.random() * ${a[0]})`,
 	Int63n: (a) => `Math.floor(Math.random() * ${a[0]})`,
@@ -16,6 +18,7 @@ const RAND_DISPATCH = {
 		`((n) => { const a = Array.from({length: n}, (_, i) => i); for (let i = n - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; })(${a[0]})`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const randMethods = {
 	_genRand(fn, a) {
 		const gen = RAND_DISPATCH[fn];

package/src/codegen/stdlib/regexp.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `regexp` package and `*Regexp` methods.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const REGEXP_METHOD = {
 	MatchString: (re, a) => `${re}.test(${a[0]})`,
 	FindString: (re, a) => `(${re}.exec(${a[0]})?.[0] ?? "")`,
@@ -19,6 +21,7 @@ const REGEXP_METHOD = {
 	String: (re) => `${re}.source`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const regexpMethods = {
 	_genRegexp(fn, a) {
 		// Converts a Go regexp pattern string (which may contain inline flags like (?i))

package/src/codegen/stdlib/slices.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `slices` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const SLICES_DISPATCH = {
 	Contains: (a) => `${a[0]}.includes(${a[1]})`,
 	Index: (a) => `${a[0]}.indexOf(${a[1]})`,
@@ -35,6 +37,7 @@ const SLICES_DISPATCH = {
 	Clip: (a) => `${a[0]}.slice()`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const slicesMethods = {
 	_genSlices(fn, a) {
 		if (fn === "Equal") {

package/src/codegen/stdlib/sort.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `sort` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const SORT_DISPATCH = {
 	Ints: (a) => `${a[0]}.sort((a, b) => a - b)`,
 	Float64s: (a) => `${a[0]}.sort((a, b) => a - b)`,
@@ -20,6 +22,7 @@ const SORT_DISPATCH = {
 		`(${a[0]}).every((v, i, a) => i === 0 || a[i - 1] <= v)`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const sortMethods = {
 	_genSort(fn, a) {
 		const gen = SORT_DISPATCH[fn];

package/src/codegen/stdlib/strconv.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `strconv` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const STRCONV_DISPATCH = {
 	Itoa: (a) => `String(${a[0]})`,
 	Atoi: (a) =>
@@ -22,6 +24,7 @@ const STRCONV_DISPATCH = {
 		`[...(${a[0]}), ...new TextEncoder().encode(${a[1]}.toFixed(${a[3]} < 0 ? 6 : ${a[3]}))]`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const strconvMethods = {
 	_genStrconv(fn, a) {
 		const gen = STRCONV_DISPATCH[fn];

package/src/codegen/stdlib/strings.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `strings` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const STRINGS_M1 = {
 	ToUpper: "toUpperCase",
 	ToLower: "toLowerCase",
@@ -71,6 +73,7 @@ const STRINGS_DISPATCH = {
 		`((...pairs) => { const p = []; for (let i = 0; i < pairs.length; i += 2) p.push([pairs[i], pairs[i+1]]); return { _p: p, Replace(s) { let r = s; for (const [o, n] of this._p) r = r.split(o).join(n); return r; } }; })(${args.join(", ")})`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const stringsMethods = {
 	_genStrings(fn, a) {
 		const args = a();

package/src/codegen/stdlib/time.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `time` package — `time.Now`, `time.Since`, etc., plus `*Time` methods.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const TIME_METHOD_DISPATCH = {
 	Year: (r) => `${r}._d.getFullYear()`,
 	Month: (r) => `${r}._d.getMonth() + 1`,
@@ -26,6 +28,7 @@ const TIME_DISPATCH = {
 		`{_d: new Date(${a[0]}, ${a[1]} - 1, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]})}`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const timeMethods = {
 	_genTimeMethodCall(method, expr) {
 		const recv = expr.func.expr;

package/src/codegen/stdlib/unicode.js

@@ -1,5 +1,8 @@
 // CodeGen for Go `unicode` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
+/** @type {ThisType<CodeGen>} */
 export const unicodeMethods = {
 	_genUnicode(fn, a) {
 		const [arg] = a();

package/src/codegen/stdlib/utf8.js

@@ -1,5 +1,7 @@
 // CodeGen for Go `unicode/utf8` package.
 
+/** @typedef {import('../index.js').CodeGen} CodeGen */
+
 const UTF8_DISPATCH = {
 	RuneCountInString: (a) => `[...(${a[0]})].length`,
 	RuneLen: (a) =>
@@ -15,6 +17,7 @@ const UTF8_DISPATCH = {
 	FullRuneInString: (a) => `(${a[0]}).length > 0`,
 };
 
+/** @type {ThisType<CodeGen>} */
 export const utf8Methods = {
 	_genUtf8(fn, a) {
 		const gen = UTF8_DISPATCH[fn];

package/src/codegen/templ.js

@@ -5,6 +5,9 @@
 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

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)
@@ -146,6 +148,63 @@ export function resolveImports(
 
 // ── 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}`);