gofront 1.2.1 → 1.2.2

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.2",
 	"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

@@ -545,10 +545,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,23 +614,27 @@ 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;
 }