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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-for-gir/lib",
-  "version": "4.0.0-rc.1",
+  "version": "4.0.0-rc.2",
   "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.2",
     "@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.2",
+    "@ts-for-gir/reporter": "^4.0.0-rc.2",
+    "@ts-for-gir/templates": "^4.0.0-rc.2",
     "colorette": "^2.0.20",
     "ejs": "^5.0.1",
     "glob": "^13.0.6",

package/src/gir.ts

@@ -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,19 @@ 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 "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.
@@ -243,6 +249,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;