@ts-for-gir/lib 4.0.0-beta.40 → 4.0.0-beta.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-for-gir/lib",
-  "version": "4.0.0-beta.40",
+  "version": "4.0.0-beta.42",
   "description": "Typescript .d.ts generator from GIR for gjs",
   "main": "src/index.ts",
   "module": "src/index.ts",
@@ -41,18 +41,19 @@
     "type definitions"
   ],
   "devDependencies": {
+    "@ts-for-gir/tsconfig": "^4.0.0-beta.42",
     "@types/ejs": "^3.1.5",
     "@types/lodash": "^4.17.24",
-    "@types/node": "^24.11.0",
+    "@types/node": "^24.12.0",
     "rimraf": "^6.1.3",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@gi.ts/parser": "^4.0.0-beta.40",
-    "@ts-for-gir/reporter": "^4.0.0-beta.40",
-    "@ts-for-gir/templates": "^4.0.0-beta.40",
+    "@gi.ts/parser": "^4.0.0-beta.42",
+    "@ts-for-gir/reporter": "^4.0.0-beta.42",
+    "@ts-for-gir/templates": "^4.0.0-beta.42",
     "colorette": "^2.0.20",
-    "ejs": "^4.0.1",
+    "ejs": "^5.0.1",
     "glob": "^13.0.6",
     "lodash": "^4.17.23"
   }

package/src/constants.ts

@@ -8,61 +8,27 @@ export const PARAM_REG_EXP = /[0-9a-zA-Z_]*:/g;
 export const OPT_PARAM_REG_EXP = /[0-9a-zA-Z_]*\?:/g;
 export const NEW_LINE_REG_EXP = /[\n\r]+/g;
 
-/**
- * Package information interface for package.json
- */
-interface Package {
-	name: string;
-	version: string;
-	description: string;
-	license: string;
-	homepage: string;
-	author: string;
-}
+declare const __TS_FOR_GIR_VERSION__: string;
 
 /**
- * Resolves the current package's package.json path
- * Uses import.meta.url for ES Module compatibility
- * Works both in workspace and after publishing
+ * Reads the package version, using the build-time injected value when bundled
+ * or falling back to reading package.json in development mode.
  */
-function resolvePackageJson(): string {
-	try {
-		// Get the directory of the current module
-		const currentModulePath = fileURLToPath(import.meta.url);
-		const currentDir = dirname(currentModulePath);
-
-		// Go up to the package root (src/ -> package root)
-		const packageRoot = join(currentDir, "..");
-		const packageJsonPath = join(packageRoot, "package.json");
-
-		return packageJsonPath;
-	} catch (error) {
-		throw new Error(`Unable to resolve package.json path: ${error instanceof Error ? error.message : "Unknown error"}`);
+function getPackageVersion(): string {
+	if (typeof __TS_FOR_GIR_VERSION__ !== "undefined") {
+		return __TS_FOR_GIR_VERSION__;
 	}
+	const currentModulePath = fileURLToPath(import.meta.url);
+	const currentDir = dirname(currentModulePath);
+	const packageJsonPath = join(currentDir, "..", "package.json");
+	const content = readFileSync(packageJsonPath, "utf-8");
+	return (JSON.parse(content) as { version: string }).version;
 }
 
-/**
- * Reads and parses the current package's package.json file synchronously
- * Contains version and metadata for this specific package
- */
-function readPackageSync(): Package {
-	try {
-		const packagePath = resolvePackageJson();
-		const content = readFileSync(packagePath, "utf-8");
-		return JSON.parse(content) as Package;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : "Unknown error";
-		throw new Error(`Failed to read package.json: ${message}`);
-	}
-}
-
-// Read package information once at module load
-export const PACKAGE = readPackageSync();
-
 export const APP_NAME = "ts-for-gir";
 export const APP_USAGE = "TypeScript type definition generator for GObject introspection GIR files";
 export const APP_SOURCE = "https://github.com/gjsify/ts-for-gir";
-export const APP_VERSION = PACKAGE.version;
+export const APP_VERSION = getPackageVersion();
 
 export const PACKAGE_DESC = (packageName: string, libraryVersion?: LibraryVersion) => {
 	if (libraryVersion) {
@@ -149,4 +115,4 @@ export const RESERVED_CLASS_NAMES = [
 
 export const RESERVED_FUNCTION_NAMES = ["false", "true", "break"];
 
-export const RESERVED_NAMESPACE_NAMES = {};
+export const RESERVED_NAMESPACE_NAMES: Record<string, boolean> = {};

package/src/gir/alias.ts

@@ -2,7 +2,7 @@ import type { FormatGenerator, GenericDescriptor } from "../generators/generator
 import type { TypeExpression } from "../gir.ts";
 import type { GirAliasElement } from "../index.ts";
 import type { IntrospectedOptions, OptionsLoad } from "../types/index.ts";
-import { parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
+import { girParsingReporter, parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
 import { isIntrospectable } from "../utils/girs.ts";
 import { sanitizeIdentifierName } from "../utils/naming.ts";
 import { getAliasType } from "../utils/types.ts";
@@ -52,7 +52,7 @@ export class IntrospectedAlias extends IntrospectedNamespaceMember {
 
 	static fromXML(element: GirAliasElement, ns: IntrospectedNamespace, options: OptionsLoad): IntrospectedAlias | null {
 		if (!element.$.name) {
-			console.error(`Alias in ${ns.namespace} lacks name.`);
+			girParsingReporter.get().reportParsingFailure("alias", "alias", ns.namespace, "Alias lacks name attribute");
 			return null;
 		}
 

package/src/gir/introspected-classes.ts

@@ -72,6 +72,8 @@ export class IntrospectedClassFunction<
 	protected _generify: boolean = false;
 	interfaceParent: IntrospectedBaseClass | IntrospectedEnum | null = null;
 	returnTypeDoc?: string | null;
+	/** If this function was generated from a signal, stores the signal name. */
+	signalOrigin?: string;
 
 	generics: Generic[] = [];
 
@@ -794,105 +796,66 @@ export class IntrospectedClass extends IntrospectedBaseClass {
 		);
 	}
 
-	implementedProperties(potentialConflicts: IntrospectedBase<never>[] = []) {
+	private collectImplementedItems<T extends { name: string }>(
+		getItems: (node: IntrospectedBaseClass) => T[],
+		validate: (item: T) => boolean,
+	): Map<string, T> {
 		const resolution = this.resolveParents();
 		const implementedOnParent = [...(resolution.extends() ?? [])].flatMap((r) => r.implements());
-		const properties = new Map<string, IntrospectedProperty>();
-
-		const validateProp = (prop: IntrospectedProperty) =>
-			!this.hasInstanceSymbol(prop) &&
-			!properties.has(prop.name) &&
-			potentialConflicts.every((p) => prop.name !== p.name);
+		const items = new Map<string, T>();
 
 		for (const implemented of resolution.implements()) {
 			if (implemented.node instanceof IntrospectedClass) continue;
-
 			if (implementedOnParent.find((p) => p.identifier.equals(implemented.identifier))?.node?.generics?.length === 0)
 				continue;
-			for (const prop of implemented.node.props) {
-				if (!validateProp(prop)) continue;
-				properties.set(prop.name, prop);
+			for (const item of getItems(implemented.node)) {
+				if (items.has(item.name) || !validate(item)) continue;
+				items.set(item.name, item);
 			}
 		}
 
 		for (const implemented of resolution.implements()) {
 			[...implemented].forEach((e) => {
 				if (e.node instanceof IntrospectedClass) return;
-
 				if (implementedOnParent.find((p) => p.identifier.equals(e.identifier))?.node.generics.length === 0) return;
-				for (const prop of e.node.props) {
-					if (!validateProp(prop)) continue;
-
-					properties.set(prop.name, prop);
+				for (const item of getItems(e.node)) {
+					if (items.has(item.name) || !validate(item)) continue;
+					items.set(item.name, item);
 				}
 			});
 		}
 
 		// If an interface inherits from a class (such as Gtk.Widget)
-		// we need to pull in every property from that class...
+		// we need to pull in every item from that class...
 		for (const implemented of resolution.implements()) {
 			const extended = implemented.extends();
-
 			if (extended?.node instanceof IntrospectedClass) {
-				for (const prop of extended.node.props) {
-					if (!validateProp(prop)) continue;
-
-					properties.set(prop.name, prop);
+				for (const item of getItems(extended.node)) {
+					if (items.has(item.name) || !validate(item)) continue;
+					items.set(item.name, item);
 				}
 			}
 		}
 
+		return items;
+	}
+
+	implementedProperties(potentialConflicts: IntrospectedBase<never>[] = []) {
+		const properties = this.collectImplementedItems(
+			(node) => node.props,
+			(prop) => !this.hasInstanceSymbol(prop) && potentialConflicts.every((p) => prop.name !== p.name),
+		);
 		return [...properties.values()];
 	}
 
 	implementedMethods(potentialConflicts: ClassMember[] = []) {
-		const resolution = this.resolveParents();
-		const implementedOnParent = [...(resolution.extends() ?? [])].flatMap((r) => r.implements());
-		const methods = new Map<string, IntrospectedClassFunction>();
-
-		const validateMethod = (method: IntrospectedClassFunction) =>
-			!(method instanceof IntrospectedStaticClassFunction) &&
-			!this.hasInstanceSymbol(method) &&
-			!methods.has(method.name) &&
-			potentialConflicts.every((m) => method.name !== m.name);
-
-		for (const implemented of resolution.implements()) {
-			if (implemented.node instanceof IntrospectedClass) continue;
-
-			if (implementedOnParent.find((p) => p.identifier.equals(implemented.identifier))?.node?.generics?.length === 0)
-				continue;
-			for (const member of implemented.node.members) {
-				if (!validateMethod(member)) continue;
-				methods.set(member.name, member);
-			}
-		}
-
-		for (const implemented of resolution.implements()) {
-			[...implemented].forEach((e) => {
-				if (e.node instanceof IntrospectedClass) return;
-
-				if (implementedOnParent.find((p) => p.identifier.equals(e.identifier))?.node.generics.length === 0) return;
-				for (const member of e.node.members) {
-					if (!validateMethod(member)) continue;
-
-					methods.set(member.name, member);
-				}
-			});
-		}
-
-		// If an interface inherits from a class (such as Gtk.Widget)
-		// we need to pull in every method from that class...
-		for (const implemented of resolution.implements()) {
-			const extended = implemented.extends();
-
-			if (extended?.node instanceof IntrospectedClass) {
-				for (const member of extended.node.members) {
-					if (!validateMethod(member)) continue;
-
-					methods.set(member.name, member);
-				}
-			}
-		}
+		const methods = this.collectImplementedItems(
+			(node) => node.members,
+			(method) =>
+				!(method instanceof IntrospectedStaticClassFunction) &&
+				!this.hasInstanceSymbol(method) &&
+				potentialConflicts.every((m) => method.name !== m.name),
+		);
 
 		return [...methods.values()].map((f) => {
 			const mapping = new Map<string, TypeExpression>();

package/src/gir/record.ts

@@ -248,7 +248,7 @@ export class IntrospectedRecord extends IntrospectedBaseClass {
 		namespace: IntrospectedNamespace,
 		name: string,
 	): void {
-		const gtypeStructFor = element.$["glib:is-gtype-struct-for"];
+		const gtypeStructFor = "glib:is-gtype-struct-for" in element.$ ? element.$["glib:is-gtype-struct-for"] : undefined;
 
 		if (typeof gtypeStructFor === "string" && gtypeStructFor) {
 			const structFor = parseTypeIdentifier(namespace.namespace, gtypeStructFor);

package/src/gir/registry.ts

@@ -13,7 +13,6 @@ import { InterfaceVisitor } from "../validators/interface.ts";
 import type { GirVisitor } from "../visitor.ts";
 import type { IntrospectedNamespace } from "./namespace.ts";
 
-// TODO: Singleton
 export class NSRegistry {
 	mapping: TwoKeyMap<string, string, IntrospectedNamespace> = new TwoKeyMap();
 	private formatters: Map<string, Formatter> = new Map();

package/src/gir/signal.ts

@@ -34,12 +34,20 @@ export class IntrospectedSignal extends IntrospectedClassMember<IntrospectedClas
 	parameters: IntrospectedFunctionParameter[];
 	return_type: TypeExpression;
 	detailed: boolean;
+	action: boolean;
+	noRecurse: boolean;
+	noHooks: boolean;
+	when?: "first" | "last" | "cleanup";
 
 	constructor({
 		name,
 		parameters = [],
 		return_type = UnknownType,
 		detailed = false,
+		action = false,
+		noRecurse = false,
+		noHooks = false,
+		when,
 		parent,
 		...args
 	}: Options<{
@@ -47,6 +55,10 @@ export class IntrospectedSignal extends IntrospectedClassMember<IntrospectedClas
 		parameters?: IntrospectedFunctionParameter[];
 		return_type?: TypeExpression;
 		detailed?: boolean;
+		action?: boolean;
+		noRecurse?: boolean;
+		noHooks?: boolean;
+		when?: "first" | "last" | "cleanup";
 		parent: IntrospectedClass;
 	}>) {
 		super(name, parent, { ...args });
@@ -54,6 +66,10 @@ export class IntrospectedSignal extends IntrospectedClassMember<IntrospectedClas
 		this.parameters = parameters.map((p) => p.copy({ parent: this }));
 		this.return_type = return_type;
 		this.detailed = detailed;
+		this.action = action;
+		this.noRecurse = noRecurse;
+		this.noHooks = noHooks;
+		this.when = when;
 	}
 
 	accept(visitor: GirVisitor): IntrospectedSignal {
@@ -72,11 +88,19 @@ export class IntrospectedSignal extends IntrospectedClassMember<IntrospectedClas
 		parameters,
 		returnType,
 		detailed,
+		action,
+		noRecurse,
+		noHooks,
+		when,
 	}: {
 		parent?: IntrospectedClass;
 		parameters?: IntrospectedFunctionParameter[];
 		returnType?: TypeExpression;
 		detailed?: boolean;
+		action?: boolean;
+		noRecurse?: boolean;
+		noHooks?: boolean;
+		when?: "first" | "last" | "cleanup";
 	} = {}): IntrospectedSignal {
 		return new IntrospectedSignal({
 			name: this.name,
@@ -84,6 +108,10 @@ export class IntrospectedSignal extends IntrospectedClassMember<IntrospectedClas
 			parameters: parameters ?? this.parameters,
 			return_type: returnType ?? this.return_type,
 			detailed: detailed ?? this.detailed,
+			action: action ?? this.action,
+			noRecurse: noRecurse ?? this.noRecurse,
+			noHooks: noHooks ?? this.noHooks,
+			when: when ?? this.when,
 		})._copyBaseProperties(this);
 	}
 
@@ -93,6 +121,10 @@ export class IntrospectedSignal extends IntrospectedClassMember<IntrospectedClas
 			name: element.$.name,
 			parent,
 			detailed: element.$.detailed === "1",
+			action: element.$.action === "1",
+			noRecurse: element.$["no-recurse"] === "1",
+			noHooks: element.$["no-hooks"] === "1",
+			when: element.$.when as "first" | "last" | "cleanup" | undefined,
 			isIntrospectable: isIntrospectable(element),
 		});