gofront 1.2.3 → 1.3.0

package/src/pwa.js

@@ -0,0 +1,138 @@
+// Offline PWA & Service Worker Generation for GoFront.
+// Implements zero-configuration pre-caching and service worker emission.
+
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	writeFileSync,
+} from "node:fs";
+import { join, resolve } from "node:path";
+
+export const PWA_REGISTER_SNIPPET = `<script id="gofront-pwa">
+if ('serviceWorker' in navigator) {
+	window.addEventListener('load', () => {
+		navigator.serviceWorker.register('./sw.js').catch(() => {});
+	});
+}
+</script>`;
+
+export function collectPwaAssets(outDir) {
+	const assets = [];
+	function walk(dir, prefix = "") {
+		for (const entry of readdirSync(dir, { withFileTypes: true })) {
+			const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+			const full = join(dir, entry.name);
+			if (entry.isDirectory()) {
+				walk(full, rel);
+			} else if (entry.isFile()) {
+				if (entry.name !== "sw.js" && !entry.name.endsWith(".map")) {
+					assets.push(`./${rel}`);
+				}
+			}
+		}
+	}
+	if (existsSync(outDir)) {
+		walk(outDir);
+	}
+	if (assets.includes("./index.html") && !assets.includes("./")) {
+		assets.unshift("./");
+	}
+	return assets.sort();
+}
+
+export function generateServiceWorkerSource(assets, version) {
+	const assetList = JSON.stringify(assets, null, 2);
+	return `// GoFront PWA Service Worker — offline cache
+const CACHE_NAME = "gofront-${version}";
+const ASSETS = ${assetList};
+
+self.addEventListener("install", (event) => {
+	event.waitUntil(
+		caches.open(CACHE_NAME).then((cache) => {
+			return cache.addAll(ASSETS);
+		}).then(() => self.skipWaiting()),
+	);
+});
+
+self.addEventListener("activate", (event) => {
+	event.waitUntil(
+		caches.keys().then((keys) => {
+			return Promise.all(
+				keys.map((key) => {
+					if (key !== CACHE_NAME && key.startsWith("gofront-")) {
+						return caches.delete(key);
+					}
+				}),
+			);
+		}).then(() => self.clients.claim()),
+	);
+});
+
+self.addEventListener("fetch", (event) => {
+	if (event.request.method !== "GET") return;
+	event.respondWith(
+		caches.match(event.request).then((cached) => {
+			if (cached) return cached;
+			return fetch(event.request).then((response) => {
+				if (!response || response.status !== 200 || response.type !== "basic") {
+					return response;
+				}
+				const clone = response.clone();
+				caches.open(CACHE_NAME).then((cache) => {
+					cache.put(event.request, clone);
+				});
+				return response;
+			}).catch(() => {
+				if (event.request.headers?.get?.("accept")?.includes("text/html")) {
+					return caches.match("./") || caches.match("./index.html");
+				}
+			});
+		}),
+	);
+});
+`;
+}
+
+export function injectPwaRegistration(html) {
+	if (
+		html.includes("gofront-pwa") ||
+		html.includes("navigator.serviceWorker.register")
+	) {
+		return html;
+	}
+	if (/<\/body>/i.test(html)) {
+		return html.replace(/<\/body>/i, () => `${PWA_REGISTER_SNIPPET}\n</body>`);
+	}
+	return `${html}\n${PWA_REGISTER_SNIPPET}\n`;
+}
+
+export function generatePwa(outDir, options = {}) {
+	const resolvedOut = resolve(outDir);
+	mkdirSync(resolvedOut, { recursive: true });
+
+	const assets = collectPwaAssets(resolvedOut);
+	const version = options.version ?? `v${Date.now().toString(36)}`;
+	const swName = options.swName ?? "sw.js";
+	const swPath = join(resolvedOut, swName);
+
+	const swSource = generateServiceWorkerSource(assets, version);
+	writeFileSync(swPath, swSource);
+
+	const indexPath = join(resolvedOut, "index.html");
+	if (existsSync(indexPath)) {
+		const html = readFileSync(indexPath, "utf8");
+		const updatedHtml = injectPwaRegistration(html);
+		if (updatedHtml !== html) {
+			writeFileSync(indexPath, updatedHtml);
+		}
+	}
+
+	return {
+		swPath,
+		assetsCount: assets.length,
+		version,
+		assets,
+	};
+}

package/src/typechecker/assignability.js

@@ -7,7 +7,6 @@ import {
 	CMP_OPS,
 	COMPLEX128,
 	FLOAT64,
-	INT,
 	isAny,
 	isComplex,
 	isComplexOrNumeric,
@@ -17,6 +16,8 @@ import {
 	isString,
 	isUntyped,
 	LOG_OPS,
+	SIZED_FLOAT_NAMES,
+	SIZED_INT_NAMES,
 	STRING,
 	typeStr,
 	UNTYPED_COMPLEX,
@@ -28,8 +29,18 @@ import {
 
 // Untyped constant assignability: maps source.base → Set of compatible target.name values
 const UNTYPED_COMPAT = {
-	int: new Set(["int", "float64", "complex128", "complex64"]),
-	float64: new Set(["float64", "int", "complex128", "complex64"]),
+	int: new Set([
+		...SIZED_INT_NAMES,
+		...SIZED_FLOAT_NAMES,
+		"complex128",
+		"complex64",
+	]),
+	float64: new Set([
+		...SIZED_FLOAT_NAMES,
+		...SIZED_INT_NAMES,
+		"complex128",
+		"complex64",
+	]),
 	string: new Set(["string"]),
 	bool: new Set(["bool"]),
 	complex128: new Set(["complex128", "complex64"]),
@@ -92,16 +103,23 @@ export const assignabilityMethods = {
 	},
 
 	_binaryResultTypeNumeric(lt, rt) {
-		const lFloat = (lt.kind === "untyped" ? lt.base : lt.name) === "float64";
-		const rFloat = (rt.kind === "untyped" ? rt.base : rt.name) === "float64";
+		const lName = lt.kind === "untyped" ? lt.base : lt.name;
+		const rName = rt.kind === "untyped" ? rt.base : rt.name;
+		const lFloat = lName === "float32" || lName === "float64";
+		const rFloat = rName === "float32" || rName === "float64";
 		const isFloat = lFloat || rFloat;
 		if (lt.kind === "untyped" && rt.kind === "untyped")
 			return isFloat ? UNTYPED_FLOAT : UNTYPED_INT;
 		if (lt.kind === "untyped")
-			return isFloat && rt.name !== "float64" ? FLOAT64 : rt;
+			return isFloat && rt.name !== "float64" && rt.name !== "float32"
+				? FLOAT64
+				: rt;
 		if (rt.kind === "untyped")
-			return isFloat && lt.name !== "float64" ? FLOAT64 : lt;
-		return isFloat ? FLOAT64 : INT;
+			return isFloat && lt.name !== "float64" && lt.name !== "float32"
+				? FLOAT64
+				: lt;
+		if (lt.name === "float32" && rt.name === "float32") return lt;
+		return isFloat ? FLOAT64 : lt;
 	},
 
 	_checkComplexCmpOp(op, lt, rt, node) {
@@ -151,6 +169,7 @@ export const assignabilityMethods = {
 		if (isUntyped(source) && this._isUntypedAssignable(target, source)) return;
 		if (this._isNumericCoercible(target, source)) return;
 		if (this._checkArrayAssignable(target, source, node)) return;
+		if (this._checkTypedArrayAssignable(target, source, node)) return;
 		if (typeStr(target) !== typeStr(source))
 			this._assertAssignableTypeMismatch(target, source, node);
 	},
@@ -222,6 +241,40 @@ export const assignabilityMethods = {
 		return false;
 	},
 
+	_checkTypedArrayAssignable(target, source, node) {
+		const isTa = (t) => t?.underlying?._isTypedArray || t?._isTypedArray;
+		const getSlice = (t) =>
+			t?.kind === "slice"
+				? t
+				: t?.underlying?.kind === "slice"
+					? t.underlying
+					: null;
+		const targetTa = isTa(target);
+		const sourceTa = isTa(source);
+		const targetSlice = getSlice(target);
+		const sourceSlice = getSlice(source);
+
+		if ((targetTa && sourceSlice) || (targetSlice && sourceTa)) {
+			const taElem = targetTa
+				? (target.underlying?._elemType ?? target._elemType)
+				: (source.underlying?._elemType ?? source._elemType);
+			const slElem = targetSlice ? targetSlice.elem : sourceSlice.elem;
+			if (typeStr(taElem) === typeStr(slElem)) return true;
+			this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
+			return true;
+		}
+
+		if (targetTa && sourceTa) {
+			const tElem = target.underlying?._elemType ?? target._elemType;
+			const sElem = source.underlying?._elemType ?? source._elemType;
+			if (typeStr(tElem) === typeStr(sElem)) return true;
+			this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
+			return true;
+		}
+
+		return false;
+	},
+
 	// ── Interface satisfaction ────────────────────────────────────────
 
 	_sigParamsMatch(reqList, actList) {

package/src/typechecker/resolve.js

@@ -6,8 +6,10 @@ import {
 	BASIC_TYPES,
 	defaultType,
 	isAny,
+	isTypedArraySlice,
 	Scope,
 	TAINTED_ANY,
+	typedArrayConstructorForElem,
 	typeStr,
 	VOID,
 } from "./types.js";
@@ -387,11 +389,17 @@ export const resolveMethods = {
 				return this._fieldTypeInterface(base, baseType, field, node);
 			case "namespace":
 				return this._fieldTypeNamespace(base, field, node);
+			case "slice":
+				if (isTypedArraySlice(base)) {
+					return this._fieldTypeTypedArraySlice(base, baseType, field, node);
+				}
+				break;
 			default:
-				if (base && !isAny(base))
-					return this._fieldTypeBadAccess(base, baseType, field, node);
-				return ANY;
+				break;
 		}
+		if (base && !isAny(base))
+			return this._fieldTypeBadAccess(base, baseType, field, node);
+		return ANY;
 	},
 
 	_fieldTypeStruct(base, baseType, field, node) {
@@ -402,9 +410,35 @@ export const resolveMethods = {
 
 	_fieldTypeInterface(base, baseType, field, node) {
 		if (base.methods?.has(field)) return base.methods.get(field);
+		if (base.fields?.has(field)) return base.fields.get(field);
+		if (base._isOpen) return ANY;
 		return this.err(`No method '${field}' on ${typeStr(baseType)}`, node);
 	},
 
+	_fieldTypeTypedArraySlice(base, baseType, field, node) {
+		const taName = typedArrayConstructorForElem(base.elem);
+		if (taName) {
+			const taType = this.types.get(taName);
+			if (taType) {
+				const underlying = taType.kind === "named" ? taType.underlying : taType;
+				if (underlying?.fields?.has(field)) return underlying.fields.get(field);
+				if (underlying?.methods?.has(field)) {
+					const m = underlying.methods.get(field);
+					if (field === "subarray" || field === "slice") {
+						return {
+							kind: "func",
+							params: m.params,
+							returns: [baseType],
+							variadic: m.variadic,
+						};
+					}
+					return m;
+				}
+			}
+		}
+		return this._fieldTypeBadAccess(base, baseType, field, node);
+	},
+
 	_fieldTypeBadAccess(base, baseType, field, node) {
 		if (base.kind === "pointer" && field === "value") return base.base ?? ANY;
 		const badKinds = ["basic", "slice", "array", "map", "func", "tuple"];

package/src/typechecker/stdlib/core.js

@@ -1,7 +1,16 @@
 // Core standard library type definitions — browser globals, fmt, strings, bytes,
 // strconv, sort, math, errors, time, unicode, os, slices, html, io.
 
-import { ANY, BOOL, ERROR, FLOAT64, INT, STRING, VOID } from "../types.js";
+import {
+	ANY,
+	BOOL,
+	ERROR,
+	FLOAT64,
+	INT,
+	STRING,
+	UINT8,
+	VOID,
+} from "../types.js";
 
 const TIME_T = { kind: "named", name: "time.Time", underlying: ANY };
 
@@ -64,14 +73,8 @@ export function setupCoreGlobals(globals, types) {
 		"Blob",
 		"File",
 		"FileReader",
-		"ArrayBuffer",
-		"Uint8Array",
 		"TextEncoder",
 		"TextDecoder",
-		"WebGLRenderingContext",
-		"WebGL2RenderingContext",
-		"GPUDevice",
-		"GPUAdapter",
 	];
 	for (const g of browserGlobals) globals.define(g, ANY);
 
@@ -220,7 +223,7 @@ export function setupCoreGlobals(globals, types) {
 		},
 	});
 
-	const BYTE_SLICE = { kind: "slice", elem: INT };
+	const BYTE_SLICE = { kind: "slice", elem: UINT8 };
 	const byFn1 = (ret) => ({
 		kind: "func",
 		params: [BYTE_SLICE],
@@ -320,13 +323,13 @@ export function setupCoreGlobals(globals, types) {
 			Unquote: { kind: "func", params: [STRING], returns: [STRING, ERROR] },
 			AppendInt: {
 				kind: "func",
-				params: [{ kind: "slice", elem: INT }, INT, INT],
-				returns: [{ kind: "slice", elem: INT }],
+				params: [BYTE_SLICE, INT, INT],
+				returns: [BYTE_SLICE],
 			},
 			AppendFloat: {
 				kind: "func",
-				params: [{ kind: "slice", elem: INT }, FLOAT64, INT, INT, INT],
-				returns: [{ kind: "slice", elem: INT }],
+				params: [BYTE_SLICE, FLOAT64, INT, INT, INT],
+				returns: [BYTE_SLICE],
 			},
 		},
 	});
@@ -570,7 +573,7 @@ export function setupCoreGlobals(globals, types) {
 		},
 	});
 
-	const BYTE_SLICE_IO = { kind: "slice", elem: INT };
+	const BYTE_SLICE_IO = { kind: "slice", elem: UINT8 };
 	globals.define("io", {
 		kind: "namespace",
 		name: "io",

package/src/typechecker/stdlib/extended.js

@@ -1,7 +1,16 @@
 // Extended standard library type definitions — gom, maps, regexp, rand, utf8,
 // path, strings.Builder / bytes.Buffer types, and built-in functions.
 
-import { ANY, BOOL, ERROR, FLOAT64, INT, STRING, VOID } from "../types.js";
+import {
+	ANY,
+	BOOL,
+	ERROR,
+	FLOAT64,
+	INT,
+	STRING,
+	UINT8,
+	VOID,
+} from "../types.js";
 
 export function setupExtendedGlobals(globals, types) {
 	const GOM_NODE_T = {
@@ -209,7 +218,7 @@ export function setupExtendedGlobals(globals, types) {
 		},
 	});
 
-	const BYTE_SLICE_T = { kind: "slice", elem: INT };
+	const BYTE_SLICE_T = { kind: "slice", elem: UINT8 };
 	const _builderBase = [
 		["WriteString", { kind: "func", params: [STRING], returns: [INT, ERROR] }],
 		["WriteByte", { kind: "func", params: [INT], returns: [ERROR] }],