@gtkx/ffi 0.4.1 → 0.5.0

package/dist/codegen/ffi-generator.d.ts

@@ -70,8 +70,8 @@ export declare class CodeGenerator {
     private collectParentMethodNames;
     private collectAllSignals;
     private generateConstructors;
+    private generateGObjectNewConstructor;
     private generateConstructor;
-    private generateCreatePtr;
     private generateStaticFactoryMethod;
     private generateStaticFunctions;
     private generateStaticFunction;
@@ -107,10 +107,18 @@ export declare class CodeGenerator {
     private generateIndex;
     private generateParameterList;
     private generateCallArguments;
+    private identifyGtkAllocatesRefs;
+    private generateRefRewrapCode;
     private generateErrorArgument;
     private generateErrorCheck;
     private generateTypeDescriptor;
     private generateImports;
     private formatCode;
+    private generateCyclicTypeReturn;
+    /**
+     * Adds a catch-all signal handler overload.
+     * Uses `any` for TypeScript compatibility with typed overloads.
+     */
+    private addSignalCatchAllOverload;
 }
 export {};

package/dist/codegen/ffi-generator.js

@@ -201,12 +201,23 @@ const parseParentReference = (parent, classMap) => {
     }
     return { hasParent: false, isCrossNamespace: false, className: "", extendsClause: "" };
 };
-const hasOutParameter = (params) => params.some((p) => p.direction === "out" || p.direction === "inout");
-const isVararg = (param) => param.name === "..." || param.name === "";
-const cTypeToGetTypeFunc = (cType) => {
-    const snakeCase = cType.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
-    return `${snakeCase}_get_type`;
+const hasRefParameter = (params, typeMapper) => {
+    const savedSameNamespace = typeMapper.getSameNamespaceClassUsageCallback();
+    const savedExternal = typeMapper.getExternalTypeUsageCallback();
+    const savedRecord = typeMapper.getRecordUsageCallback();
+    const savedEnum = typeMapper.getEnumUsageCallback();
+    typeMapper.setSameNamespaceClassUsageCallback(null);
+    typeMapper.setExternalTypeUsageCallback(null);
+    typeMapper.setRecordUsageCallback(null);
+    typeMapper.setEnumUsageCallback(null);
+    const result = params.some((p) => typeMapper.mapParameter(p).ts.startsWith("Ref<"));
+    typeMapper.setSameNamespaceClassUsageCallback(savedSameNamespace);
+    typeMapper.setExternalTypeUsageCallback(savedExternal);
+    typeMapper.setRecordUsageCallback(savedRecord);
+    typeMapper.setEnumUsageCallback(savedEnum);
+    return result;
 };
+const isVararg = (param) => param.name === "..." || param.name === "";
 /**
  * Generates TypeScript FFI bindings from GIR namespace definitions.
  * Creates classes, methods, properties, and signal handlers that call
@@ -385,19 +396,24 @@ export class CodeGenerator {
         const syncMethods = filteredClassMethods.filter((m) => !asyncMethods.has(m.name) && !finishMethods.has(m.name));
         const syncInterfaceMethods = interfaceMethods.filter((m) => !asyncMethods.has(m.name) && !finishMethods.has(m.name));
         this.usesRef =
-            syncMethods.some((m) => hasOutParameter(m.parameters)) ||
-                cls.constructors.some((c) => hasOutParameter(c.parameters)) ||
-                cls.functions.some((f) => hasOutParameter(f.parameters)) ||
-                syncInterfaceMethods.some((m) => hasOutParameter(m.parameters));
-        const hasNonVarargConstructor = cls.constructors.some((c) => !c.parameters.some(isVararg));
-        const needsGObjectNewFallback = !hasNonVarargConstructor && !!cls.parent && !!cls.cType;
+            syncMethods.some((m) => hasRefParameter(m.parameters, this.typeMapper)) ||
+                cls.constructors.some((c) => hasRefParameter(c.parameters, this.typeMapper)) ||
+                cls.functions.some((f) => hasRefParameter(f.parameters, this.typeMapper)) ||
+                syncInterfaceMethods.some((m) => hasRefParameter(m.parameters, this.typeMapper));
+        const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
+        const hasMainConstructorWithParent = mainConstructor && !!cls.parent;
+        const hasGObjectNewConstructor = !mainConstructor && !!cls.parent && !!cls.glibGetType && !cls.abstract;
+        const hasStaticFactoryMethods = cls.constructors.some((c) => c !== mainConstructor) || (cls.constructors.length > 0 && !cls.parent);
+        const { signals: allSignals, hasCrossNamespaceParent } = this.collectAllSignals(cls, classMap);
+        const hasSignalConnect = allSignals.length > 0 || hasCrossNamespaceParent;
         this.usesCall =
             filteredClassMethods.length > 0 ||
-                cls.constructors.length > 0 ||
                 cls.functions.length > 0 ||
-                cls.signals.length > 0 ||
                 interfaceMethods.length > 0 ||
-                needsGObjectNewFallback;
+                hasMainConstructorWithParent ||
+                hasGObjectNewConstructor ||
+                hasStaticFactoryMethods ||
+                hasSignalConnect;
         const className = normalizeClassName(cls.name);
         const parentInfo = parseParentReference(cls.parent, classMap);
         const implementsClause = "";
@@ -418,15 +434,13 @@ export class CodeGenerator {
             sections.push(`  id: unknown;\n`);
         }
         sections.push(this.generateConstructors(cls, sharedLibrary, parentInfo.hasParent));
-        sections.push(this.generateCreatePtr(cls, sharedLibrary, parentInfo.hasParent));
         sections.push(this.generateStaticFunctions(cls.functions, sharedLibrary, className));
         sections.push(this.generateMethods(filteredClassMethods, sharedLibrary, cls.name));
         if (interfaceMethods.length > 0) {
             sections.push(this.generateMethods(interfaceMethods, sharedLibrary, className));
         }
         let signalMetaConstant = "";
-        const { signals: allSignals, hasCrossNamespaceParent } = this.collectAllSignals(cls, classMap);
-        if (allSignals.length > 0 || hasCrossNamespaceParent) {
+        if (hasSignalConnect) {
             const hasConnectMethod = cls.methods.some((m) => toCamelCase(m.name) === "connect");
             const signalConnect = this.generateSignalConnect(sharedLibrary, allSignals, hasConnectMethod, classMap, className);
             signalMetaConstant = signalConnect.moduleLevel;
@@ -585,109 +599,103 @@ export class CodeGenerator {
         }
         return { signals: allSignals, hasCrossNamespaceParent: false };
     }
-    generateConstructors(cls, _sharedLibrary, hasParent) {
+    generateConstructors(cls, sharedLibrary, hasParent) {
         const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
         const sections = [];
-        if (mainConstructor) {
-            sections.push(this.generateConstructor(mainConstructor, hasParent));
+        if (mainConstructor && hasParent) {
+            sections.push(this.generateConstructor(mainConstructor, sharedLibrary));
             for (const ctor of cls.constructors) {
                 if (ctor !== mainConstructor) {
-                    sections.push(this.generateStaticFactoryMethod(ctor, cls.name, _sharedLibrary));
+                    sections.push(this.generateStaticFactoryMethod(ctor, cls.name, sharedLibrary));
                 }
             }
         }
-        else if (cls.constructors.length > 0) {
+        else {
             for (const ctor of cls.constructors) {
-                sections.push(this.generateStaticFactoryMethod(ctor, cls.name, _sharedLibrary));
+                sections.push(this.generateStaticFactoryMethod(ctor, cls.name, sharedLibrary));
             }
-        }
-        if (!mainConstructor) {
-            if (hasParent) {
-                sections.push(`  constructor(...args: unknown[]) {\n    super(...args);\n  }\n`);
+            if (hasParent && cls.glibGetType && !cls.abstract) {
+                sections.push(this.generateGObjectNewConstructor(cls.glibGetType, sharedLibrary));
+            }
+            else if (hasParent) {
+                sections.push(`  constructor() {\n    super();\n  }\n`);
             }
             else {
-                sections.push(`  constructor(...args: unknown[]) {\n    this.id = this.createPtr(args);\n  }\n`);
+                sections.push(`  constructor() {}\n`);
             }
         }
         return sections.join("\n");
     }
-    generateConstructor(ctor, hasParent) {
-        const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
-        const filteredParams = ctor.parameters.filter((p) => !isVararg(p));
-        if (filteredParams.length === 0) {
-            if (hasParent) {
-                return `${ctorDoc}  constructor(...args: unknown[]) {\n    super(...args);\n  }\n`;
-            }
-            return `${ctorDoc}  constructor(...args: unknown[]) {\n    this.id = this.createPtr(args);\n  }\n`;
-        }
-        const typedParams = this.generateParameterList(ctor.parameters, false);
-        if (hasParent) {
-            return `${ctorDoc}  constructor(${typedParams});
-  constructor(...args: unknown[]);
-  constructor(...args: unknown[]) {
-    super(...args);
-  }
-`;
-        }
-        return `${ctorDoc}  constructor(${typedParams});
-  constructor(...args: unknown[]);
-  constructor(...args: unknown[]) {
-    this.id = this.createPtr(args);
-  }
-`;
-    }
-    generateCreatePtr(cls, sharedLibrary, hasParent) {
-        const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
-        if (!mainConstructor) {
-            if (hasParent && cls.cType) {
-                const getTypeFunc = cTypeToGetTypeFunc(cls.cType);
-                const override = hasParent ? "override " : "";
-                return `  protected ${override}createPtr(_args: unknown[]): unknown {
+    generateGObjectNewConstructor(getTypeFunc, sharedLibrary) {
+        return `  constructor() {
+    super();
     const gtype = call(
       "${sharedLibrary}",
       "${getTypeFunc}",
       [],
       { type: "int", size: 64, unsigned: true }
-    ) as number;
-    return call(
+    );
+    this.id = call(
       "libgobject-2.0.so.0",
       "g_object_new",
       [
         { type: { type: "int", size: 64, unsigned: true }, value: gtype },
-        { type: { type: "gobject" }, value: null },
+        { type: { type: "null" }, value: null },
       ],
       { type: "gobject", borrowed: true }
     );
   }
 `;
-            }
-            if (hasParent) {
-                return `  protected override createPtr(_args: unknown[]): unknown {\n    return null;\n  }\n`;
-            }
-            return `  protected createPtr(_args: unknown[]): unknown {\n    return null;\n  }\n`;
+    }
+    generateConstructor(ctor, sharedLibrary) {
+        const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
+        const filteredParams = ctor.parameters.filter((p, i) => !isVararg(p) && !this.typeMapper.isClosureTarget(i, ctor.parameters));
+        const typedParams = this.generateParameterList(ctor.parameters, true);
+        const callArgs = this.generateCallArguments(ctor.parameters);
+        const borrowed = ctor.returnType.transferOwnership !== "full";
+        if (filteredParams.length === 0) {
+            return `${ctorDoc}  constructor() {
+    super();
+    this.id = call(
+      "${sharedLibrary}",
+      "${ctor.cIdentifier}",
+      [],
+      { type: "gobject", borrowed: ${borrowed} }
+    );
+  }
+`;
         }
-        const filteredParams = mainConstructor.parameters.filter((p, i) => !isVararg(p) && !this.typeMapper.isClosureTarget(i, mainConstructor.parameters));
-        const paramTypes = filteredParams.map((p) => this.typeMapper.mapParameter(p).ts);
-        const paramNames = filteredParams.map((p) => toValidIdentifier(toCamelCase(p.name)));
-        const hasParams = paramNames.length > 0;
-        const hasArgsParam = paramNames.includes("args");
-        const arrayParamName = hasArgsParam ? "ctorArgs" : hasParams ? "args" : "_args";
-        const destructuring = hasParams
-            ? `    const [${paramNames.join(", ")}] = ${arrayParamName} as [${paramTypes.join(", ")}];\n`
-            : "";
-        const callArgs = this.generateCallArguments(mainConstructor.parameters);
-        const override = hasParent ? "override " : "";
-        const borrowed = mainConstructor.returnType.transferOwnership !== "full";
-        return `  protected ${override}createPtr(${arrayParamName}: unknown[]): unknown {
-${destructuring}    return call(
+        const firstParam = filteredParams[0];
+        const firstParamName = toValidIdentifier(toCamelCase(firstParam?.name ?? ""));
+        const firstParamNullable = firstParam ? this.typeMapper.isNullable(firstParam) : false;
+        if (firstParamNullable) {
+            return `${ctorDoc}  constructor(${typedParams}) {
+    super();
+    this.id = call(
       "${sharedLibrary}",
-      "${mainConstructor.cIdentifier}",
+      "${ctor.cIdentifier}",
       [
 ${callArgs}
       ],
       { type: "gobject", borrowed: ${borrowed} }
     );
   }
+`;
+        }
+        return `${ctorDoc}  constructor(${typedParams}) {
+    super();
+
+    if (${firstParamName} !== undefined) {
+      this.id = call(
+        "${sharedLibrary}",
+        "${ctor.cIdentifier}",
+        [
+${callArgs}
+        ],
+        { type: "gobject", borrowed: ${borrowed} }
+      );
+    }
+  }
 `;
     }
     generateStaticFactoryMethod(ctor, className, sharedLibrary) {
@@ -735,6 +743,7 @@ ${args}
         const resultVarName = hasResultParam ? "_result" : "result";
         const needsCast = rawReturnType !== "void" && rawReturnType !== "unknown";
         const hasReturnValue = rawReturnType !== "void";
+        const gtkAllocatesRefs = this.identifyGtkAllocatesRefs(func.parameters);
         const lines = [];
         const funcDoc = formatMethodDoc(func.doc, func.parameters);
         if (funcDoc) {
@@ -760,10 +769,13 @@ ${allArgs ? `${allArgs},` : ""}
             if (func.throws) {
                 lines.push(this.generateErrorCheck());
             }
+            lines.push(...this.generateRefRewrapCode(gtkAllocatesRefs));
             lines.push(`    return getObject(ptr) as ${className};`);
         }
         else {
-            const callPrefix = func.throws
+            const hasRefRewrap = gtkAllocatesRefs.length > 0;
+            const needsResultVar = func.throws || hasRefRewrap;
+            const callPrefix = needsResultVar
                 ? hasReturnValue
                     ? `const ${resultVarName} = `
                     : ""
@@ -780,9 +792,10 @@ ${allArgs ? `${allArgs},` : ""}
     )${needsCast ? ` as ${rawReturnType}` : ""};`);
             if (func.throws) {
                 lines.push(this.generateErrorCheck());
-                if (hasReturnValue) {
-                    lines.push(`    return ${resultVarName};`);
-                }
+            }
+            lines.push(...this.generateRefRewrapCode(gtkAllocatesRefs));
+            if (needsResultVar && hasReturnValue) {
+                lines.push(`    return ${resultVarName};`);
             }
         }
         lines.push(`  }`);
@@ -828,12 +841,6 @@ ${allArgs ? `${allArgs},` : ""}
         const finishMethod = this.findFinishMethod(method, allMethods);
         if (!finishMethod)
             return null;
-        let methodName = toCamelCase(method.name);
-        if (className) {
-            const renamed = getRenamedMethod(this.options.namespace, className, methodName);
-            if (renamed)
-                methodName = renamed;
-        }
         const paramsWithoutCallback = method.parameters.filter((p, i) => !isVararg(p) &&
             p.type.name !== "Gio.AsyncReadyCallback" &&
             !this.typeMapper.isClosureTarget(i, method.parameters));
@@ -849,6 +856,12 @@ ${allArgs ? `${allArgs},` : ""}
         if (hasRequiredAfterOptional) {
             return null;
         }
+        let methodName = toCamelCase(method.name);
+        if (className) {
+            const renamed = getRenamedMethod(this.options.namespace, className, methodName);
+            if (renamed)
+                methodName = renamed;
+        }
         const params = paramsWithoutCallback
             .map((p) => {
             const mapped = this.typeMapper.mapParameter(p);
@@ -1072,7 +1085,7 @@ ${allArgs ? `${allArgs},` : ""}
             returnTypeMapping.ffi.itemType?.type === "gobject" &&
             baseReturnType.endsWith("[]");
         const hasReturnValue = returnTypeMapping.ts !== "void";
-        // For records (boxed types), use "boxed" type with innerType; for classes, use "gobject"
+        const gtkAllocatesRefs = this.identifyGtkAllocatesRefs(method.parameters);
         const selfTypeDescriptor = isRecord && className
             ? `{ type: "boxed", borrowed: true, innerType: "${className}", lib: "${sharedLibrary}" }`
             : `{ type: "gobject" }`;
@@ -1105,13 +1118,12 @@ ${allArgs ? `${allArgs},` : ""}
             if (method.throws) {
                 lines.push(this.generateErrorCheck());
             }
+            lines.push(...this.generateRefRewrapCode(gtkAllocatesRefs));
             if (isNullable) {
                 lines.push(`    if (ptr === null) return null;`);
             }
             if (isCyclic) {
-                // For cyclic types, return a minimal NativeObject wrapper. Cast is necessary
-                // because the full type interface isn't available without circular imports.
-                lines.push(`    return { id: ptr } as unknown as ${baseReturnType};`);
+                lines.push(this.generateCyclicTypeReturn(baseReturnType));
             }
             else {
                 this.usesGetObject = true;
@@ -1136,10 +1148,13 @@ ${allArgs ? `${allArgs},` : ""}
             if (method.throws) {
                 lines.push(this.generateErrorCheck());
             }
+            lines.push(...this.generateRefRewrapCode(gtkAllocatesRefs));
             lines.push(`    return ptrs.map(ptr => getObject(ptr) as ${elementType});`);
         }
         else {
-            const callPrefix = method.throws
+            const hasRefRewrap = gtkAllocatesRefs.length > 0;
+            const needsResultVar = method.throws || hasRefRewrap;
+            const callPrefix = needsResultVar
                 ? hasReturnValue
                     ? `const ${resultVarName} = `
                     : ""
@@ -1161,9 +1176,10 @@ ${allArgs ? `${allArgs},` : ""}
     )${needsCast ? ` as ${tsReturnType}` : ""};`);
             if (method.throws) {
                 lines.push(this.generateErrorCheck());
-                if (hasReturnValue) {
-                    lines.push(`    return ${resultVarName};`);
-                }
+            }
+            lines.push(...this.generateRefRewrapCode(gtkAllocatesRefs));
+            if (needsResultVar && hasReturnValue) {
+                lines.push(`    return ${resultVarName};`);
             }
         }
         lines.push(`  }`);
@@ -1263,9 +1279,7 @@ ${allArgs ? `${allArgs},` : ""}
                 kind: "class",
             });
         }
-        // Signal handler catch-all overload must use `any` for compatibility with typed overloads.
-        // The typed overloads have specific return types, and unknown is not assignable to them.
-        signalOverloads.push(`  ${methodName}(signal: string, handler: (...args: any[]) => any, after?: boolean): number;`);
+        this.addSignalCatchAllOverload(signalOverloads, methodName);
         this.usesType = true;
         this.usesGetObject = true;
         if (signalMetadata.length > 0) {
@@ -1323,7 +1337,7 @@ ${allArgs ? `${allArgs},` : ""}
         const interfaceName = toPascalCase(iface.name);
         const sections = [];
         this.usesCall = iface.methods.length > 0;
-        this.usesRef = iface.methods.some((m) => hasOutParameter(m.parameters));
+        this.usesRef = iface.methods.some((m) => hasRefParameter(m.parameters, this.typeMapper));
         if (iface.doc) {
             sections.push(formatDoc(iface.doc));
         }
@@ -1350,9 +1364,9 @@ ${allArgs ? `${allArgs},` : ""}
     async generateRecord(record, sharedLibrary) {
         this.resetState();
         this.usesRef =
-            record.methods.some((m) => hasOutParameter(m.parameters)) ||
-                record.constructors.some((c) => hasOutParameter(c.parameters)) ||
-                record.functions.some((f) => hasOutParameter(f.parameters));
+            record.methods.some((m) => hasRefParameter(m.parameters, this.typeMapper)) ||
+                record.constructors.some((c) => hasRefParameter(c.parameters, this.typeMapper)) ||
+                record.functions.some((f) => hasRefParameter(f.parameters, this.typeMapper));
         this.usesCall = record.methods.length > 0 || record.constructors.length > 0 || record.functions.length > 0;
         const hasReadableFields = record.fields.some((f) => f.readable !== false && !f.private);
         if (hasReadableFields) {
@@ -1671,7 +1685,7 @@ ${args}
     }
     async generateFunctions(functions, sharedLibrary) {
         this.resetState();
-        this.usesRef = functions.some((f) => hasOutParameter(f.parameters));
+        this.usesRef = functions.some((f) => hasRefParameter(f.parameters, this.typeMapper));
         this.usesCall = functions.length > 0;
         const sections = [];
         for (const func of functions) {
@@ -1694,6 +1708,7 @@ ${args}
             returnTypeMapping.ts !== "unknown" &&
             returnTypeMapping.kind !== "interface";
         const hasReturnValue = returnTypeMapping.ts !== "void";
+        const gtkAllocatesRefs = this.identifyGtkAllocatesRefs(func.parameters);
         const lines = [];
         const funcDoc = formatMethodDoc(func.doc, func.parameters, "");
         if (funcDoc) {
@@ -1706,6 +1721,7 @@ ${args}
         const args = this.generateCallArguments(func.parameters, "  ");
         const errorArg = func.throws ? this.generateErrorArgument("  ") : "";
         const allArgs = errorArg ? args + (args ? ",\n" : "") + errorArg : args;
+        const refRewrapCode = this.generateRefRewrapCode(gtkAllocatesRefs).map((line) => line.replace(/^ {4}/, "  "));
         if (needsObjectWrap && hasReturnValue) {
             this.usesGetObject = true;
             lines.push(`  const ptr = call("${sharedLibrary}", "${func.cIdentifier}", [
@@ -1714,13 +1730,16 @@ ${allArgs ? `${allArgs},` : ""}
             if (func.throws) {
                 lines.push(this.generateErrorCheck(""));
             }
+            lines.push(...refRewrapCode);
             if (isNullable) {
                 lines.push(`  if (ptr === null) return null;`);
             }
             lines.push(`  return getObject(ptr) as ${baseReturnType};`);
         }
         else {
-            const callPrefix = func.throws
+            const hasRefRewrap = gtkAllocatesRefs.length > 0;
+            const needsResultVar = func.throws || hasRefRewrap;
+            const callPrefix = needsResultVar
                 ? hasReturnValue
                     ? `const ${resultVarName} = `
                     : ""
@@ -1733,9 +1752,10 @@ ${allArgs ? `${allArgs},` : ""}
   ], ${this.generateTypeDescriptor(returnTypeMapping.ffi)})${needsCast ? ` as ${returnTypeMapping.ts}` : ""};`);
             if (func.throws) {
                 lines.push(this.generateErrorCheck(""));
-                if (hasReturnValue) {
-                    lines.push(`  return ${resultVarName};`);
-                }
+            }
+            lines.push(...refRewrapCode);
+            if (needsResultVar && hasReturnValue) {
+                lines.push(`  return ${resultVarName};`);
             }
         }
         lines.push(`};`);
@@ -1790,6 +1810,34 @@ ${allArgs ? `${allArgs},` : ""}
         })
             .join(",\n");
     }
+    identifyGtkAllocatesRefs(parameters) {
+        return parameters
+            .filter((p, i) => !isVararg(p) && !this.typeMapper.isClosureTarget(i, parameters))
+            .map((param) => {
+            const mapped = this.typeMapper.mapParameter(param);
+            if (mapped.ffi.type === "ref" &&
+                typeof mapped.ffi.innerType === "object" &&
+                (mapped.ffi.innerType.type === "boxed" || mapped.ffi.innerType.type === "gobject")) {
+                const innerTsType = mapped.ts.slice(4, -1);
+                return {
+                    paramName: toValidIdentifier(toCamelCase(param.name)),
+                    innerType: innerTsType,
+                    nullable: this.typeMapper.isNullable(param),
+                };
+            }
+            return null;
+        })
+            .filter((x) => x !== null);
+    }
+    generateRefRewrapCode(gtkAllocatesRefs) {
+        if (gtkAllocatesRefs.length === 0) {
+            return [];
+        }
+        this.usesGetObject = true;
+        return gtkAllocatesRefs.map((ref) => ref.nullable
+            ? `    if (${ref.paramName}) ${ref.paramName}.value = getObject(${ref.paramName}.value) as ${ref.innerType};`
+            : `    ${ref.paramName}.value = getObject(${ref.paramName}.value) as ${ref.innerType};`);
+    }
     generateErrorArgument(indent = "      ") {
         return `${indent}  {\n${indent}    type: { type: "ref", innerType: { type: "boxed", innerType: "GError", lib: "libglib-2.0.so.0" } },\n${indent}    value: error,\n${indent}  }`;
     }
@@ -1952,4 +2000,14 @@ ${indent}  }`;
             return code;
         }
     }
+    generateCyclicTypeReturn(baseReturnType) {
+        return `    return { id: ptr } as unknown as ${baseReturnType};`;
+    }
+    /**
+     * Adds a catch-all signal handler overload.
+     * Uses `any` for TypeScript compatibility with typed overloads.
+     */
+    addSignalCatchAllOverload(signalOverloads, methodName) {
+        signalOverloads.push(`  ${methodName}(signal: string, handler: (...args: any[]) => any, after?: boolean): number;`);
+    }
 }

package/dist/generated/gdk/app-launch-context.d.ts

@@ -24,8 +24,7 @@ import * as Gio from "../gio/index.js";
  */
 export declare class AppLaunchContext extends Gio.AppLaunchContext {
     static readonly glibTypeName: string;
-    constructor(...args: unknown[]);
-    protected createPtr(_args: unknown[]): unknown;
+    constructor();
     /**
      * Gets the `GdkDisplay` that `context` is for.
      */

package/dist/generated/gdk/app-launch-context.js

@@ -23,18 +23,16 @@ import * as Gio from "../gio/index.js";
  */
 export class AppLaunchContext extends Gio.AppLaunchContext {
     static glibTypeName = "GdkAppLaunchContext";
-    constructor(...args) {
-        super(...args);
-    }
-    createPtr(_args) {
+    constructor() {
+        super();
         const gtype = call("libgtk-4.so.1", "gdk_app_launch_context_get_type", [], {
             type: "int",
             size: 64,
             unsigned: true,
         });
-        return call("libgobject-2.0.so.0", "g_object_new", [
+        this.id = call("libgobject-2.0.so.0", "g_object_new", [
             { type: { type: "int", size: 64, unsigned: true }, value: gtype },
-            { type: { type: "gobject" }, value: null },
+            { type: { type: "null" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
     /**

package/dist/generated/gdk/button-event.d.ts

@@ -2,8 +2,7 @@ import { Event } from "./event.js";
 /** An event related to a button on a pointer device. */
 export declare class ButtonEvent extends Event {
     static readonly glibTypeName: string;
-    constructor(...args: unknown[]);
-    protected createPtr(_args: unknown[]): unknown;
+    constructor();
     /**
      * Extract the button number from a button event.
      */

package/dist/generated/gdk/button-event.js

@@ -3,18 +3,16 @@ import { Event } from "./event.js";
 /** An event related to a button on a pointer device. */
 export class ButtonEvent extends Event {
     static glibTypeName = "GdkButtonEvent";
-    constructor(...args) {
-        super(...args);
-    }
-    createPtr(_args) {
+    constructor() {
+        super();
         const gtype = call("libgtk-4.so.1", "gdk_button_event_get_type", [], {
             type: "int",
             size: 64,
             unsigned: true,
         });
-        return call("libgobject-2.0.so.0", "g_object_new", [
+        this.id = call("libgobject-2.0.so.0", "g_object_new", [
             { type: { type: "int", size: 64, unsigned: true }, value: gtype },
-            { type: { type: "gobject" }, value: null },
+            { type: { type: "null" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
     /**

package/dist/generated/gdk/cairo-context.d.ts

@@ -10,8 +10,7 @@ import { DrawContext } from "./draw-context.js";
  */
 export declare class CairoContext extends DrawContext {
     static readonly glibTypeName: string;
-    constructor(...args: unknown[]);
-    protected createPtr(_args: unknown[]): unknown;
+    constructor();
     /**
      * Retrieves a Cairo context to be used to draw on the `GdkSurface`
      * of @context.

package/dist/generated/gdk/cairo-context.js

@@ -9,19 +9,8 @@ import { DrawContext } from "./draw-context.js";
  */
 export class CairoContext extends DrawContext {
     static glibTypeName = "GdkCairoContext";
-    constructor(...args) {
-        super(...args);
-    }
-    createPtr(_args) {
-        const gtype = call("libgtk-4.so.1", "gdk_cairo_context_get_type", [], {
-            type: "int",
-            size: 64,
-            unsigned: true,
-        });
-        return call("libgobject-2.0.so.0", "g_object_new", [
-            { type: { type: "int", size: 64, unsigned: true }, value: gtype },
-            { type: { type: "gobject" }, value: null },
-        ], { type: "gobject", borrowed: true });
+    constructor() {
+        super();
     }
     /**
      * Retrieves a Cairo context to be used to draw on the `GdkSurface`

package/dist/generated/gdk/cicp-params.d.ts

@@ -30,8 +30,7 @@ export declare class CicpParams extends GObject.GObject {
      * The initial values of the properties are the values for "undefined"
      * and need to be set before a color state object can be built.
      */
-    constructor(...args: unknown[]);
-    protected createPtr(_args: unknown[]): unknown;
+    constructor();
     /**
      * Creates a new `GdkColorState` object for the cicp parameters in @self.
      *

package/dist/generated/gdk/cicp-params.js

@@ -29,11 +29,9 @@ export class CicpParams extends GObject.GObject {
      * The initial values of the properties are the values for "undefined"
      * and need to be set before a color state object can be built.
      */
-    constructor(...args) {
-        super(...args);
-    }
-    createPtr(_args) {
-        return call("libgtk-4.so.1", "gdk_cicp_params_new", [], {
+    constructor() {
+        super();
+        this.id = call("libgtk-4.so.1", "gdk_cicp_params_new", [], {
             type: "gobject",
             borrowed: false,
         });