@ts-for-gir/lib 4.0.0-rc.1 → 4.0.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-for-gir/lib",
-  "version": "4.0.0-rc.1",
+  "version": "4.0.0-rc.3",
   "description": "Typescript .d.ts generator from GIR for gjs",
   "main": "src/index.ts",
   "module": "src/index.ts",
@@ -41,7 +41,7 @@
     "type definitions"
   ],
   "devDependencies": {
-    "@ts-for-gir/tsconfig": "^4.0.0-rc.1",
+    "@ts-for-gir/tsconfig": "^4.0.0-rc.3",
     "@types/ejs": "^3.1.5",
     "@types/lodash": "^4.17.24",
     "@types/node": "^24.12.2",
@@ -49,9 +49,9 @@
     "typescript": "^6.0.2"
   },
   "dependencies": {
-    "@gi.ts/parser": "^4.0.0-rc.1",
-    "@ts-for-gir/reporter": "^4.0.0-rc.1",
-    "@ts-for-gir/templates": "^4.0.0-rc.1",
+    "@gi.ts/parser": "^4.0.0-rc.3",
+    "@ts-for-gir/reporter": "^4.0.0-rc.3",
+    "@ts-for-gir/templates": "^4.0.0-rc.3",
     "colorette": "^2.0.20",
     "ejs": "^5.0.1",
     "glob": "^13.0.6",

package/src/gir/registry.ts

@@ -8,7 +8,6 @@ import { inject } from "../injections/inject.ts";
 import type { GeneratorConstructor, OptionsGeneration, OptionsTransform } from "../types/index.ts";
 import { TwoKeyMap } from "../util.ts";
 import { ClassVisitor } from "../validators/class.ts";
-import { FunctionParametersVisitor } from "../validators/function-parameters.ts";
 import { InterfaceVisitor } from "../validators/interface.ts";
 import type { GirVisitor } from "../visitor.ts";
 import type { IntrospectedNamespace } from "./namespace.ts";
@@ -113,13 +112,12 @@ export class NSRegistry {
 		GObject.package_version = [...GLib.package_version];
 
 		const interfaceVisitor = new InterfaceVisitor();
+
 		this.registerTransformation(interfaceVisitor);
 
 		const classVisitor = new ClassVisitor();
-		this.registerTransformation(classVisitor);
 
-		const enumParamsVisitor = new FunctionParametersVisitor();
-		this.registerTransformation(enumParamsVisitor);
+		this.registerTransformation(classVisitor);
 
 		console.log("Adding generics...");
 		generify(this, options.inferGenerics);

package/src/gir.ts

@@ -23,7 +23,7 @@ export enum ConflictType {
 
 import { type ConsoleReporter, LazyReporter } from "@ts-for-gir/reporter";
 import type { IntrospectedField, IntrospectedProperty } from "./gir/property.ts";
-import type { OptionsBase } from "./types/index.ts";
+import type { OptionsGeneration } from "./types/index.ts";
 import { isInvalid, sanitizeIdentifierName, sanitizeNamespace } from "./utils/naming.ts";
 
 export abstract class TypeExpression {
@@ -37,10 +37,10 @@ export abstract class TypeExpression {
 	}
 
 	abstract rewrap(type: TypeExpression): TypeExpression;
-	abstract resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression;
+	abstract resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression;
 
-	abstract print(namespace: IntrospectedNamespace, options: OptionsBase): string;
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	abstract print(namespace: IntrospectedNamespace, options: OptionsGeneration): string;
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return this.print(namespace, options);
 	}
 }
@@ -89,7 +89,7 @@ export class TypeIdentifier extends TypeExpression {
 		return new TypeIdentifier(sanitizeIdentifierName(this.namespace, this.name), sanitizeNamespace(this.namespace));
 	}
 
-	protected _resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeIdentifier | null {
+	protected _resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeIdentifier | null {
 		const name: string = sanitizeIdentifierName(null, this.name);
 		const unresolvedNamespaceName = this.namespace;
 
@@ -183,11 +183,11 @@ export class TypeIdentifier extends TypeExpression {
 		return null;
 	}
 
-	resolveIdentifier(namespace: IntrospectedNamespace, options: OptionsBase): TypeIdentifier | null {
+	resolveIdentifier(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeIdentifier | null {
 		return this._resolve(namespace, options);
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		const resolved = this._resolve(namespace, options);
 
 		// Generally if we can't resolve a type it is not introspectable,
@@ -199,7 +199,7 @@ export class TypeIdentifier extends TypeExpression {
 		return new TypeIdentifier(name, namespace);
 	}
 
-	print(namespace: IntrospectedNamespace, _options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, _options: OptionsGeneration): string {
 		if (namespace.hasSymbol(this.namespace) && this.namespace !== namespace.namespace) {
 			// TODO: Move to TypeScript generator...
 			// Libraries like zbar have classes named things like "Gtk"
@@ -248,11 +248,11 @@ export class ModuleTypeIdentifier extends TypeIdentifier {
 		);
 	}
 
-	protected _resolve(_namespace: IntrospectedNamespace, _options: OptionsBase): ModuleTypeIdentifier | null {
+	protected _resolve(_namespace: IntrospectedNamespace, _options: OptionsGeneration): ModuleTypeIdentifier | null {
 		return this;
 	}
 
-	print(namespace: IntrospectedNamespace, _options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, _options: OptionsGeneration): string {
 		if (namespace.namespace === this.namespace) {
 			return `${this.moduleName}.${this.name}`;
 		} else {
@@ -269,7 +269,7 @@ export class ClassStructTypeIdentifier extends TypeIdentifier {
 		return type instanceof ClassStructTypeIdentifier && super.equals(type);
 	}
 
-	print(namespace: IntrospectedNamespace, _options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, _options: OptionsGeneration): string {
 		if (namespace.namespace === this.namespace) {
 			// TODO: Mapping to invalid names should happen at the generator level...
 			return `typeof ${isInvalid(this.name) ? `__${this.name}` : this.name}`;
@@ -287,7 +287,7 @@ export class GenerifiedTypeIdentifier extends TypeIdentifier {
 		this.generics = generics;
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		const Generics = this.generics.map((generic) => generic.print(namespace, options)).join(", ");
 
 		if (namespace.namespace === this.namespace) {
@@ -297,7 +297,7 @@ export class GenerifiedTypeIdentifier extends TypeIdentifier {
 		}
 	}
 
-	_resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeIdentifier | null {
+	_resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeIdentifier | null {
 		const iden = super._resolve(namespace, options);
 
 		if (iden) {
@@ -309,9 +309,9 @@ export class GenerifiedTypeIdentifier extends TypeIdentifier {
 }
 
 export class NativeType extends TypeExpression {
-	readonly expression: (options?: OptionsBase) => string;
+	readonly expression: (options?: OptionsGeneration) => string;
 
-	constructor(expression: ((options?: OptionsBase) => string) | string) {
+	constructor(expression: ((options?: OptionsGeneration) => string) | string) {
 		super();
 		this.expression = typeof expression === "string" ? () => expression : expression;
 	}
@@ -324,11 +324,11 @@ export class NativeType extends TypeExpression {
 		return this;
 	}
 
-	print(_namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(_namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return this.expression(options);
 	}
 
-	equals(type: TypeExpression, options?: OptionsBase): boolean {
+	equals(type: TypeExpression, options?: OptionsGeneration): boolean {
 		return type instanceof NativeType && this.expression(options) === type.expression(options);
 	}
 
@@ -336,7 +336,7 @@ export class NativeType extends TypeExpression {
 		return this;
 	}
 
-	static withGenerator(generator: (options?: OptionsBase) => string): TypeExpression {
+	static withGenerator(generator: (options?: OptionsGeneration) => string): TypeExpression {
 		return new NativeType(generator);
 	}
 
@@ -361,17 +361,17 @@ export class OrType extends TypeExpression {
 		return this;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		const [type, ...types] = this.types;
 
 		return new OrType(type.resolve(namespace, options), ...types.map((t) => t.resolve(namespace, options)));
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return `(${this.types.map((t) => t.print(namespace, options)).join(" | ")})`;
 	}
 
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return `${this.types.map((t) => t.print(namespace, options)).join(" | ")}`;
 	}
 
@@ -385,15 +385,15 @@ export class OrType extends TypeExpression {
 }
 
 export class TupleType extends OrType {
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return `[${this.types.map((t) => t.print(namespace, options)).join(", ")}]`;
 	}
 
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return this.print(namespace, options);
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		const [type, ...types] = this.types;
 
 		return new TupleType(type.resolve(namespace, options), ...types.map((t) => t.resolve(namespace, options)));
@@ -413,7 +413,7 @@ export class BinaryType extends OrType {
 		return this;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase) {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration) {
 		return new BinaryType(this.a.resolve(namespace, options), this.b.resolve(namespace, options));
 	}
 
@@ -465,7 +465,7 @@ export class FunctionType extends TypeExpression {
 		return this;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		return new FunctionType(
 			Object.fromEntries(
 				Object.entries(this.parameterTypes).map(([k, p]) => {
@@ -476,7 +476,7 @@ export class FunctionType extends TypeExpression {
 		);
 	}
 
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		const Parameters = Object.entries(this.parameterTypes)
 			.map(([k, v]) => {
 				return `${k}: ${v.rootPrint(namespace, options)}`;
@@ -486,7 +486,7 @@ export class FunctionType extends TypeExpression {
 		return `(${Parameters}) => ${this.returnType.print(namespace, options)}`;
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return `(${this.rootPrint(namespace, options)})`;
 	}
 }
@@ -548,7 +548,7 @@ export class GenerifiedType extends TypeExpression {
 		this.generic = generic;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase) {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration) {
 		return new GenerifiedType(this.type.resolve(namespace, options), this.generic);
 	}
 
@@ -556,11 +556,11 @@ export class GenerifiedType extends TypeExpression {
 		return this.type;
 	}
 
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase) {
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration) {
 		return this.type.rootPrint(namespace, options);
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase) {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration) {
 		return `${this.type.print(namespace, options)}<${this.generic.print()}>`;
 	}
 
@@ -652,11 +652,11 @@ export class PromiseType extends TypeExpression {
 		return new PromiseType(this.type.rewrap(type));
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		return new PromiseType(this.type.resolve(namespace, options));
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		if (this.type.equals(VoidType)) {
 			return "globalThis.Promise<void>";
 		}
@@ -664,7 +664,7 @@ export class PromiseType extends TypeExpression {
 		return `globalThis.Promise<${this.type.print(namespace, options)}>`;
 	}
 
-	rootPrint(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return this.print(namespace, options);
 	}
 }
@@ -703,13 +703,13 @@ export class TypeConflict extends TypeExpression {
 		return true;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		const resolvedType = this.type.resolve(namespace, options);
 		const typeString = resolvedType.print(namespace, options);
 		throw new Error(`Type conflict was not resolved for ${typeString} in ${namespace.namespace}`);
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		const resolvedType = this.type.resolve(namespace, options);
 		const typeString = resolvedType.print(namespace, options);
 		throw new Error(`Type conflict was not resolved for ${typeString} in ${namespace.namespace}`);
@@ -750,7 +750,7 @@ export class ClosureType extends TypeExpression {
 		return this;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase) {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration) {
 		const { user_data, type } = this;
 
 		return ClosureType.new({
@@ -759,7 +759,7 @@ export class ClosureType extends TypeExpression {
 		});
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return this.type.print(namespace, options);
 	}
 
@@ -807,7 +807,7 @@ export class ArrayType extends TypeExpression {
 		return false;
 	}
 
-	resolve(namespace: IntrospectedNamespace, options: OptionsBase): TypeExpression {
+	resolve(namespace: IntrospectedNamespace, options: OptionsGeneration): TypeExpression {
 		const { type, arrayDepth, length } = this;
 		return ArrayType.new({
 			type: type.resolve(namespace, options),
@@ -816,7 +816,7 @@ export class ArrayType extends TypeExpression {
 		});
 	}
 
-	print(namespace: IntrospectedNamespace, options: OptionsBase): string {
+	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		const depth = this.arrayDepth;
 		let typeSuffix: string = "";
 
@@ -861,6 +861,7 @@ export const Uint8ArrayType = new NativeType("Uint8Array");
 export const BooleanType = new NativeType("boolean");
 export const StringType = new NativeType("string");
 export const NumberType = new NativeType("number");
+export const BigintOrNumberType = new BinaryType(new NativeType("bigint"), NumberType);
 export const NullType = new NativeType("null");
 export const VoidType = new NativeType("void");
 export const UnknownType = new NativeType("unknown");

package/src/utils/gir-parsing.ts

@@ -14,6 +14,7 @@ import { LazyReporter } from "@ts-for-gir/reporter";
 import type { IntrospectedNamespace } from "../gir/namespace.ts";
 import {
 	ArrayType,
+	BigintOrNumberType,
 	ClosureType,
 	GenerifiedTypeIdentifier,
 	NativeType,
@@ -238,7 +239,8 @@ export function getType(
 		parameter.$ &&
 		(parameter.$.direction === GirDirection.Inout || parameter.$.direction === GirDirection.Out) &&
 		(nullable || allowNone) &&
-		!(variableType instanceof NativeType)
+		!(variableType instanceof NativeType) &&
+		variableType !== BigintOrNumberType
 	) {
 		return new NullableType(variableType);
 	}

package/src/utils/types.ts

@@ -4,14 +4,19 @@ import type { IntrospectedNamespace } from "../gir/namespace.ts";
 import {
 	AnyType,
 	ArrayType,
+	BigintOrNumberType,
 	BinaryType,
 	BooleanType,
 	NativeType,
 	NeverType,
+	NullableType,
 	NumberType,
 	ObjectType,
+	OrType,
+	PromiseType,
 	StringType,
 	ThisType,
+	TupleType,
 	type TypeExpression,
 	TypeIdentifier,
 	Uint8ArrayType,
@@ -167,18 +172,20 @@ export function resolvePrimitiveType(name: string): TypeExpression | null {
 		case "gfloat":
 		case "gchar":
 		case "guint":
-		case "glong":
-		case "gulong":
 		case "gint":
 		case "guint8":
+		case "gdouble":
+			return NumberType;
+		case "glong":
+		case "gulong":
 		case "guint64":
 		case "gint64":
-		case "gdouble":
 		case "gssize":
 		case "gsize":
+		case "guintptr": // Integer of the same width as a pointer
 		case "time_t": // C standard library time type (seconds since Unix epoch)
 		case "ulong": // C standard library unsigned long type
-			return NumberType;
+			return BigintOrNumberType;
 		case "gboolean":
 			return BooleanType;
 		case "gpointer": // This is typically used in callbacks to pass data, so we'll allow anything.
@@ -187,8 +194,6 @@ export function resolvePrimitiveType(name: string): TypeExpression | null {
 			return ObjectType;
 		case "va_list":
 			return AnyType;
-		case "guintptr": // You can't use pointers in GJS! (at least that I'm aware of)
-			return NeverType;
 		case "never": // Support TS "never"
 			return NeverType;
 		case "unknown": // Support TS "unknown"
@@ -243,6 +248,27 @@ export function resolveDirectedType(type: TypeExpression, direction: GirDirectio
 				return type;
 			}
 		}
+	} else if (type === BigintOrNumberType && direction === GirDirection.Out) {
+		// 64-bit integers accept number or bigint, but only return number to JS
+		return NumberType;
+	} else if (type instanceof PromiseType) {
+		// Propagate direction into the Promise's inner type so e.g. async
+		// functions returning 64-bit ints resolve to `Promise<number>` rather
+		// than `Promise<bigint | number>`.
+		const resolvedInner = resolveDirectedType(type.type, direction);
+		if (resolvedInner) return new PromiseType(resolvedInner);
+	} else if (type instanceof BinaryType && !(type instanceof NullableType)) {
+		// Walk through binary unions like `Promise<T> | void` (the dual-call
+		// async overload) so the inner types still get direction propagation.
+		// NullableType is skipped to preserve its subclass behaviour.
+		const a = resolveDirectedType(type.a, direction) ?? type.a;
+		const b = resolveDirectedType(type.b, direction) ?? type.b;
+		if (a !== type.a || b !== type.b) return new BinaryType(a, b);
+	} else if (type instanceof OrType && !(type instanceof BinaryType || type instanceof TupleType)) {
+		// flatten "bigint | number" out of another OR-type
+		const types = type.types.map((t) => resolveDirectedType(t, direction) ?? t);
+		if (types.length === 1) return types[0];
+		return new OrType(types[0], ...types.slice(1));
 	}
 
 	return null;

package/src/validators/function-parameters.ts

@@ -1,52 +0,0 @@
-import type { IntrospectedEnum } from "../gir/enum.ts";
-import type { IntrospectedFunction } from "../gir/function.ts";
-import type { IntrospectedBaseClass, IntrospectedClassFunction } from "../gir/introspected-classes.ts";
-
-import { NullableType, TypeIdentifier } from "../gir.ts";
-import { GirVisitor } from "../visitor.ts";
-
-export class FunctionParametersVisitor extends GirVisitor {
-	/**
-	 * Marks all enum parameters of a function as nullable,
-	 * because GJS allows null values for enum parameters and treats them as a 0 value.
-	 * See issue [#207](https://github.com/gjsify/ts-for-gir/issues/207).
-	 */
-	private makeEnumParamsNullable(node: IntrospectedFunction): IntrospectedFunction;
-	private makeEnumParamsNullable<T extends IntrospectedBaseClass | IntrospectedEnum>(
-		node: IntrospectedClassFunction<T>,
-	): IntrospectedClassFunction<T>;
-	private makeEnumParamsNullable(
-		node: IntrospectedFunction | IntrospectedClassFunction,
-	): IntrospectedFunction | IntrospectedClassFunction {
-		return node.copy({
-			parameters: node.parameters.map((param) => {
-				const type = param.type.deepUnwrap();
-				if (type instanceof TypeIdentifier) {
-					// Get the namespace where this type should be defined
-					const ns = node.namespace.assertInstalledImport(type.namespace);
-
-					// Check if the type is an enum
-					const isEnumType = !!ns.getEnum(type.name);
-
-					// If it is, make the parameter nullable
-					if (isEnumType) {
-						return param.copy({
-							type: new NullableType(param.type),
-						});
-					}
-				}
-				return param;
-			}),
-		});
-	}
-
-	visitFunction = (node: IntrospectedFunction): IntrospectedFunction => {
-		return this.makeEnumParamsNullable(node);
-	};
-
-	visitClassFunction = <T extends IntrospectedBaseClass | IntrospectedEnum>(
-		node: IntrospectedClassFunction<T>,
-	): IntrospectedClassFunction<T> => {
-		return this.makeEnumParamsNullable(node);
-	};
-}