gofront 0.0.9 → 1.0.1

package/src/dts-parser.js

@@ -59,6 +59,17 @@ export class DtsParser {
 		return this.src[this.pos + 1];
 	}
 
+	_skipLineComment() {
+		while (!this.eof() && this.ch() !== "\n") this.pos++;
+	}
+
+	_skipBlockComment() {
+		this.pos += 2;
+		while (!this.eof() && !(this.ch() === "*" && this.ch1() === "/"))
+			this.pos++;
+		if (!this.eof()) this.pos += 2;
+	}
+
 	skip() {
 		while (!this.eof()) {
 			const c = this.ch();
@@ -67,14 +78,11 @@ export class DtsParser {
 				continue;
 			}
 			if (c === "/" && this.ch1() === "/") {
-				while (!this.eof() && this.ch() !== "\n") this.pos++;
+				this._skipLineComment();
 				continue;
 			}
 			if (c === "/" && this.ch1() === "*") {
-				this.pos += 2;
-				while (!this.eof() && !(this.ch() === "*" && this.ch1() === "/"))
-					this.pos++;
-				if (!this.eof()) this.pos += 2;
+				this._skipBlockComment();
 				continue;
 			}
 			break;
@@ -162,62 +170,30 @@ export class DtsParser {
 		}
 	}
 
+	_trackBracketDepth(c, depths) {
+		const open = { "<": 0, "(": 1, "[": 2, "{": 3 };
+		const close = { ">": 0, ")": 1, "]": 2, "}": 3 };
+		if (c in open) {
+			depths[open[c]]++;
+			return true;
+		}
+		if (c in close && depths[close[c]] > 0) {
+			depths[close[c]]--;
+			return true;
+		}
+		return false;
+	}
+
 	// Skip to the end of a type expression (stops at ; | , | ) | } | { | newline-after-token)
 	skipTypeExpr(stopAt = ";,)}{") {
-		let angleBrackets = 0,
-			parens = 0,
-			brackets = 0,
-			curlies = 0;
+		const depths = [0, 0, 0, 0];
 		while (!this.eof()) {
 			const c = this.ch();
-			if (c === "<") {
-				angleBrackets++;
-				this.pos++;
-				continue;
-			}
-			if (c === ">" && angleBrackets > 0) {
-				angleBrackets--;
-				this.pos++;
-				continue;
-			}
-			if (c === "(") {
-				parens++;
-				this.pos++;
-				continue;
-			}
-			if (c === ")" && parens > 0) {
-				parens--;
-				this.pos++;
-				continue;
-			}
-			if (c === "[") {
-				brackets++;
-				this.pos++;
-				continue;
-			}
-			if (c === "]" && brackets > 0) {
-				brackets--;
-				this.pos++;
-				continue;
-			}
-			if (c === "{") {
-				curlies++;
-				this.pos++;
-				continue;
-			}
-			if (c === "}" && curlies > 0) {
-				curlies--;
+			if (this._trackBracketDepth(c, depths)) {
 				this.pos++;
 				continue;
 			}
-			if (
-				angleBrackets === 0 &&
-				parens === 0 &&
-				brackets === 0 &&
-				curlies === 0 &&
-				stopAt.includes(c)
-			)
-				break;
+			if (!depths.some(Boolean) && stopAt.includes(c)) break;
 			if (c === '"' || c === "'") {
 				this.skipStringLit();
 				continue;
@@ -272,83 +248,71 @@ export class DtsParser {
 		return base;
 	}
 
+	_parseParenType() {
+		this.pos++;
+		this.skipTypeExpr(")");
+		this.consume(")");
+		this.skip();
+		if (this.startsWith("=>")) {
+			this.pos += 2;
+			this.parseType();
+		}
+		return ANY;
+	}
+
+	_parseTemplateLit() {
+		while (!this.eof() && this.ch() !== "`") this.pos++;
+		this.pos++;
+		return { kind: "basic", name: "string" };
+	}
+
+	_parseNumericLit() {
+		while (!this.eof() && /[0-9._-]/.test(this.ch())) this.pos++;
+		return { kind: "basic", name: "float64" };
+	}
+
+	_parseNamedType(name) {
+		if (TS_PRIMITIVES[name]) {
+			this.skipGenerics();
+			return TS_PRIMITIVES[name];
+		}
+		if (name === "true" || name === "false")
+			return { kind: "basic", name: "bool" };
+		this.skipGenerics();
+		while (this.ch() === ".") {
+			this.pos++;
+			this.readIdent();
+		}
+		return { kind: "basic", name: "any", alias: name };
+	}
+
 	_parseBaseType() {
 		this.skip();
 		const c = this.ch();
-
-		// Tuple / array literal type: [T, U]
 		if (c === "[") {
-			this.pos++; // consume opening [, so skipTypeExpr stops at depth-0 ]
+			this.pos++;
 			this.skipTypeExpr("]");
 			this.consume("]");
 			return ANY;
 		}
-		// Object literal type: { x: T }
 		if (c === "{") {
 			this.skipBlock();
 			return ANY;
 		}
-		// Parenthesised type or function type: (params) => T
-		if (c === "(") {
-			this.pos++; // consume opening (, so skipTypeExpr stops at depth-0 )
-			this.skipTypeExpr(")");
-			this.consume(")");
-			this.skip();
-			if (this.startsWith("=>")) {
-				this.pos += 2;
-				this.parseType();
-			}
-			return ANY;
-		}
-		// String literal type: "foo"
+		if (c === "(") return this._parseParenType();
 		if (c === '"' || c === "'") {
 			this.skipStringLit();
 			return { kind: "basic", name: "string" };
 		}
-		// Template literal: `...`
-		if (c === "`") {
-			while (!this.eof() && this.ch() !== "`") this.pos++;
-			this.pos++;
-			return { kind: "basic", name: "string" };
-		}
-		// Numeric literal
-		if (
-			/[0-9]/.test(c) ||
-			(c === "-" && /[0-9]/.test(this.src[this.pos + 1]))
-		) {
-			while (!this.eof() && /[0-9._-]/.test(this.ch())) this.pos++;
-			return { kind: "basic", name: "float64" };
-		}
-
-		// Named type (including primitives)
-		let name = "";
-		while (!this.eof() && /[a-zA-Z0-9_$]/.test(this.ch()))
-			name += this.src[this.pos++];
+		if (c === "`") return this._parseTemplateLit();
+		if (/[0-9]/.test(c) || (c === "-" && /[0-9]/.test(this.src[this.pos + 1])))
+			return this._parseNumericLit();
+		const name = this.readIdent();
 		if (!name) {
 			this.pos++;
 			return ANY;
-		} // skip unknown char
-
-		if (TS_PRIMITIVES[name]) {
-			this.skipGenerics();
-			return TS_PRIMITIVES[name];
-		}
-
-		// true / false
-		if (name === "true" || name === "false")
-			return { kind: "basic", name: "bool" };
-
-		// Generic application: T<U> — skip the parameters
-		this.skipGenerics();
-
-		// Qualified name: A.B
-		while (this.ch() === ".") {
-			this.pos++;
-			while (!this.eof() && /[a-zA-Z0-9_$]/.test(this.ch())) this.pos++;
 		}
-
-		// Return as a named any-alias (the type checker will resolve or fall back to any)
-		return { kind: "basic", name: "any", alias: name };
+		return this._parseNamedType(name);
 	}
 
 	// ── Parameter list ───────────────────────────────────────────
@@ -399,11 +363,22 @@ export class DtsParser {
 		return members;
 	}
 
-	_parseMember(out) {
+	_skipEnumBody() {
 		this.skip();
-		if (this.eof() || this.ch() === "}") return;
+		this.consume("{");
+		while (!this.eof() && this.ch() !== "}") {
+			this.readIdent();
+			this.skip();
+			if (this.ch() === "=") {
+				this.pos++;
+				this.skipTypeExpr(",}");
+			}
+			this.consume(",");
+		}
+		this.consume("}");
+	}
 
-		// Skip modifiers (export, declare, static, readonly, etc.)
+	_skipModifiers() {
 		while (true) {
 			this.skip();
 			let found = false;
@@ -415,76 +390,106 @@ export class DtsParser {
 			}
 			if (!found) break;
 		}
+	}
 
+	_parseMemberFuncDecl(out) {
+		const name = this.readIdent();
+		this.skipGenerics();
+		const params = this.parseParams();
 		this.skip();
-		if (this.eof() || this.ch() === "}") return;
+		let ret = VOID;
+		if (this.ch() === ":") {
+			this.pos++;
+			ret = this.parseType();
+		}
+		this.consume(";");
+		if (name)
+			out[name] = {
+				kind: "func",
+				params: params.map((p) => p.type),
+				returns: [ret],
+			};
+	}
 
-		// Read the first identifier (keyword or name)
+	_parseMemberNewSig() {
+		this.skipGenerics();
+		this.parseParams();
+		this.skip();
+		if (this.ch() === ":") {
+			this.pos++;
+			this.parseType();
+		}
+		this.consume(";");
+	}
+
+	_parseMemberTypeDecl(out) {
+		const name = this.readIdent();
+		this.skipGenerics();
+		this.skip();
+		let type = ANY;
+		if (this.ch() === "=") {
+			this.pos++;
+			type = this.parseType();
+		}
+		this.consume(";");
+		if (name) out[name] = type;
+	}
+
+	_parseMemberClassDecl(out) {
+		const name = this.readIdent();
+		this.skipGenerics();
+		while (!this.eof() && this.ch() !== "{") this.pos++;
+		this.consume("{");
+		const body = this.parseBody();
+		this.consume("}");
+		this.consume(";");
+		if (name) out[name] = { kind: "namespace", name, members: body };
+	}
+
+	_parseMemberVarDecl(out) {
+		const name = this.readIdent();
+		this.skip();
+		this.consume("?");
+		let type = ANY;
+		if (this.ch() === ":") {
+			this.pos++;
+			type = this.parseType();
+		}
+		this.skip();
+		if (this.ch() === "=") {
+			this.pos++;
+			this.skipTypeExpr();
+		}
+		this.consume(";");
+		if (name) out[name] = type;
+	}
+
+	_parseMember(out) {
+		this.skip();
+		if (this.eof() || this.ch() === "}") return;
+		this._skipModifiers();
+		this.skip();
+		if (this.eof() || this.ch() === "}") return;
 		const kw = this.readIdent();
 		if (!kw) {
 			this.pos++;
 			return;
 		}
-
 		this.skip();
 		switch (kw) {
-			case "function": {
-				const name = this.readIdent();
-				this.skipGenerics();
-				const params = this.parseParams();
-				this.skip();
-				let ret = VOID;
-				if (this.ch() === ":") {
-					this.pos++;
-					ret = this.parseType();
-				}
-				this.consume(";");
-				if (name)
-					out[name] = {
-						kind: "func",
-						params: params.map((p) => p.type),
-						returns: [ret],
-					};
+			case "function":
+				this._parseMemberFuncDecl(out);
 				break;
-			}
-			case "new": {
-				// constructor signature in interface
-				this.skipGenerics();
-				this.parseParams();
-				this.skip();
-				if (this.ch() === ":") {
-					this.pos++;
-					this.parseType();
-				}
-				this.consume(";");
+			case "new":
+				this._parseMemberNewSig();
 				break;
-			}
-			case "type": {
-				const name = this.readIdent();
-				this.skipGenerics();
-				this.skip();
-				let type = ANY;
-				if (this.ch() === "=") {
-					this.pos++;
-					type = this.parseType();
-				}
-				this.consume(";");
-				if (name) out[name] = type;
+			case "type":
+				this._parseMemberTypeDecl(out);
 				break;
-			}
 			case "interface":
-			case "class": {
-				const name = this.readIdent();
-				this.skipGenerics();
-				// skip extends/implements
-				while (!this.eof() && this.ch() !== "{") this.pos++;
-				this.consume("{");
-				const body = this.parseBody();
-				this.consume("}");
-				this.consume(";");
-				if (name) out[name] = { kind: "namespace", name, members: body };
+			case "class":
+				this._parseMemberClassDecl(out);
 				break;
-			}
 			case "namespace":
 			case "module": {
 				const name = this.readIdent() || this._readStringLit();
@@ -498,80 +503,53 @@ export class DtsParser {
 			}
 			case "enum": {
 				const name = this.readIdent();
-				this.skip();
-				this.consume("{");
-				// skip enum body — members are string/number constants
-				while (!this.eof() && this.ch() !== "}") {
-					this.readIdent();
-					this.skip();
-					if (this.ch() === "=") {
-						this.pos++;
-						this.skipTypeExpr(",}");
-					}
-					this.consume(",");
-				}
-				this.consume("}");
+				this._skipEnumBody();
 				if (name) out[name] = ANY;
 				break;
 			}
 			case "const":
 			case "let":
-			case "var": {
-				const name = this.readIdent();
-				this.skip();
-				this.consume("?");
-				let type = ANY;
-				if (this.ch() === ":") {
-					this.pos++;
-					type = this.parseType();
-				}
-				this.skip();
-				if (this.ch() === "=") {
-					this.pos++;
-					this.skipTypeExpr();
-				}
-				this.consume(";");
-				if (name) out[name] = type;
+			case "var":
+				this._parseMemberVarDecl(out);
 				break;
-			}
-			default: {
-				// Could be: propertyName: Type  or  methodName(params): Type
-				const name = kw;
-				this.skip();
-				this.consume("?"); // optional property
-				this.skipGenerics();
-				this.skip();
-
-				if (this.ch() === "(") {
-					// Method signature
-					const params = this.parseParams();
-					this.skip();
-					let ret = VOID;
-					if (this.ch() === ":") {
-						this.pos++;
-						ret = this.parseType();
-					}
-					this.consume(";");
-					out[name] = {
-						kind: "func",
-						params: params.map((p) => p.type),
-						returns: [ret],
-					};
-				} else if (this.ch() === ":") {
-					this.pos++;
-					const type = this.parseType();
-					this.consume(";");
-					out[name] = type;
-				} else {
-					// Unknown — skip to next ;
-					this.skipTypeExpr();
-					this.consume(";");
-				}
+			default:
+				this._parseMemberDefault(kw, out);
 				break;
-			}
 		}
 	}
 
+	_parseMemberDefault(name, out) {
+		this.skip();
+		this.consume("?"); // optional property
+		this.skipGenerics();
+		this.skip();
+
+		if (this.ch() === "(") {
+			// Method signature
+			const params = this.parseParams();
+			this.skip();
+			let ret = VOID;
+			if (this.ch() === ":") {
+				this.pos++;
+				ret = this.parseType();
+			}
+			this.consume(";");
+			out[name] = {
+				kind: "func",
+				params: params.map((p) => p.type),
+				returns: [ret],
+			};
+		} else if (this.ch() === ":") {
+			this.pos++;
+			const type = this.parseType();
+			this.consume(";");
+			out[name] = type;
+		} else {
+			// Unknown — skip to next ;
+			this.skipTypeExpr();
+			this.consume(";");
+		}
+	}
 	_readStringLit() {
 		this.skip();
 		const c = this.ch();
@@ -585,34 +563,26 @@ export class DtsParser {
 
 	// ── Top-level parse ──────────────────────────────────────────
 
-	parse() {
-		const types = new Map(); // type namespace (for type annotations)
-		const values = new Map(); // value namespace (for expressions)
-
-		// If wrapped in `declare module "name" { ... }`, strip the wrapper
-		this.skip();
+	_parseDeclareModuleWrapper() {
 		if (this.matchKw("declare") && this.matchKw("module")) {
 			this._readStringLit() || this.readIdent();
 			this.skip();
 			this.consume("{");
 		}
+	}
+
+	parse() {
+		const types = new Map();
+		const values = new Map();
+
+		this.skip();
+		this._parseDeclareModuleWrapper();
 
 		while (!this.eof() && this.peek() !== "}") {
 			this.skip();
 			if (this.eof() || this.ch() === "}") break;
 
-			// Collect modifiers
-			while (true) {
-				this.skip();
-				let found = false;
-				for (const mod of SKIP_MODIFIERS) {
-					if (this.matchKw(mod)) {
-						found = true;
-						break;
-					}
-				}
-				if (!found) break;
-			}
+			this._skipModifiers();
 
 			this.skip();
 			if (this.eof() || this.ch() === "}") break;
@@ -624,131 +594,145 @@ export class DtsParser {
 			}
 
 			this.skip();
-			switch (kw) {
-				case "import":
-				case "export":
-					// skip import { ... } from "..." or export { ... }
-					this.skipTypeExpr();
-					this.consume(";");
-					break;
-				case "type": {
-					const name = this.readIdent();
-					this.skipGenerics();
-					this.skip();
-					let type = ANY;
-					if (this.ch() === "=") {
-						this.pos++;
-						type = this.parseType();
-					}
-					this.consume(";");
-					if (name) types.set(name, type);
-					break;
-				}
-				case "interface": {
-					const name = this.readIdent();
-					this.skipGenerics();
-					while (!this.eof() && this.ch() !== "{") this.pos++;
-					this.consume("{");
-					const body = this.parseBody();
-					this.consume("}");
-					this.consume(";");
-					if (name)
-						types.set(name, {
-							kind: "namespace",
-							name,
-							members: body,
-						});
-					break;
-				}
-				case "namespace":
-				case "module": {
-					const name = this.readIdent() || this._readStringLit();
-					this.skip();
-					this.consume("{");
-					const body = this.parseBody();
-					this.consume("}");
-					this.consume(";");
-					if (name) {
-						const ns = { kind: "namespace", name, members: body };
-						types.set(name, ns);
-						values.set(name, ns);
-					}
-					break;
-				}
-				case "class": {
-					const name = this.readIdent();
-					this.skipGenerics();
-					while (!this.eof() && this.ch() !== "{") this.pos++;
-					this.consume("{");
-					const body = this.parseBody();
-					this.consume("}");
-					this.consume(";");
-					if (name) {
-						const ns = { kind: "namespace", name, members: body };
-						types.set(name, ns);
-						values.set(name, ns);
-					}
-					break;
-				}
-				case "enum": {
-					const name = this.readIdent();
-					this.skipBlock();
-					this.consume(";");
-					if (name) {
-						types.set(name, ANY);
-						values.set(name, ANY);
-					}
-					break;
-				}
-				case "function": {
-					const name = this.readIdent();
-					this.skipGenerics();
-					const params = this.parseParams();
-					this.skip();
-					let ret = VOID;
-					if (this.ch() === ":") {
-						this.pos++;
-						ret = this.parseType();
-					}
-					this.consume(";");
-					if (name)
-						values.set(name, {
-							kind: "func",
-							params: params.map((p) => p.type),
-							returns: [ret],
-						});
-					break;
-				}
-				case "const":
-				case "let":
-				case "var": {
-					const name = this.readIdent();
-					this.skip();
-					this.consume("?");
-					let type = ANY;
-					if (this.ch() === ":") {
-						this.pos++;
-						type = this.parseType();
-					}
-					this.skip();
-					if (this.ch() === "=") {
-						this.pos++;
-						this.skipTypeExpr();
-					}
-					this.consume(";");
-					if (name) values.set(name, type);
-					break;
-				}
-				default:
-					// Unknown top-level construct — skip to next ;
-					this.skipTypeExpr();
-					this.consume(";");
-					break;
+			const savedPos = this.pos;
+			try {
+				this._parseTopLevelDecl(kw, types, values);
+			} catch (err) {
+				this.pos = savedPos;
+				// skip to next top-level boundary (;, }, or EOF) to resume parsing
+				while (!this.eof() && this.ch() !== ";" && this.ch() !== "}")
+					this.pos++;
+				this.consume(";");
+				console.warn(
+					`[dts-parser] skipping malformed declaration '${kw}': ${err.message}`,
+				);
 			}
 		}
 
 		return { types, values };
 	}
+
+	_parseTopLevelTypeAlias(types) {
+		const name = this.readIdent();
+		this.skipGenerics();
+		this.skip();
+		let type = ANY;
+		if (this.ch() === "=") {
+			this.pos++;
+			type = this.parseType();
+		}
+		this.consume(";");
+		if (name) types.set(name, type);
+	}
+
+	_parseTopLevelClassDecl(kw, types, values) {
+		const name = this.readIdent();
+		this.skipGenerics();
+		while (!this.eof() && this.ch() !== "{") this.pos++;
+		this.consume("{");
+		const body = this.parseBody();
+		this.consume("}");
+		this.consume(";");
+		if (name) {
+			const ns = { kind: "namespace", name, members: body };
+			types.set(name, ns);
+			if (kw === "class") values.set(name, ns);
+		}
+	}
+
+	_parseTopLevelNamespaceDecl(types, values) {
+		const name = this.readIdent() || this._readStringLit();
+		this.skip();
+		this.consume("{");
+		const body = this.parseBody();
+		this.consume("}");
+		this.consume(";");
+		if (name) {
+			const ns = { kind: "namespace", name, members: body };
+			types.set(name, ns);
+			values.set(name, ns);
+		}
+	}
+
+	_parseTopLevelFuncDecl(values) {
+		const name = this.readIdent();
+		this.skipGenerics();
+		const params = this.parseParams();
+		this.skip();
+		let ret = VOID;
+		if (this.ch() === ":") {
+			this.pos++;
+			ret = this.parseType();
+		}
+		this.consume(";");
+		if (name)
+			values.set(name, {
+				kind: "func",
+				params: params.map((p) => p.type),
+				returns: [ret],
+			});
+	}
+
+	_parseTopLevelVarDecl(values) {
+		const name = this.readIdent();
+		this.skip();
+		this.consume("?");
+		let type = ANY;
+		if (this.ch() === ":") {
+			this.pos++;
+			type = this.parseType();
+		}
+		this.skip();
+		if (this.ch() === "=") {
+			this.pos++;
+			this.skipTypeExpr();
+		}
+		this.consume(";");
+		if (name) values.set(name, type);
+	}
+
+	_parseTopLevelDecl(kw, types, values) {
+		switch (kw) {
+			case "import":
+			case "export":
+				this.skipTypeExpr();
+				this.consume(";");
+				break;
+			case "type":
+				this._parseTopLevelTypeAlias(types);
+				break;
+			case "interface":
+			case "class":
+				this._parseTopLevelClassDecl(kw, types, values);
+				break;
+			case "namespace":
+			case "module":
+				this._parseTopLevelNamespaceDecl(types, values);
+				break;
+			case "enum": {
+				const name = this.readIdent();
+				this.skipBlock();
+				this.consume(";");
+				if (name) {
+					types.set(name, ANY);
+					values.set(name, ANY);
+				}
+				break;
+			}
+			case "function":
+				this._parseTopLevelFuncDecl(values);
+				break;
+			case "const":
+			case "let":
+			case "var":
+				this._parseTopLevelVarDecl(values);
+				break;
+			default:
+				this.skipTypeExpr();
+				this.consume(";");
+				break;
+		}
+	}
 }
 
 // Helper: parse a .d.ts file and return { types, values } Maps