gofront 1.0.0 → 1.1.0

package/src/typechecker/assignability.js

@@ -24,6 +24,8 @@ import {
 	UNTYPED_INT,
 } from "./types.js";
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
 // Untyped constant assignability: maps source.base → Set of compatible target.name values
 const UNTYPED_COMPAT = {
 	int: new Set(["int", "float64", "complex128", "complex64"]),
@@ -33,6 +35,7 @@ const UNTYPED_COMPAT = {
 	complex128: new Set(["complex128", "complex64"]),
 };
 
+/** @type {ThisType<TypeChecker>} */
 export const assignabilityMethods = {
 	// ── Binary result types ───────────────────────────────────────────
 

package/src/typechecker/expressions.js

@@ -17,6 +17,7 @@ import {
 	NIL,
 	Scope,
 	STRING,
+	TAINTED_ANY,
 	typeStr,
 	UNTYPED_BOOL,
 	UNTYPED_COMPLEX,
@@ -26,6 +27,8 @@ import {
 	VOID,
 } from "./types.js";
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
 // Dispatch table for builtin function type checking.
 // Each value is (self, name, expr, argTypes, scope) => returnType.
 const BUILTIN_CHECK = {
@@ -80,6 +83,7 @@ const CHECK_EXPR_DELEGATE = {
 	InstantiationExpr: "_checkInstantiationExpr",
 };
 
+/** @type {ThisType<TypeChecker>} */
 export const expressionCheckMethods = {
 	checkExpr(expr, scope) {
 		const t = this._checkExpr(expr, scope);
@@ -115,6 +119,7 @@ export const expressionCheckMethods = {
 			case "BinaryExpr": {
 				const lt = this.checkExpr(expr.left, scope);
 				const rt = this.checkExpr(expr.right, scope);
+				if (lt?._tainted || rt?._tainted) return TAINTED_ANY;
 				if (isAny(lt) || isAny(rt))
 					return this.binaryResultType(expr.op, ANY, ANY, expr);
 				return this.binaryResultType(expr.op, lt, rt, expr);
@@ -185,6 +190,7 @@ export const expressionCheckMethods = {
 
 	_checkSelectorExpr(expr, scope) {
 		const baseType = this.checkExpr(expr.expr, scope);
+		if (baseType?._tainted) return TAINTED_ANY;
 		if (expr.expr._isTypeRef) {
 			let base = baseType.kind === "named" ? baseType.underlying : baseType;
 			base = this.resolveType(base);
@@ -230,6 +236,7 @@ export const expressionCheckMethods = {
 	_checkIndexExpr(expr, scope) {
 		const bt = this.checkExpr(expr.expr, scope);
 		this.checkExpr(expr.index, scope);
+		if (bt?._tainted) return TAINTED_ANY;
 		if (isAny(bt)) return ANY;
 		const btu =
 			bt.kind === "named"
@@ -252,6 +259,7 @@ export const expressionCheckMethods = {
 		if (expr.low) this.checkExpr(expr.low, scope);
 		if (expr.high) this.checkExpr(expr.high, scope);
 		if (expr.max) this.checkExpr(expr.max, scope);
+		if (bt?._tainted) return TAINTED_ANY;
 		if (isAny(bt)) return ANY;
 		if (bt.kind === "slice" || bt.kind === "array")
 			return { kind: "slice", elem: bt.elem };
@@ -468,6 +476,7 @@ export const expressionCheckMethods = {
 
 		const argTypes = this._resolveCallArgTypes(expr, scope);
 
+		if (fnType?._tainted) return TAINTED_ANY;
 		if (isAny(fnType)) return ANY;
 
 		// Named type used as a constructor/conversion: Greeter(fn), NodeFunc(fn)

package/src/typechecker/index.js

@@ -22,6 +22,7 @@ import {
 	ERROR,
 	isVoid,
 	Scope,
+	TAINTED_ANY,
 	TypeCheckError,
 	typeStr,
 	VOID,
@@ -124,7 +125,7 @@ export class TypeChecker {
 			this._currentSource,
 		);
 		this.errors.push(e);
-		return ANY; // recovery type
+		return TAINTED_ANY; // tainted recovery type — suppresses downstream cascade errors
 	}
 
 	_reportUnused(scope, node) {

package/src/typechecker/resolve.js

@@ -7,10 +7,13 @@ import {
 	defaultType,
 	isAny,
 	Scope,
+	TAINTED_ANY,
 	typeStr,
 	VOID,
 } from "./types.js";
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
 // Dispatch table for substituteType — keyed by type.kind.
 const SUBSTITUTE_DISPATCH = {
 	basic: (_s, type) => type,
@@ -69,6 +72,7 @@ const SUBSTITUTE_DISPATCH = {
 	}),
 };
 
+/** @type {ThisType<TypeChecker>} */
 export const resolveMethods = {
 	resolveTypeNode(node, scope) {
 		if (!node) return ANY;
@@ -217,7 +221,9 @@ export const resolveMethods = {
 				}
 			}
 		}
-		return { kind: "interface", methods };
+		const result = { kind: "interface", methods };
+		if (node.unionConstraint) result.unionConstraint = node.unionConstraint;
+		return result;
 	},
 
 	// ── Generics — substitution, instantiation, inference ────────────
@@ -354,7 +360,8 @@ export const resolveMethods = {
 
 	fieldType(baseType, field, node) {
 		baseType = this.resolveType(baseType);
-		if (!baseType || isAny(baseType)) return ANY;
+		if (!baseType || isAny(baseType))
+			return baseType?._tainted ? TAINTED_ANY : ANY;
 		if (this._isTransparentPointerField(baseType, field))
 			baseType = this.resolveType(baseType.base);
 		if (baseType.kind === "named" && baseType.methods?.has(field))

package/src/typechecker/statements.js

@@ -26,6 +26,9 @@ import {
 	Scope,
 } from "./types.js";
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
+/** @type {ThisType<TypeChecker>} */
 export const statementCheckMethods = {
 	checkBlock(block, scope, returnType) {
 		for (const stmt of block.stmts) {

package/src/typechecker/termination.js

@@ -1,6 +1,9 @@
 // Termination analysis — determines whether a statement/block always returns.
 // Installed as a mixin on TypeChecker.prototype.
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
+/** @type {ThisType<TypeChecker>} */
 export const terminationMethods = {
 	_isPanicCall(expr) {
 		return (

package/src/typechecker/types.js

@@ -48,6 +48,7 @@ export const FLOAT64 = { kind: "basic", name: "float64" };
 export const STRING = { kind: "basic", name: "string" };
 export const BOOL = { kind: "basic", name: "bool" };
 export const ANY = { kind: "basic", name: "any" };
+export const TAINTED_ANY = { kind: "basic", name: "any", _tainted: true };
 export const VOID = { kind: "basic", name: "void" };
 export const NIL = { kind: "basic", name: "nil" };
 export const ERROR = {

package/src/vendor.js

@@ -0,0 +1,228 @@
+// Vendor dependency bundler for GoFront projects.
+// Dynamically loads a bundler (rolldown or esbuild) from consumer devDependencies.
+
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+export function getExportNames(pkgName) {
+	const base = pkgName.replace(/^@[^/]+\//, "");
+	const clean = base.replace(/[^a-zA-Z0-9_]/g, "_");
+	const names = new Set([pkgName, base, clean]);
+
+	if (pkgName === "@emailjs/browser") names.add("emailjs");
+	if (pkgName === "fuse.js") {
+		names.add("Fuse");
+		names.add("fuse");
+	}
+	if (pkgName === "prismjs") {
+		names.add("Prism");
+		names.add("prism");
+	}
+	if (pkgName === "marked") {
+		names.add("marked");
+	}
+
+	return [...names];
+}
+
+export function generateVendorEntry(packages) {
+	const imports = [];
+	const assignments = [];
+	const exports = [];
+
+	packages.forEach((pkg, idx) => {
+		const id = `_dep_${idx}`;
+		imports.push(`import * as ${id} from ${JSON.stringify(pkg)};`);
+
+		const names = getExportNames(pkg);
+		for (const name of names) {
+			assignments.push(
+				`    window[${JSON.stringify(name)}] = ${id}.default || ${id};`,
+			);
+		}
+
+		const cleanId = pkg
+			.replace(/^@[^/]+\//, "")
+			.replace(/[^a-zA-Z0-9_$]/g, "_");
+		exports.push(`    ${id} as ${cleanId}`);
+	});
+
+	return `// Auto-generated GoFront vendor entry point
+${imports.join("\n")}
+
+if (typeof window !== "undefined") {
+${assignments.join("\n")}
+}
+
+export {
+${exports.join(",\n")}
+};
+`;
+}
+
+export function findBundler(projectDir) {
+	const pkgPath = join(projectDir, "package.json");
+	let req;
+	if (existsSync(pkgPath)) {
+		req = createRequire(pkgPath);
+	} else {
+		req = createRequire(join(projectDir, "dummy.js"));
+	}
+
+	try {
+		const path = req.resolve("rolldown");
+		return { name: "rolldown", path };
+	} catch {}
+
+	try {
+		const path = req.resolve("esbuild");
+		return { name: "esbuild", path };
+	} catch {}
+
+	return null;
+}
+
+export function loadVendorConfig(projectDir) {
+	const pkgPath = join(projectDir, "package.json");
+	let pkg = {};
+	if (existsSync(pkgPath)) {
+		try {
+			pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+		} catch {}
+	}
+
+	const gfjPath = join(projectDir, "gofront.json");
+	let gfj = {};
+	if (existsSync(gfjPath)) {
+		try {
+			gfj = JSON.parse(readFileSync(gfjPath, "utf8"));
+		} catch {}
+	}
+
+	const vendorConfig = gfj.vendor ?? pkg.vendor ?? null;
+	const dependencies = Object.keys(pkg.dependencies ?? {});
+
+	let dest = null;
+	let packages = dependencies;
+
+	if (typeof vendorConfig === "string") {
+		dest = vendorConfig;
+	} else if (vendorConfig && typeof vendorConfig === "object") {
+		if (vendorConfig.dest) dest = vendorConfig.dest;
+		if (Array.isArray(vendorConfig.packages)) packages = vendorConfig.packages;
+	}
+
+	if (!dest) {
+		dest = existsSync(join(projectDir, "app")) ? "app/vendor.js" : "vendor.js";
+	}
+
+	return { dest, packages };
+}
+
+export async function bundleVendor(projectDir = ".", options = {}) {
+	const projectRoot = resolve(projectDir);
+	const config = loadVendorConfig(projectRoot);
+
+	const packages = options.packages ?? config.packages;
+	const dest = options.dest ?? config.dest;
+
+	if (!packages || packages.length === 0) {
+		return {
+			bundled: [],
+			skipped: 0,
+			dest,
+			message: "no external dependencies found",
+		};
+	}
+
+	const destPath = resolve(projectRoot, dest);
+	const relDest = relative(projectRoot, destPath);
+	if (relDest.startsWith("..") || isAbsolute(relDest)) {
+		throw new Error(
+			`gofront: vendor destination '${dest}' is outside project directory`,
+		);
+	}
+
+	const bundlerInfo = options.bundler ?? findBundler(projectRoot);
+	if (!bundlerInfo) {
+		console.warn(
+			"gofront: no bundler found (rolldown or esbuild). Run 'npm install --save-dev rolldown' to enable vendor bundling.",
+		);
+		return {
+			bundled: [],
+			skipped: packages.length,
+			dest,
+			bundler: null,
+			reason: "no bundler installed",
+		};
+	}
+
+	mkdirSync(dirname(destPath), { recursive: true });
+
+	// Allow custom bundler execution function (useful for tests and plugins)
+	if (typeof bundlerInfo.bundle === "function") {
+		await bundlerInfo.bundle({
+			projectRoot,
+			packages,
+			dest: destPath,
+		});
+		return { bundled: packages, bundler: bundlerInfo.name ?? "custom", dest };
+	}
+
+	const entryCode = generateVendorEntry(packages);
+	const entryFile = join(
+		projectRoot,
+		`.gofront-vendor-entry-${Date.now()}.mjs`,
+	);
+	writeFileSync(entryFile, entryCode);
+
+	try {
+		if (bundlerInfo.name === "rolldown") {
+			const rolldownModule =
+				bundlerInfo.instance ??
+				(await import(pathToFileURL(bundlerInfo.path).href));
+			const rolldownFn =
+				rolldownModule.rolldown ||
+				rolldownModule.default?.rolldown ||
+				rolldownModule.default;
+
+			const bundle = await rolldownFn({
+				input: entryFile,
+				cwd: projectRoot,
+			});
+			await bundle.write({
+				file: destPath,
+				format: "esm",
+			});
+			await bundle.close();
+		} else if (bundlerInfo.name === "esbuild") {
+			const esbuildModule =
+				bundlerInfo.instance ??
+				(await import(pathToFileURL(bundlerInfo.path).href));
+			const buildFn =
+				esbuildModule.build || esbuildModule.default?.build || esbuildModule;
+
+			await buildFn({
+				entryPoints: [entryFile],
+				bundle: true,
+				format: "esm",
+				outfile: destPath,
+				absWorkingDir: projectRoot,
+			});
+		}
+	} finally {
+		if (existsSync(entryFile)) {
+			rmSync(entryFile, { force: true });
+		}
+	}
+
+	return { bundled: packages, bundler: bundlerInfo.name, dest };
+}