gofront 1.2.1 → 1.2.3

package/README.md

@@ -387,16 +387,13 @@ gofront <dir>                    compile all *.go in directory → stdout
 gofront <input> -o out.js        write output to file (prints elapsed compile time e.g. "15ms")
 gofront <input> --check                    type-check only
 gofront <input> --watch                    watch for changes and recompile
-gofront <input> -o out.js --serve          watch + serve with live reload & SPA fallback (default port 3000)
+gofront <input> -o out.js --serve          watch + serve with live reload (default port 3000)
 gofront <input> -o out.js --serve --port 8080  use a custom port
-gofront <input> -o out.js --copy-assets    compile and synchronize static assets from package.json assetCopy
 gofront <input> --source-map               append inline source map (single file or directory; multi-file packages emit per-file mappings)
 gofront <input> --minify                   minify output (built-in minifier)
 gofront <input> --minify --mangle          minify and rename local identifiers
 gofront <file.go> --ast                    dump AST (debug)
 gofront <file.go> --tokens                 dump tokens (debug)
-gofront test [dir] [--dom]                 run unit tests (-v verbose, -run <regex>)
-gofront prep [dir]                         copy static assets and bundle vendor dependencies
 gofront init [dir]                         scaffold a new project
 gofront --version / -v                     print version
 gofront --help / -h                        print this help
@@ -404,116 +401,6 @@ gofront --help / -h                        print this help
 
 ---
 
-## Unit testing (`gofront test`)
-
-GoFront provides native, Go-idiomatic unit testing out of the box:
-
-- Files ending in `*_test.go` are automatically excluded from production builds (`gofront .`, `gofront -o app.js`) and compiled only when running tests.
-- Built-in `testing` standard library package with `*testing.T`.
-- Discover and execute `func TestXxx(t *testing.T)` functions with standard Go-style output.
-
-### Writing a test
-
-```go
-package store
-
-import "testing"
-
-func TestAddTodo(t *testing.T) {
-    store := NewTodoStore()
-    store.Add("Buy milk")
-
-    if store.Count() != 1 {
-        t.Errorf("expected 1 item, got %d", store.Count())
-    }
-}
-```
-
-Subtests and skips are fully supported:
-
-```go
-func TestFilter(t *testing.T) {
-    t.Run("active", func(t *testing.T) {
-        // subtest logic
-    })
-    t.Run("completed", func(t *testing.T) {
-        if testing.Short() {
-            t.Skip("skipping in short mode")
-        }
-    })
-}
-```
-
-### Running tests
-
-```sh
-gofront test                  # run tests in current directory
-gofront test ./src            # run tests in specific directory
-gofront test -v               # verbose output (RUN, PASS/FAIL, logs)
-gofront test -run "Todo"      # run only tests matching regex pattern
-gofront test --dom            # initialize JSDOM for DOM/gom/templ tests
-```
-
-`--dom` requires `jsdom`. It is resolved from the project directory first and
-then from GoFront's own installation, so a globally installed `gofront` works
-without a project-local copy.
-
-Only `TestXxx` functions declared in `*_test.go` files are discovered, matching Go.
-
----
-
-## Static assets & vendor bundling
-
-GoFront includes native tooling to manage static assets and package external npm dependencies for the browser without requiring external wrappers or complex build tools.
-
-### Asset copying (`assetCopy`)
-
-Specify static assets (fonts, stylesheets, images) in `package.json` (or `gofront.json`):
-
-```json
-{
-  "assetCopy": [
-    { "source": "node_modules/@fontsource/raleway/files", "dest": "app/fonts" },
-    { "source": "node_modules/prismjs/themes", "dest": "app/css/prism-themes" }
-  ]
-}
-```
-
-Run `gofront prep` to copy them, or pass `--copy-assets` to automatically synchronize assets on build.
-
-### Vendor bundling (`gofront prep`)
-
-Package external npm dependencies for the browser:
-
-```sh
-gofront prep
-```
-
-GoFront inspects your `dependencies`, dynamically uses `rolldown` or `esbuild` from your `devDependencies`, and bundles them into an ES module (defaulting to `app/vendor.js` or `vendor.js`).
-
-Each bundled package is exposed on `window` under its full name, its unscoped name,
-and a sanitised identifier (e.g. `fuse.js` → `window["fuse.js"]`, `window.fuse_js`).
-To expose additional global names, add a `vendor.globals` mapping:
-
-```json
-{
-  "vendor": {
-    "dest": ["app/vendor.js", "public/vendor.js"],
-    "minify": true,
-    "globals": {
-      "fuse.js": ["Fuse"],
-      "prismjs": ["Prism"],
-      "@emailjs/browser": ["emailjs"]
-    }
-  }
-}
-```
-
-`dest` accepts a string or an array (the bundle is written once and copied to each
-extra destination). `gofront prep --minify` overrides `minify` from the command line.
-
----
-
 ## Multi-file packages
 
 All `.go` files in a directory share the same namespace and are compiled as one unit.

package/package.json

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

package/src/codegen/index.js

@@ -333,10 +333,23 @@ export class CodeGen {
 		if (fields.length === 0) {
 			this.line("constructor() {}");
 		} else {
-			const params = fields.map((f) => `${f.name} = ${f.zero}`).join(", ");
+			// A field named like a type used in a default (e.g. `Project Project`)
+			// would shadow that class inside the parameter scope, so alias it.
+			const binding = (f) => {
+				const re = new RegExp(`\\b${f.name}\\b`);
+				return fields.some((o) => re.test(o.zero)) ? `${f.name}$` : f.name;
+			};
+			const params = fields
+				.map((f) => {
+					const b = binding(f);
+					return b === f.name
+						? `${f.name} = ${f.zero}`
+						: `${f.name}: ${b} = ${f.zero}`;
+				})
+				.join(", ");
 			this.line(`constructor({ ${params} } = {}) {`);
 			this.indented(() => {
-				for (const f of fields) this.line(`this.${f.name} = ${f.name};`);
+				for (const f of fields) this.line(`this.${f.name} = ${binding(f)};`);
 			});
 			this.line("}");
 		}

package/src/codegen/statements.js

@@ -448,7 +448,10 @@ export const statementGenMethods = {
 	},
 
 	_genRangeIterExpr(iterType, iteree, lhs) {
-		if (this._isMapRangeType(iterType)) return `Object.entries(${iteree})`;
+		if (this._isMapRangeType(iterType)) {
+			if (lhs.length === 1) return `Object.keys(${iteree})`;
+			return `Object.entries(${iteree})`;
+		}
 		if (this._isStringRangeType(iterType)) {
 			if (lhs.length === 1) return `Array.from(${iteree}).keys()`;
 			return `Array.from(${iteree}, (__c, __i) => [__i, __c.codePointAt(0)])`;

package/src/minifier.js

@@ -379,8 +379,7 @@ function needsSpaceBetween(left, right) {
 	return false;
 }
 
-function compress(code) {
-	const tokens = tokenize(code);
+function compressTokens(tokens) {
 	let out = "";
 
 	for (let i = 0; i < tokens.length; i++) {
@@ -430,6 +429,10 @@ function compress(code) {
 	return out;
 }
 
+function compress(code) {
+	return compressTokens(tokenize(code));
+}
+
 function findPrevNonWs(tokens, index) {
 	for (let i = index - 1; i >= 0; i--) {
 		if (tokens[i].type !== "ws" && tokens[i].type !== "comment")
@@ -545,10 +548,18 @@ function _applyRenaming(tokens, renameMap) {
 
 function mangle(code) {
 	const tokens = tokenize(code);
-	const nameGen = shortNameGeneratorFn();
-	const renameMap = new Map();
 	const { declaredLocals } = _collectLocalDecls(tokens);
 	_filterRenameCandidates(declaredLocals);
+
+	const occupied = new Set(MANGLE_GLOBALS);
+	for (const tok of tokens) {
+		if (tok.type === "ident" && !declaredLocals.has(tok.value)) {
+			occupied.add(tok.value);
+		}
+	}
+
+	const nameGen = shortNameGeneratorFn(occupied);
+	const renameMap = new Map();
 	for (const name of declaredLocals) renameMap.set(name, nameGen());
 	return _applyRenaming(tokens, renameMap);
 }
@@ -606,61 +617,180 @@ function collectParams(tokens, openIdx, locals) {
 	}
 }
 
-function* shortNameGenerator() {
+function* shortNameGenerator(occupied = new Set()) {
 	const chars = "abcdefghijklmnopqrstuvwxyz";
 	let index = 0;
 	while (true) {
+		let name;
 		if (index < 26) {
-			yield chars[index++];
+			name = chars[index++];
 		} else {
 			const base = index - 26;
-			yield chars[base % 26] + (Math.floor(base / 26) + 1);
+			name = chars[base % 26] + (Math.floor(base / 26) + 1);
 			index++;
 		}
+		if (!occupied.has(name)) {
+			yield name;
+		}
 	}
 }
 
 // Make it callable (not an iterator interface)
-function shortNameGeneratorFn() {
-	const gen = shortNameGenerator();
+function shortNameGeneratorFn(occupied = new Set()) {
+	const gen = shortNameGenerator(occupied);
 	return () => gen.next().value;
 }
 
 // ── Stage 4: Literal folding ─────────────────────────────────
 
-function foldLiterals(code) {
-	// Fold patterns like: <number> <op> <number> where both are literal constants
-	return code.replace(
-		/\b(\d+(?:\.\d+)?)\s*(\+|-|\*|\/|%)\s*(\d+(?:\.\d+)?)\b/g,
-		(match, left, op, right) => {
-			const l = Number(left);
-			const r = Number(right);
-			let result;
-			switch (op) {
-				case "+":
-					result = l + r;
-					break;
-				case "-":
-					result = l - r;
-					break;
-				case "*":
-					result = l * r;
-					break;
-				case "/":
-					result = r !== 0 ? l / r : null;
-					break;
-				case "%":
-					result = r !== 0 ? l % r : null;
-					break;
-				default:
-					return match;
+const FOLD_SAFE_PREV = new Set([
+	";",
+	"(",
+	"[",
+	"{",
+	",",
+	":",
+	"?",
+	"=",
+	"+=",
+	"-=",
+	"*=",
+	"/=",
+	"%=",
+	"&&",
+	"||",
+	"??",
+	"==",
+	"!=",
+	"===",
+	"!==",
+	"<",
+	"<=",
+	">",
+	">=",
+	"return",
+	"throw",
+	"case",
+	"yield",
+	"await",
+	"=>",
+]);
+
+function _foldBinaryOp(op, l, r) {
+	switch (op) {
+		case "+":
+			return l + r;
+		case "-":
+			return l - r;
+		case "*":
+			return l * r;
+		case "/":
+			return r !== 0 ? l / r : null;
+		case "%":
+			return r !== 0 ? l % r : null;
+		default:
+			return null;
+	}
+}
+
+function _isHigherPrecedenceOp(op, afterOp) {
+	if (
+		afterOp === "**" ||
+		afterOp === "++" ||
+		afterOp === "--" ||
+		afterOp === "."
+	) {
+		return true;
+	}
+	if (
+		(op === "+" || op === "-") &&
+		(afterOp === "*" || afterOp === "/" || afterOp === "%")
+	) {
+		return true;
+	}
+	return false;
+}
+
+function _canFoldLeft(next) {
+	const prevTok = findPrevNonWs(next, next.length);
+	return !prevTok || FOLD_SAFE_PREV.has(prevTok.value);
+}
+
+function _evaluateFold(tok, opTok, rightTok) {
+	const l = Number(tok.value);
+	const r = Number(rightTok.value);
+	if (!Number.isFinite(l) || !Number.isFinite(r)) return null;
+
+	let val = _foldBinaryOp(opTok.value, l, r);
+	if (val === null || !Number.isFinite(val) || val < 0) return null;
+	if (Object.is(val, -0)) val = 0;
+
+	const s = String(val);
+	const origLen = tok.value.length + opTok.value.length + rightTok.value.length;
+	return s.length <= origLen ? s : null;
+}
+
+function _tryFoldAt(current, i, next) {
+	const tok = current[i];
+	if (tok.type !== "num" || !_canFoldLeft(next)) return null;
+
+	const opInfo = nextNonWs(current, i);
+	if (opInfo?.tok.type !== "op") return null;
+
+	const op = opInfo.tok.value;
+	if (op !== "+" && op !== "-" && op !== "*" && op !== "/" && op !== "%") {
+		return null;
+	}
+
+	const rightInfo = nextNonWs(current, opInfo.idx);
+	if (rightInfo?.tok.type !== "num") return null;
+
+	const afterInfo = nextNonWs(current, rightInfo.idx);
+	if (
+		afterInfo?.tok.type === "op" &&
+		_isHigherPrecedenceOp(op, afterInfo.tok.value)
+	) {
+		return null;
+	}
+
+	const folded = _evaluateFold(tok, opInfo.tok, rightInfo.tok);
+	if (!folded) return null;
+
+	next.push({ type: "num", value: folded });
+	return rightInfo.idx + 1;
+}
+
+function foldTokens(tokens) {
+	let changed = true;
+	let current = tokens;
+	let iterations = 0;
+
+	while (changed && iterations < 10) {
+		changed = false;
+		iterations++;
+		const next = [];
+		let i = 0;
+
+		while (i < current.length) {
+			const nextIdx = _tryFoldAt(current, i, next);
+			if (nextIdx !== null) {
+				i = nextIdx;
+				changed = true;
+			} else {
+				next.push(current[i]);
+				i++;
 			}
-			if (result === null || !Number.isFinite(result)) return match;
-			// If result is integer, emit without decimal point
-			const s = Number.isInteger(result) ? String(result) : String(result);
-			return s;
-		},
-	);
+		}
+
+		current = next;
+	}
+
+	return current;
+}
+
+function foldLiterals(code) {
+	const tokens = tokenize(code);
+	return compressTokens(foldTokens(tokens));
 }
 
 // ── Public API ───────────────────────────────────────────────