@gtkx/ffi 0.1.11 → 0.1.14

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

@@ -17,6 +17,7 @@ export declare class CodeGenerator {
     private usesAlloc;
     private usesNativeError;
     private usesWrapPtr;
+    private usesSignalMeta;
     private usedEnums;
     private usedRecords;
     private usedExternalTypes;
@@ -46,6 +47,7 @@ export declare class CodeGenerator {
     private getAncestors;
     private classImports;
     private collectParentMethodNames;
+    private collectAllSignals;
     private generateConstructors;
     private generateConstructor;
     private generateCreatePtr;

package/dist/codegen/ffi-generator.js

@@ -81,8 +81,23 @@ const METHOD_RENAMES = new Map([
         ]),
     ],
     ["PrintUnixDialog", new Map([["getSettings", "getPrintSettings"]])],
+    ["Gdk.AppLaunchContext", new Map([["getDisplay", "getGdkDisplay"]])],
+    ["SocketClient", new Map([["connect", "connectTo"]])],
+    ["SocketConnection", new Map([["connect", "connectTo"]])],
+    ["Socket", new Map([["connect", "connectTo"]])],
+    ["Cancellable", new Map([["connect", "connectCallback"]])],
+    ["GutterRenderer", new Map([["activate", "activateRenderer"]])],
+    ["GutterRendererText", new Map([["measure", "measureText"]])],
 ]);
 const CLASS_RENAMES = new Map([["Error", "GError"]]);
+const getRenamedMethod = (namespace, className, methodName) => {
+    const nsRenames = METHOD_RENAMES.get(`${namespace}.${className}`);
+    if (nsRenames?.has(methodName)) {
+        return nsRenames.get(methodName);
+    }
+    const classRenames = METHOD_RENAMES.get(className);
+    return classRenames?.get(methodName);
+};
 const toKebabCase = (str) => str
     .replace(/([a-z])([A-Z])/g, "$1-$2")
     .replace(/_/g, "-")
@@ -155,8 +170,43 @@ const normalizeClassName = (name) => {
     }
     return pascalName;
 };
+const parseParentReference = (parent, classMap) => {
+    if (!parent) {
+        return { hasParent: false, isCrossNamespace: false, className: "", extendsClause: "" };
+    }
+    if (parent.includes(".")) {
+        const [ns, className] = parent.split(".", 2);
+        if (ns && className) {
+            const normalizedClass = normalizeClassName(className);
+            const nsLower = ns.toLowerCase();
+            return {
+                hasParent: true,
+                isCrossNamespace: true,
+                namespace: ns,
+                className: normalizedClass,
+                importStatement: `import * as ${ns} from "../${nsLower}/index.js";`,
+                extendsClause: ` extends ${ns}.${normalizedClass}`,
+            };
+        }
+    }
+    if (classMap.has(parent)) {
+        const normalizedClass = normalizeClassName(parent);
+        return {
+            hasParent: true,
+            isCrossNamespace: false,
+            className: normalizedClass,
+            importStatement: `import { ${normalizedClass} } from "./${toKebabCase(parent)}.js";`,
+            extendsClause: ` extends ${normalizedClass}`,
+        };
+    }
+    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`;
+};
 export class CodeGenerator {
     options;
     typeMapper;
@@ -169,6 +219,7 @@ export class CodeGenerator {
     usesAlloc = false;
     usesNativeError = false;
     usesWrapPtr = false;
+    usesSignalMeta = false;
     usedEnums = new Set();
     usedRecords = new Set();
     usedExternalTypes = new Map();
@@ -310,6 +361,7 @@ export class CodeGenerator {
         this.usesAlloc = false;
         this.usesNativeError = false;
         this.usesWrapPtr = false;
+        this.usesSignalMeta = false;
         this.usedEnums.clear();
         this.usedRecords.clear();
         this.usedExternalTypes.clear();
@@ -351,42 +403,53 @@ export class CodeGenerator {
                 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;
         this.usesCall =
             filteredClassMethods.length > 0 ||
                 cls.constructors.length > 0 ||
                 cls.functions.length > 0 ||
                 cls.signals.length > 0 ||
-                interfaceMethods.length > 0;
+                interfaceMethods.length > 0 ||
+                needsGObjectNewFallback;
         const className = normalizeClassName(cls.name);
-        const hasParent = !!(cls.parent && classMap.has(cls.parent));
-        const parentClassName = cls.parent ? normalizeClassName(cls.parent) : "";
-        const extendsClause = hasParent ? ` extends ${parentClassName}` : "";
+        const parentInfo = parseParentReference(cls.parent, classMap);
         const implementsClause = "";
         const sections = [];
-        if (hasParent && cls.parent) {
-            sections.push(`import { ${parentClassName} } from "./${toKebabCase(cls.parent)}.js";`);
+        if (parentInfo.importStatement && !parentInfo.isCrossNamespace) {
+            sections.push(parentInfo.importStatement);
         }
         sections.push("");
         if (cls.doc) {
             sections.push(formatDoc(cls.doc));
         }
-        sections.push(`export class ${className}${extendsClause}${implementsClause} {`);
-        if (!extendsClause) {
+        sections.push(`export class ${className}${parentInfo.extendsClause}${implementsClause} {`);
+        if (!parentInfo.hasParent) {
             sections.push(`  ptr: unknown;\n`);
         }
-        sections.push(this.generateConstructors(cls, sharedLibrary, hasParent));
-        sections.push(this.generateCreatePtr(cls, sharedLibrary, hasParent));
+        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));
         }
-        if (cls.signals.length > 0) {
+        let signalMetaConstant = "";
+        const { signals: allSignals, hasCrossNamespaceParent } = this.collectAllSignals(cls, classMap);
+        if (allSignals.length > 0 && !hasCrossNamespaceParent) {
             const hasConnectMethod = cls.methods.some((m) => toCamelCase(m.name) === "connect");
-            sections.push(this.generateSignalConnect(sharedLibrary, cls.signals, hasConnectMethod, classMap));
+            const signalConnect = this.generateSignalConnect(sharedLibrary, allSignals, hasConnectMethod, classMap, className);
+            signalMetaConstant = signalConnect.moduleLevel;
+            sections.push(signalConnect.method);
         }
         sections.push("}");
-        const imports = this.generateImports(className, hasParent ? parentClassName : undefined);
+        if (signalMetaConstant) {
+            const classDefIndex = sections.findIndex((s) => s.startsWith("export class "));
+            if (classDefIndex !== -1) {
+                sections.splice(classDefIndex, 0, signalMetaConstant);
+            }
+        }
+        const imports = this.generateImports(className, parentInfo.hasParent && !parentInfo.isCrossNamespace ? parentInfo.className : undefined, parentInfo.isCrossNamespace ? parentInfo.namespace : undefined);
         return this.formatCode(imports + sections.join("\n"));
     }
     topologicalSortClasses(classes, classMap) {
@@ -507,6 +570,30 @@ export class CodeGenerator {
         }
         return names;
     }
+    collectAllSignals(cls, classMap) {
+        const allSignals = [...cls.signals];
+        const seenNames = new Set(cls.signals.map((s) => s.name));
+        if (cls.parent?.includes(".")) {
+            return { signals: allSignals, hasCrossNamespaceParent: true };
+        }
+        let current = cls.parent ? classMap.get(cls.parent) : undefined;
+        while (current) {
+            if (current.signals.length > 0 && current.parent?.includes(".")) {
+                return { signals: allSignals, hasCrossNamespaceParent: true };
+            }
+            for (const signal of current.signals) {
+                if (!seenNames.has(signal.name)) {
+                    allSignals.push(signal);
+                    seenNames.add(signal.name);
+                }
+            }
+            if (current.parent?.includes(".")) {
+                break;
+            }
+            current = current.parent ? classMap.get(current.parent) : undefined;
+        }
+        return { signals: allSignals, hasCrossNamespaceParent: false };
+    }
     generateConstructors(cls, _sharedLibrary, hasParent) {
         const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
         const sections = [];
@@ -561,6 +648,28 @@ export class CodeGenerator {
     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 {
+    const gtype = call(
+      "${sharedLibrary}",
+      "${getTypeFunc}",
+      [],
+      { type: "int", size: 64, unsigned: true }
+    ) as number;
+    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 }
+    );
+  }
+`;
+            }
             if (hasParent) {
                 return `  protected override createPtr(_args: unknown[]): unknown {\n    return null;\n  }\n`;
             }
@@ -577,6 +686,7 @@ export class CodeGenerator {
             : "";
         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(
       "${sharedLibrary}",
@@ -584,7 +694,7 @@ ${destructuring}    return call(
       [
 ${callArgs}
       ],
-      { type: "gobject", borrowed: true }
+      { type: "gobject", borrowed: ${borrowed} }
     );
   }
 `;
@@ -601,6 +711,7 @@ ${callArgs}
         const params = this.generateParameterList(ctor.parameters);
         const args = this.generateCallArguments(ctor.parameters);
         const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
+        const borrowed = ctor.returnType.transferOwnership !== "full";
         this.usesWrapPtr = true;
         return `${ctorDoc}  static ${methodName}(${params}): ${className} {
     const ptr = call(
@@ -609,7 +720,7 @@ ${callArgs}
       [
 ${args}
       ],
-      { type: "gobject", borrowed: true }
+      { type: "gobject", borrowed: ${borrowed} }
     );
     return wrapPtr(ptr, ${className});
   }
@@ -728,8 +839,7 @@ ${allArgs ? `${allArgs},` : ""}
             return null;
         let methodName = toCamelCase(method.name);
         if (className) {
-            const renames = METHOD_RENAMES.get(className);
-            const renamed = renames?.get(methodName);
+            const renamed = getRenamedMethod(this.options.namespace, className, methodName);
             if (renamed)
                 methodName = renamed;
         }
@@ -761,8 +871,9 @@ ${allArgs ? `${allArgs},` : ""}
         const returnTypeMapping = this.typeMapper.mapType(finishMethod.returnType, true);
         const mainReturnType = returnTypeMapping.ts;
         const hasMainReturn = mainReturnType !== "void";
+        const isNullable = finishMethod.returnType.nullable === true;
         this.addGioImport = true;
-        const promiseType = this.buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams);
+        const promiseType = this.buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams, isNullable);
         const lines = [];
         lines.push(`  /**`);
         lines.push(`   * Promise-based version of ${methodName}.`);
@@ -775,19 +886,22 @@ ${allArgs ? `${allArgs},` : ""}
         lines.push(`   */`);
         lines.push(`  ${methodName}(${params}): Promise<${promiseType}> {`);
         lines.push(`    return new Promise((resolve, reject) => {`);
-        const callArgs = this.buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary);
+        const callArgs = this.buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary, isNullable);
         lines.push(callArgs);
         lines.push(`    });`);
         lines.push(`  }`);
         return `${lines.join("\n")}\n`;
     }
-    buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams) {
+    buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams, isNullable = false) {
         if (outputParams.length === 0) {
-            return hasMainReturn ? mainReturnType : "void";
+            if (!hasMainReturn)
+                return "void";
+            return isNullable ? `${mainReturnType} | null` : mainReturnType;
         }
         const outputTypes = [];
         if (hasMainReturn) {
-            outputTypes.push(`result: ${mainReturnType}`);
+            const returnType = isNullable ? `${mainReturnType} | null` : mainReturnType;
+            outputTypes.push(`result: ${returnType}`);
         }
         for (const param of outputParams) {
             const paramName = toValidIdentifier(toCamelCase(param.name));
@@ -800,7 +914,7 @@ ${allArgs ? `${allArgs},` : ""}
         }
         return `{ ${outputTypes.join("; ")} }`;
     }
-    buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary) {
+    buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary, isNullable = false) {
         const returnTypeMapping = this.typeMapper.mapType(finishMethod.returnType, true);
         const hasMainReturn = returnTypeMapping.ts !== "void";
         const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
@@ -866,7 +980,9 @@ ${allArgs ? `${allArgs},` : ""}
             if (hasMainReturn) {
                 if (needsObjectWrap) {
                     this.usesWrapPtr = true;
-                    lines.push(`          if (ptr === null) { resolve(null as unknown as ${finishReturnType.ts}); return; }`);
+                    if (isNullable) {
+                        lines.push(`          if (ptr === null) { resolve(null); return; }`);
+                    }
                     lines.push(`          resolve(wrapPtr(ptr, ${finishReturnType.ts}));`);
                 }
                 else {
@@ -882,7 +998,12 @@ ${allArgs ? `${allArgs},` : ""}
             if (hasMainReturn) {
                 if (needsObjectWrap) {
                     this.usesWrapPtr = true;
-                    lines.push(`          const result = (ptr === null ? null : wrapPtr(ptr, ${finishReturnType.ts})) as ${finishReturnType.ts};`);
+                    if (isNullable) {
+                        lines.push(`          const result = (ptr === null ? null : wrapPtr(ptr, ${finishReturnType.ts})) as ${finishReturnType.ts} | null;`);
+                    }
+                    else {
+                        lines.push(`          const result = wrapPtr(ptr, ${finishReturnType.ts});`);
+                    }
                 }
                 resolveFields.push("result");
             }
@@ -910,7 +1031,7 @@ ${allArgs ? `${allArgs},` : ""}
             lines.push(`${asyncCallArgs},`);
         }
         lines.push(`          {`);
-        lines.push(`            type: { type: "asyncCallback", sourceType: { type: "gobject", borrowed: true }, resultType: { type: "gobject", borrowed: true } },`);
+        lines.push(`            type: { type: "callback", trampoline: "asyncReady", sourceType: { type: "gobject", borrowed: true }, resultType: { type: "gobject", borrowed: true } },`);
         lines.push(`            value: callback,`);
         lines.push(`          },`);
         lines.push(`        ],`);
@@ -940,20 +1061,21 @@ ${allArgs ? `${allArgs},` : ""}
     generateMethod(method, sharedLibrary, className) {
         let methodName = toCamelCase(method.name);
         if (className) {
-            const renames = METHOD_RENAMES.get(className);
-            const renamed = renames?.get(methodName);
+            const renamed = getRenamedMethod(this.options.namespace, className, methodName);
             if (renamed) {
                 methodName = renamed;
             }
         }
         const params = this.generateParameterList(method.parameters);
         const returnTypeMapping = this.typeMapper.mapType(method.returnType, true);
-        const tsReturnType = returnTypeMapping.ts === "void" ? "void" : returnTypeMapping.ts;
+        const isNullable = method.returnType.nullable === true;
+        const baseReturnType = returnTypeMapping.ts === "void" ? "void" : returnTypeMapping.ts;
+        const tsReturnType = isNullable && baseReturnType !== "void" ? `${baseReturnType} | null` : baseReturnType;
         const returnTypeAnnotation = tsReturnType !== "void" ? `: ${tsReturnType}` : "";
         const hasResultParam = method.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
         const resultVarName = hasResultParam ? "_result" : "result";
         const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
-            tsReturnType !== "unknown" &&
+            baseReturnType !== "unknown" &&
             returnTypeMapping.kind !== "interface";
         const hasReturnValue = returnTypeMapping.ts !== "void";
         const lines = [];
@@ -985,13 +1107,15 @@ ${allArgs ? `${allArgs},` : ""}
             if (method.throws) {
                 lines.push(this.generateErrorCheck());
             }
-            lines.push(`    if (ptr === null) return null as unknown as ${tsReturnType};`);
+            if (isNullable) {
+                lines.push(`    if (ptr === null) return null;`);
+            }
             if (isCyclic) {
-                lines.push(`    return { ptr } as unknown as ${tsReturnType};`);
+                lines.push(`    return { ptr } as unknown as ${baseReturnType};`);
             }
             else {
                 this.usesWrapPtr = true;
-                lines.push(`    return wrapPtr(ptr, ${tsReturnType});`);
+                lines.push(`    return wrapPtr(ptr, ${baseReturnType});`);
             }
         }
         else {
@@ -1042,7 +1166,7 @@ ${allArgs ? `${allArgs},` : ""}
         }
         return undefined;
     }
-    generateSignalConnect(sharedLibrary, signals, hasConnectMethod, classMap) {
+    generateSignalConnect(sharedLibrary, signals, hasConnectMethod, classMap, className) {
         const methodName = hasConnectMethod ? "on" : "connect";
         const savedEnumCallback = this.typeMapper.getEnumUsageCallback();
         const savedRecordCallback = this.typeMapper.getRecordUsageCallback();
@@ -1053,10 +1177,10 @@ ${allArgs ? `${allArgs},` : ""}
         const signalMetadata = signals.map((signal) => {
             const paramEntries = (signal.parameters ?? []).map((param) => {
                 const ffiType = JSON.stringify(this.typeMapper.mapType(param.type).ffi);
-                const className = this.extractSignalParamClass(param, classMap);
-                if (className) {
-                    this.signalClasses.add(className);
-                    return `{ type: ${ffiType}, cls: ${className} }`;
+                const signalParamClass = this.extractSignalParamClass(param, classMap);
+                if (signalParamClass) {
+                    this.signalClasses.add(signalParamClass);
+                    return `{ type: ${ffiType}, cls: ${signalParamClass} }`;
                 }
                 return `{ type: ${ffiType} }`;
             });
@@ -1068,33 +1192,61 @@ ${allArgs ? `${allArgs},` : ""}
             const key = `${usage.namespace}.${usage.transformedName}`;
             this.usedExternalTypes.set(key, usage);
         });
-        this.typeMapper.setSameNamespaceClassUsageCallback((className, originalName) => {
-            this.usedSameNamespaceClasses.set(className, originalName);
+        this.typeMapper.setSameNamespaceClassUsageCallback((clsName, originalName) => {
+            this.usedSameNamespaceClasses.set(clsName, originalName);
         });
+        const signalOverloads = signals.map((signal) => {
+            const signalParams = signal.parameters ?? [];
+            const handlerParams = [`self: ${className}`];
+            for (const param of signalParams) {
+                const paramName = toValidIdentifier(toCamelCase(param.name));
+                const signalParamClass = this.extractSignalParamClass(param, classMap);
+                const paramType = signalParamClass ?? this.typeMapper.mapType(param.type).ts;
+                handlerParams.push(`${paramName}: ${paramType}`);
+            }
+            const returnType = signal.returnType ? this.typeMapper.mapType(signal.returnType).ts : "void";
+            return `  ${methodName}(signal: "${signal.name}", handler: (${handlerParams.join(", ")}) => ${returnType}, after?: boolean): number;`;
+        });
+        const hasNotifySignal = signals.some((s) => s.name === "notify");
+        if (!hasNotifySignal && this.options.namespace !== "GObject") {
+            signalOverloads.push(`  ${methodName}(signal: "notify", handler: (self: ${className}, pspec: GObject.ParamSpec) => void, after?: boolean): number;`);
+            this.usedExternalTypes.set("GObject.ParamSpec", {
+                namespace: "GObject",
+                name: "ParamSpec",
+                transformedName: "ParamSpec",
+                kind: "class",
+            });
+        }
+        signalOverloads.push(`  ${methodName}(signal: string, handler: (...args: any[]) => any, after?: boolean): number;`);
         this.usesType = true;
         if (signalMetadata.length > 0) {
             this.usesWrapPtr = true;
+            this.usesSignalMeta = true;
         }
+        const moduleLevel = signalMetadata.length > 0
+            ? `const SIGNAL_META: SignalMeta = {\n${signalMetadata.join(",\n")}\n};\n`
+            : "";
         const signalMapCode = signalMetadata.length > 0
-            ? `const signalMeta: Record<string, { type: Type; cls?: { prototype: object } }[]> = {\n${signalMetadata.join(",\n")}\n  };
-    const meta = signalMeta[signal];
-    const selfType: Type = { type: "gobject", borrowed: false };
+            ? `const meta = SIGNAL_META[signal];
+    const selfType: Type = { type: "gobject", borrowed: true };
     const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];`
-            : `const meta = undefined;\n    const selfType: Type = { type: "gobject", borrowed: false };\n    const argTypes = [selfType];`;
+            : `const meta = undefined;\n    const selfType: Type = { type: "gobject", borrowed: true };\n    const argTypes = [selfType];`;
         const wrapperCode = `const wrappedHandler = (...args: unknown[]) => {
+      const self = wrapPtr(args[0], ${className});
       const signalArgs = args.slice(1);
-      if (!meta) return handler(...signalArgs);
+      if (!meta) return handler(self, ...signalArgs);
       const wrapped = meta.map((m, i) => {
         if (m.cls && signalArgs[i] != null) {
           return wrapPtr(signalArgs[i], m.cls);
         }
         return signalArgs[i];
       });
-      return handler(...wrapped);
+      return handler(self, ...wrapped);
     };`;
-        return `  ${methodName}(
+        const overloadsSection = signalOverloads.length > 0 ? `${signalOverloads.join("\n")}\n` : "";
+        const method = `${overloadsSection}  ${methodName}(
     signal: string,
-    handler: (...args: unknown[]) => unknown,
+    handler: (...args: any[]) => any,
     after = false
   ): number {
     ${signalMapCode}
@@ -1112,6 +1264,7 @@ ${allArgs ? `${allArgs},` : ""}
     ) as number;
   }
 `;
+        return { moduleLevel, method };
     }
     async generateInterface(iface, sharedLibrary, _classMap) {
         this.resetState();
@@ -1471,7 +1624,10 @@ ${args}
         const funcName = toValidIdentifier(toCamelCase(func.name));
         const params = this.generateParameterList(func.parameters);
         const returnTypeMapping = this.typeMapper.mapType(func.returnType, true);
-        const tsReturnType = returnTypeMapping.ts === "void" ? "" : `: ${returnTypeMapping.ts}`;
+        const isNullable = func.returnType.nullable === true;
+        const baseReturnType = returnTypeMapping.ts;
+        const fullReturnType = isNullable && baseReturnType !== "void" ? `${baseReturnType} | null` : baseReturnType;
+        const tsReturnType = fullReturnType === "void" ? "" : `: ${fullReturnType}`;
         const hasResultParam = func.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
         const resultVarName = hasResultParam ? "_result" : "result";
         const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
@@ -1498,8 +1654,10 @@ ${allArgs ? `${allArgs},` : ""}
             if (func.throws) {
                 lines.push(this.generateErrorCheck(""));
             }
-            lines.push(`  if (ptr === null) return null as unknown as ${returnTypeMapping.ts};`);
-            lines.push(`  return wrapPtr(ptr, ${returnTypeMapping.ts});`);
+            if (isNullable) {
+                lines.push(`  if (ptr === null) return null;`);
+            }
+            lines.push(`  return wrapPtr(ptr, ${baseReturnType});`);
         }
         else {
             const callPrefix = func.throws
@@ -1552,7 +1710,8 @@ ${allArgs ? `${allArgs},` : ""}
             const mapped = this.typeMapper.mapParameter(param);
             const paramName = toValidIdentifier(toCamelCase(param.name));
             const isOptional = makeAllOptional || this.typeMapper.isNullable(param);
-            const paramStr = `${paramName}${isOptional ? "?" : ""}: ${mapped.ts}`;
+            const typeStr = isOptional ? `${mapped.ts} | null` : mapped.ts;
+            const paramStr = `${paramName}${isOptional ? "?" : ""}: ${typeStr}`;
             (isOptional ? optional : required).push(paramStr);
         }
         return [...required, ...optional].join(", ");
@@ -1585,6 +1744,9 @@ ${indent}  }`;
         if (type.type === "float") {
             return `{ type: "float", size: ${type.size} }`;
         }
+        if (type.type === "string") {
+            return type.borrowed ? `{ type: "string", borrowed: true }` : `{ type: "string" }`;
+        }
         if (type.type === "gobject") {
             return type.borrowed ? `{ type: "gobject", borrowed: true }` : `{ type: "gobject" }`;
         }
@@ -1601,12 +1763,22 @@ ${indent}  }`;
         if (type.type === "array" && type.itemType) {
             return `{ type: "array", itemType: ${this.generateTypeDescriptor(type.itemType)} }`;
         }
-        if (type.type === "asyncCallback" && type.sourceType && type.resultType) {
-            return `{ type: "asyncCallback", sourceType: ${this.generateTypeDescriptor(type.sourceType)}, resultType: ${this.generateTypeDescriptor(type.resultType)} }`;
+        if (type.type === "callback") {
+            const parts = [`type: "callback"`];
+            if (type.trampoline) {
+                parts.push(`trampoline: "${type.trampoline}"`);
+            }
+            if (type.sourceType) {
+                parts.push(`sourceType: ${this.generateTypeDescriptor(type.sourceType)}`);
+            }
+            if (type.resultType) {
+                parts.push(`resultType: ${this.generateTypeDescriptor(type.resultType)}`);
+            }
+            return `{ ${parts.join(", ")} }`;
         }
         return `{ type: "${type.type}" }`;
     }
-    generateImports(currentClassName, parentClassName) {
+    generateImports(currentClassName, parentClassName, parentNamespace) {
         const nativeImports = [];
         if (this.usesAlloc)
             nativeImports.push("alloc");
@@ -1627,6 +1799,8 @@ ${indent}  }`;
         const ffiImports = [];
         if (this.usesNativeError)
             ffiImports.push("NativeError");
+        if (this.usesSignalMeta)
+            ffiImports.push("SignalMeta");
         if (this.usesWrapPtr)
             ffiImports.push("wrapPtr");
         if (ffiImports.length > 0) {
@@ -1677,6 +1851,9 @@ ${indent}  }`;
         if (this.addGioImport && this.options.namespace !== "Gio") {
             externalNamespaces.add("Gio");
         }
+        if (parentNamespace && parentNamespace !== this.options.namespace) {
+            externalNamespaces.add(parentNamespace);
+        }
         for (const namespace of Array.from(externalNamespaces).sort()) {
             const nsLower = namespace.toLowerCase();
             lines.push(`import * as ${namespace} from "../${nsLower}/index.js";`);

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

@@ -1,12 +1,11 @@
 import { Display } from "./display.js";
 import * as Gio from "../gio/index.js";
-export declare class AppLaunchContext {
-    ptr: unknown;
+export declare class AppLaunchContext extends Gio.AppLaunchContext {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    getDisplay(): Display;
+    getGdkDisplay(): Display;
     setDesktop(desktop: number): void;
-    setIcon(icon?: Gio.Icon): void;
-    setIconName(iconName?: string): void;
+    setIcon(icon?: Gio.Icon | null): void;
+    setIconName(iconName?: string | null): void;
     setTimestamp(timestamp: number): void;
 }

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

@@ -1,23 +1,29 @@
 import { call } from "@gtkx/native";
 import { wrapPtr } from "@gtkx/ffi";
 import { Display } from "./display.js";
-export class AppLaunchContext {
-    ptr;
+import * as Gio from "../gio/index.js";
+export class AppLaunchContext extends Gio.AppLaunchContext {
     constructor(...args) {
-        this.ptr = this.createPtr(args);
+        super(...args);
     }
     createPtr(_args) {
-        return null;
+        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", [
+            { type: { type: "int", size: 64, unsigned: true }, value: gtype },
+            { type: { type: "gobject" }, value: null },
+        ], { type: "gobject", borrowed: true });
     }
-    getDisplay() {
+    getGdkDisplay() {
         const ptr = call("libgtk-4.so.1", "gdk_app_launch_context_get_display", [
             {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
         ], { type: "gobject", borrowed: true });
-        if (ptr === null)
-            return null;
         return wrapPtr(ptr, Display);
     }
     setDesktop(desktop) {

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

@@ -5,7 +5,15 @@ export class ButtonEvent extends Event {
         super(...args);
     }
     createPtr(_args) {
-        return null;
+        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", [
+            { type: { type: "int", size: 64, unsigned: true }, value: gtype },
+            { type: { type: "gobject" }, value: null },
+        ], { type: "gobject", borrowed: true });
     }
     getButton() {
         return call("libgtk-4.so.1", "gdk_button_event_get_button", [

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

@@ -3,5 +3,5 @@ import { DrawContext } from "./draw-context.js";
 export declare class CairoContext extends DrawContext {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    cairoCreate(): cairo.Context;
+    cairoCreate(): cairo.Context | null;
 }