@ts-for-gir/lib 4.0.0-rc.15 → 4.0.0-rc.17

package/package.json

@@ -1,60 +1,60 @@
 {
-  "name": "@ts-for-gir/lib",
-  "version": "4.0.0-rc.15",
-  "description": "Typescript .d.ts generator from GIR for gjs",
-  "main": "src/index.ts",
-  "module": "src/index.ts",
-  "type": "module",
-  "engines": {
-    "node": ">=18"
-  },
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "scripts": {
-    "check": "tsc --noEmit"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gjsify/ts-for-gir.git"
-  },
-  "author": "Pascal Garber <pascal@mailfreun.de>",
-  "files": [
-    "src"
-  ],
-  "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/gjsify/ts-for-gir/issues"
-  },
-  "homepage": "https://github.com/gjsify/ts-for-gir#readme",
-  "keywords": [
-    "gjs",
-    "typescript",
-    "generate",
-    "gir",
-    "gobject-introspection",
-    "gnome",
-    "gtk",
-    "glib",
-    "gobject",
-    "dts",
-    "type definitions"
-  ],
-  "devDependencies": {
-    "@ts-for-gir/tsconfig": "^4.0.0-rc.15",
-    "@types/ejs": "^3.1.5",
-    "@types/lodash": "^4.17.24",
-    "@types/node": "^25.6.2",
-    "rimraf": "^6.1.3",
-    "typescript": "^6.0.3"
-  },
-  "dependencies": {
-    "@gi.ts/parser": "^4.0.0-rc.15",
-    "@ts-for-gir/reporter": "^4.0.0-rc.15",
-    "@ts-for-gir/templates": "^4.0.0-rc.15",
-    "colorette": "^2.0.20",
-    "ejs": "^5.0.2",
-    "glob": "^13.0.6",
-    "lodash": "4.18.1"
-  }
-}
+	"name": "@ts-for-gir/lib",
+	"version": "4.0.0-rc.17",
+	"description": "Typescript .d.ts generator from GIR for gjs",
+	"main": "src/index.ts",
+	"module": "src/index.ts",
+	"type": "module",
+	"engines": {
+		"node": ">=18"
+	},
+	"exports": {
+		".": "./src/index.ts"
+	},
+	"scripts": {
+		"check": "tsc --noEmit"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gjsify/ts-for-gir.git"
+	},
+	"author": "Pascal Garber <pascal@mailfreun.de>",
+	"files": [
+		"src"
+	],
+	"license": "Apache-2.0",
+	"bugs": {
+		"url": "https://github.com/gjsify/ts-for-gir/issues"
+	},
+	"homepage": "https://github.com/gjsify/ts-for-gir#readme",
+	"keywords": [
+		"gjs",
+		"typescript",
+		"generate",
+		"gir",
+		"gobject-introspection",
+		"gnome",
+		"gtk",
+		"glib",
+		"gobject",
+		"dts",
+		"type definitions"
+	],
+	"devDependencies": {
+		"@ts-for-gir/tsconfig": "^4.0.0-rc.17",
+		"@types/ejs": "^3.1.5",
+		"@types/lodash": "^4.17.24",
+		"@types/node": "^25.6.2",
+		"rimraf": "^6.1.3",
+		"typescript": "^6.0.3"
+	},
+	"dependencies": {
+		"@gi.ts/parser": "^4.0.0-rc.17",
+		"@ts-for-gir/reporter": "^4.0.0-rc.17",
+		"@ts-for-gir/templates": "^4.0.0-rc.17",
+		"colorette": "^2.0.20",
+		"ejs": "^5.0.2",
+		"glob": "^13.0.6",
+		"lodash": "4.18.1"
+	}
+}

package/src/gir/namespace.ts

@@ -1,4 +1,4 @@
-import { BinaryType, BooleanType, ClosureType, PromiseType, TupleType, TypeIdentifier, VoidType } from "../gir.ts";
+import { BooleanType, ClosureType, makeUnion, PromiseType, TupleType, TypeIdentifier, VoidType } from "../gir.ts";
 
 import type { GirModule } from "../gir-module.ts";
 import type { IntrospectedAlias } from "./alias.ts";
@@ -65,7 +65,7 @@ export function promisifyNamespaceFunctions(namespace: GirModule) {
 						parameters: sync_parameters,
 					}),
 					node.copy({
-						return_type: new BinaryType(async_return, node.return()),
+						return_type: makeUnion(async_return, node.return()),
 					}),
 				]);
 			}

package/src/gir/promisify.ts

@@ -1,4 +1,4 @@
-import { BinaryType, BooleanType, ClosureType, PromiseType, TupleType, TypeIdentifier, VoidType } from "../gir.ts";
+import { BooleanType, ClosureType, makeUnion, PromiseType, TupleType, TypeIdentifier, VoidType } from "../gir.ts";
 import { IntrospectedConstructor } from "./constructor.ts";
 import type { IntrospectedClassFunction } from "./introspected-classes.ts";
 import {
@@ -42,7 +42,7 @@ function generatePromisifyOverloadedSignatures(
 	// Union overload (with optional callback)
 	const unionOverload = node.copy({
 		parameters: [...async_parameters, sync_parameters[sync_parameters.length - 1].copy({ isOptional: true })],
-		returnType: new BinaryType(async_return, VoidType),
+		returnType: makeUnion(async_return, VoidType),
 	});
 
 	return [promiseOverload, callbackOverload, unionOverload];

package/src/gir.ts

@@ -348,9 +348,9 @@ export class NativeType extends TypeExpression {
 export class OrType extends TypeExpression {
 	readonly types: ReadonlyArray<TypeExpression>;
 
-	constructor(type: TypeExpression, ...types: TypeExpression[]) {
+	constructor(...types: TypeExpression[]) {
 		super();
-		this.types = [type, ...types];
+		this.types = [...types];
 	}
 
 	rewrap(type: TypeExpression): TypeExpression {
@@ -362,17 +362,15 @@ export class OrType extends 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)));
+		return makeUnion(...this.types.map((t) => t.resolve(namespace, options)));
 	}
 
 	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
-		return `(${this.types.map((t) => t.print(namespace, options)).join(" | ")})`;
+		return `${this.types.map((t) => t.print(namespace, options)).join(" | ")}`;
 	}
 
 	rootPrint(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
-		return `${this.types.map((t) => t.print(namespace, options)).join(" | ")}`;
+		return this.print(namespace, options);
 	}
 
 	equals(type: TypeExpression) {
@@ -384,6 +382,36 @@ export class OrType extends TypeExpression {
 	}
 }
 
+export function makeUnion(...inputTypes: TypeExpression[]) {
+	const types: Set<TypeExpression> = new Set();
+	for (const type of inputTypes) {
+		if (type instanceof BinaryType) {
+			types.add(type.a);
+			types.add(type.b);
+		} else if (type instanceof OrType && !(type instanceof TupleType)) {
+			for (const t of type.types) {
+				types.add(t);
+			}
+		} else {
+			types.add(type);
+		}
+	}
+	if (types.size === 1) {
+		return [...types][0];
+	}
+	if (types.size === 2) {
+		const typesArray = [...types];
+		if (typesArray[0] === NullType) {
+			return new NullableType(typesArray[1]);
+		}
+		if (typesArray[1] === NullType) {
+			return new NullableType(typesArray[0]);
+		}
+		return new BinaryType(...typesArray);
+	}
+	return new OrType(...types);
+}
+
 export class TupleType extends OrType {
 	print(namespace: IntrospectedNamespace, options: OptionsGeneration): string {
 		return `[${this.types.map((t) => t.print(namespace, options)).join(", ")}]`;
@@ -633,9 +661,10 @@ export class NullableType extends BinaryType {
 }
 
 export function makeNullable(type: TypeExpression) {
+	if (type instanceof NullableType) return type;
 	if (type === RawPointerType) return NullType;
 	if (type === AnyType) return AnyType;
-	return new NullableType(type);
+	return makeUnion(type, NullType);
 }
 
 export class PromiseType extends TypeExpression {
@@ -834,6 +863,8 @@ export class ArrayType extends TypeExpression {
 			typeSuffix = "".padStart(2 * depth, "[]");
 		}
 
+		if (this.type instanceof OrType && !(this.type instanceof TupleType))
+			return `(${this.type.print(namespace, options)})${typeSuffix}`;
 		return `${this.type.print(namespace, options)}${typeSuffix}`;
 	}
 

package/src/injections/shell.ts

@@ -1,6 +1,6 @@
 import type { IntrospectedNamespace } from "../gir/namespace.ts";
 import type { NSRegistry } from "../gir/registry.ts";
-import { NullableType, OrType, TypeIdentifier } from "../gir.ts";
+import { makeUnion, NullType, TypeIdentifier } from "../gir.ts";
 
 const shellTemplate = (version: string) => ({
 	namespace: "Shell",
@@ -24,8 +24,10 @@ const shellTemplate = (version: string) => ({
 		if (addGlslSnippet) {
 			// Create a new parameter with updated type using copy()
 			const updatedParameter = addGlslSnippet.parameters[0].copy({
-				type: new NullableType(
-					new OrType(new TypeIdentifier("SnippetHook", "Shell"), new TypeIdentifier("SnippetHook", "Cogl")),
+				type: makeUnion(
+					new TypeIdentifier("SnippetHook", "Shell"),
+					new TypeIdentifier("SnippetHook", "Cogl"),
+					NullType,
 				),
 			});
 

package/src/utils/types.ts

@@ -7,18 +7,17 @@ import {
 	BigintOrNumberType,
 	BinaryType,
 	BooleanType,
+	makeUnion,
 	NativeType,
 	NeverType,
 	NullableType,
 	NullType,
 	NumberType,
 	ObjectType,
-	OrType,
 	PromiseType,
 	RawPointerType,
 	StringType,
 	ThisType,
-	TupleType,
 	type TypeExpression,
 	TypeIdentifier,
 	Uint8ArrayType,
@@ -231,17 +230,17 @@ export function resolveDirectedType(type: TypeExpression, direction: GirDirectio
 			type.type.equals(Uint8ArrayType) &&
 			type.arrayDepth === 0
 		) {
-			return new BinaryType(type, StringType);
+			return makeUnion(type, StringType);
 		} else {
 			// Rewrap arrays if they have directional types
 			return type.rewrap(resolveDirectedType(type.type, direction) ?? type.type);
 		}
 	} else if (type instanceof TypeIdentifier) {
 		if ((direction === GirDirection.In || direction === GirDirection.Inout) && type.is("GLib", "Bytes")) {
-			return new BinaryType(type, Uint8ArrayType);
+			return makeUnion(type, Uint8ArrayType);
 		} else if (type.is("GObject", "Value")) {
 			if (direction === GirDirection.In || direction === GirDirection.Inout) {
-				return new BinaryType(type, AnyType);
+				return makeUnion(type, AnyType);
 			} else {
 				// GJS converts GObject.Value out parameters to their unboxed type, which we don't know,
 				// so type as `unknown`
@@ -273,12 +272,7 @@ export function resolveDirectedType(type: TypeExpression, direction: GirDirectio
 		// 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));
+		if (a !== type.a || b !== type.b) return makeUnion(a, b);
 	}
 
 	return null;