@gtkx/ffi 0.1.6 → 0.1.7

package/dist/codegen/ffi-generator.js

@@ -52,8 +52,20 @@ const RESERVED_WORDS = new Set([
     "arguments",
 ]);
 const METHOD_RENAMES = new Map([
-    ["IconView", new Map([["setCursor", "setCursorPath"]])],
-    ["TreeView", new Map([["setCursor", "setCursorPath"]])],
+    [
+        "IconView",
+        new Map([
+            ["setCursor", "setCursorPath"],
+            ["getCursor", "getCursorPath"],
+        ]),
+    ],
+    [
+        "TreeView",
+        new Map([
+            ["setCursor", "setCursorPath"],
+            ["getCursor", "getCursorPath"],
+        ]),
+    ],
     ["HSV", new Map([["getColor", "getHsvColor"]])],
     ["Layout", new Map([["getSize", "getLayoutSize"]])],
     ["Table", new Map([["getSize", "getTableSize"]])],
@@ -68,10 +80,9 @@ const METHOD_RENAMES = new Map([
             ["setDirection", "setArrowDirection"],
         ]),
     ],
+    ["PrintUnixDialog", new Map([["getSettings", "getPrintSettings"]])],
 ]);
-const CLASS_RENAMES = new Map([
-    ["Error", "GError"],
-]);
+const CLASS_RENAMES = new Map([["Error", "GError"]]);
 const toKebabCase = (str) => str
     .replace(/([a-z])([A-Z])/g, "$1-$2")
     .replace(/_/g, "-")
@@ -151,6 +162,7 @@ export class CodeGenerator {
     typeMapper;
     usesRef = false;
     usesCall = false;
+    addGioImport = false;
     usesType = false;
     usesRead = false;
     usesWrite = false;
@@ -158,39 +170,50 @@ export class CodeGenerator {
     usesNativeError = false;
     usedEnums = new Set();
     usedRecords = new Set();
+    usedExternalTypes = new Map();
+    usedSameNamespaceClasses = new Map();
+    usedInterfaces = new Map();
     signalClasses = new Set();
     recordNameToFile = new Map();
+    interfaceNameToFile = new Map();
     currentSharedLibrary = "";
+    cyclicReturnTypes = new Set();
     constructor(options) {
         this.options = options;
         this.typeMapper = new TypeMapper();
+        if (options.typeRegistry) {
+            this.typeMapper.setTypeRegistry(options.typeRegistry, options.namespace);
+        }
     }
     async generateNamespace(namespace) {
         const files = new Map();
         this.currentSharedLibrary = namespace.sharedLibrary;
         this.registerEnumsAndBitfields(namespace);
         this.registerRecords(namespace);
+        this.registerInterfaces(namespace);
         const classMap = this.buildClassMap(namespace);
+        const interfaceMap = this.buildInterfaceMap(namespace);
         this.attachConstructorFunctions(namespace, classMap);
-        for (const iface of namespace.interfaces) {
-            files.set(`${toKebabCase(iface.name)}.ts`, await this.generateInterface(iface, namespace.sharedLibrary, classMap));
-        }
-        for (const cls of namespace.classes) {
-            files.set(`${toKebabCase(cls.name)}.ts`, await this.generateClass(cls, namespace.sharedLibrary, classMap));
+        const allEnums = [...namespace.enumerations, ...namespace.bitfields];
+        if (allEnums.length > 0) {
+            files.set("enums.ts", await this.generateEnums(allEnums));
         }
         for (const record of namespace.records) {
             if (this.shouldGenerateRecord(record)) {
                 files.set(`${toKebabCase(record.name)}.ts`, await this.generateRecord(record, namespace.sharedLibrary));
             }
         }
+        const sortedClasses = this.topologicalSortClasses(namespace.classes, classMap);
+        for (const cls of sortedClasses) {
+            files.set(`${toKebabCase(cls.name)}.ts`, await this.generateClass(cls, namespace.sharedLibrary, classMap, interfaceMap));
+        }
+        for (const iface of namespace.interfaces) {
+            files.set(`${toKebabCase(iface.name)}.ts`, await this.generateInterface(iface, namespace.sharedLibrary, classMap));
+        }
         const standaloneFunctions = this.getStandaloneFunctions(namespace, classMap);
         if (standaloneFunctions.length > 0) {
             files.set("functions.ts", await this.generateFunctions(standaloneFunctions, namespace.sharedLibrary));
         }
-        const allEnums = [...namespace.enumerations, ...namespace.bitfields];
-        if (allEnums.length > 0) {
-            files.set("enums.ts", await this.generateEnums(allEnums));
-        }
         files.set("index.ts", await this.generateIndex(files.keys()));
         return files;
     }
@@ -231,6 +254,19 @@ export class CodeGenerator {
         }
         return classMap;
     }
+    registerInterfaces(namespace) {
+        for (const iface of namespace.interfaces) {
+            const normalizedName = toPascalCase(iface.name);
+            this.interfaceNameToFile.set(normalizedName, iface.name);
+        }
+    }
+    buildInterfaceMap(namespace) {
+        const interfaceMap = new Map();
+        for (const iface of namespace.interfaces) {
+            interfaceMap.set(iface.name, iface);
+        }
+        return interfaceMap;
+    }
     attachConstructorFunctions(namespace, classMap) {
         for (const func of namespace.functions) {
             const match = func.cIdentifier?.match(/^[a-z_]+_([a-z_]+)_new(_.*)?$/);
@@ -266,6 +302,7 @@ export class CodeGenerator {
     resetState() {
         this.usesRef = false;
         this.usesCall = false;
+        this.addGioImport = false;
         this.usesType = false;
         this.usesRead = false;
         this.usesWrite = false;
@@ -273,21 +310,56 @@ export class CodeGenerator {
         this.usesNativeError = false;
         this.usedEnums.clear();
         this.usedRecords.clear();
+        this.usedExternalTypes.clear();
+        this.usedSameNamespaceClasses.clear();
+        this.usedInterfaces.clear();
         this.signalClasses.clear();
+        this.cyclicReturnTypes.clear();
         this.typeMapper.setEnumUsageCallback((enumName) => this.usedEnums.add(enumName));
         this.typeMapper.setRecordUsageCallback((recordName) => this.usedRecords.add(recordName));
+        this.typeMapper.setExternalTypeUsageCallback((usage) => {
+            const key = `${usage.namespace}.${usage.transformedName}`;
+            this.usedExternalTypes.set(key, usage);
+        });
+        this.typeMapper.setSameNamespaceClassUsageCallback((className, originalName) => {
+            this.usedSameNamespaceClasses.set(className, originalName);
+        });
     }
-    async generateClass(cls, sharedLibrary, classMap) {
+    async generateClass(cls, sharedLibrary, classMap, interfaceMap) {
         this.resetState();
+        this.cyclicReturnTypes = this.computeCyclicReturnTypes(cls, classMap);
+        const asyncMethods = new Set();
+        const finishMethods = new Set();
+        for (const method of cls.methods) {
+            if (this.hasAsyncCallback(method)) {
+                asyncMethods.add(method.name);
+                finishMethods.add(`${method.name}_finish`);
+            }
+        }
+        const parentMethodNames = this.collectParentMethodNames(cls, classMap, interfaceMap);
+        const filteredClassMethods = cls.methods.filter((m) => !parentMethodNames.has(m.name));
+        const classMethodNames = new Set(cls.methods.map((m) => m.name));
+        const interfaceMethods = cls.implements
+            .flatMap((ifaceName) => interfaceMap.get(ifaceName)?.methods ?? [])
+            .filter((m) => !classMethodNames.has(m.name) && !parentMethodNames.has(m.name));
+        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 =
-            cls.methods.some((m) => hasOutParameter(m.parameters)) ||
+            syncMethods.some((m) => hasOutParameter(m.parameters)) ||
                 cls.constructors.some((c) => hasOutParameter(c.parameters)) ||
-                cls.functions.some((f) => hasOutParameter(f.parameters));
-        this.usesCall = cls.methods.length > 0 || cls.constructors.length > 0 || cls.functions.length > 0 || cls.signals.length > 0;
+                cls.functions.some((f) => hasOutParameter(f.parameters)) ||
+                syncInterfaceMethods.some((m) => hasOutParameter(m.parameters));
+        this.usesCall =
+            filteredClassMethods.length > 0 ||
+                cls.constructors.length > 0 ||
+                cls.functions.length > 0 ||
+                cls.signals.length > 0 ||
+                interfaceMethods.length > 0;
         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 implementsClause = "";
         const sections = [];
         if (hasParent && cls.parent) {
             sections.push(`import { ${parentClassName} } from "./${toKebabCase(cls.parent)}.js";`);
@@ -296,15 +368,18 @@ export class CodeGenerator {
         if (cls.doc) {
             sections.push(formatDoc(cls.doc));
         }
-        sections.push(`export class ${className}${extendsClause} {`);
+        sections.push(`export class ${className}${extendsClause}${implementsClause} {`);
         if (!extendsClause) {
             sections.push(`  ptr: unknown;\n`);
         }
         sections.push(this.generateConstructors(cls, sharedLibrary, hasParent));
         sections.push(this.generateCreatePtr(cls, sharedLibrary, hasParent));
         sections.push(this.generateStaticFunctions(cls.functions, sharedLibrary, className));
-        sections.push(this.generateMethods(cls.methods, sharedLibrary, cls.name));
+        sections.push(this.generateMethods(filteredClassMethods, sharedLibrary, cls.name));
         sections.push(this.generateProperties(cls.properties, cls.methods));
+        if (interfaceMethods.length > 0) {
+            sections.push(this.generateMethods(interfaceMethods, sharedLibrary, className));
+        }
         if (cls.signals.length > 0) {
             const hasConnectMethod = cls.methods.some((m) => toCamelCase(m.name) === "connect");
             sections.push(this.generateSignalConnect(sharedLibrary, cls.signals, hasConnectMethod, classMap));
@@ -313,6 +388,124 @@ export class CodeGenerator {
         const imports = this.generateImports(className, hasParent ? parentClassName : undefined);
         return this.formatCode(imports + sections.join("\n"));
     }
+    topologicalSortClasses(classes, classMap) {
+        const sorted = [];
+        const visited = new Set();
+        const visit = (cls) => {
+            if (visited.has(cls.name))
+                return;
+            visited.add(cls.name);
+            if (cls.parent && classMap.has(cls.parent)) {
+                const parent = classMap.get(cls.parent);
+                visit(parent);
+            }
+            sorted.push(cls);
+        };
+        for (const cls of classes) {
+            visit(cls);
+        }
+        return sorted;
+    }
+    isDescendantOf(className, ancestorName, classMap) {
+        const cls = classMap.get(className);
+        if (!cls)
+            return false;
+        if (cls.parent === ancestorName)
+            return true;
+        if (cls.parent && classMap.has(cls.parent)) {
+            return this.isDescendantOf(cls.parent, ancestorName, classMap);
+        }
+        return false;
+    }
+    computeCyclicReturnTypes(cls, classMap) {
+        const cyclic = new Set();
+        for (const method of cls.methods) {
+            const returnTypeName = method.returnType.name;
+            if (returnTypeName && classMap.has(returnTypeName)) {
+                if (this.wouldCreateCycle(cls.name, returnTypeName, classMap)) {
+                    cyclic.add(normalizeClassName(returnTypeName));
+                }
+            }
+        }
+        for (const func of cls.functions) {
+            const returnTypeName = func.returnType.name;
+            if (returnTypeName && classMap.has(returnTypeName)) {
+                if (this.wouldCreateCycle(cls.name, returnTypeName, classMap)) {
+                    cyclic.add(normalizeClassName(returnTypeName));
+                }
+            }
+        }
+        return cyclic;
+    }
+    wouldCreateCycle(currentClass, returnType, classMap) {
+        if (this.isDescendantOf(returnType, currentClass, classMap)) {
+            return true;
+        }
+        const returnTypeClass = classMap.get(returnType);
+        if (!returnTypeClass)
+            return false;
+        const ancestors = this.getAncestors(returnType, classMap);
+        for (const ancestor of ancestors) {
+            const ancestorClass = classMap.get(ancestor);
+            if (!ancestorClass)
+                continue;
+            if (this.classImports(ancestorClass, currentClass, classMap)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getAncestors(className, classMap) {
+        const ancestors = [];
+        let current = classMap.get(className);
+        while (current?.parent && classMap.has(current.parent)) {
+            ancestors.push(current.parent);
+            current = classMap.get(current.parent);
+        }
+        return ancestors;
+    }
+    classImports(cls, targetClass, _classMap) {
+        for (const method of cls.methods) {
+            if (method.returnType.name === targetClass)
+                return true;
+            for (const param of method.parameters) {
+                if (param.type.name === targetClass)
+                    return true;
+            }
+        }
+        for (const func of cls.functions) {
+            if (func.returnType.name === targetClass)
+                return true;
+            for (const param of func.parameters) {
+                if (param.type.name === targetClass)
+                    return true;
+            }
+        }
+        for (const prop of cls.properties) {
+            if (prop.type.name === targetClass)
+                return true;
+        }
+        return false;
+    }
+    collectParentMethodNames(cls, classMap, interfaceMap) {
+        const names = new Set();
+        let current = cls.parent ? classMap.get(cls.parent) : undefined;
+        while (current) {
+            for (const method of current.methods) {
+                names.add(method.name);
+            }
+            for (const ifaceName of current.implements) {
+                const iface = interfaceMap.get(ifaceName);
+                if (iface) {
+                    for (const method of iface.methods) {
+                        names.add(method.name);
+                    }
+                }
+            }
+            current = current.parent ? classMap.get(current.parent) : undefined;
+        }
+        return names;
+    }
     generateConstructors(cls, _sharedLibrary, hasParent) {
         const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
         const sections = [];
@@ -376,7 +569,7 @@ export class CodeGenerator {
             }
             return `  protected createPtr(_args: unknown[]): unknown {\n    return null;\n  }\n`;
         }
-        const filteredParams = mainConstructor.parameters.filter((p) => !isVararg(p));
+        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 destructuring = paramNames.length > 0
@@ -498,15 +691,258 @@ ${allArgs ? `${allArgs},` : ""}
     generateMethods(methods, sharedLibrary, className) {
         const generatedMethods = new Set();
         const sections = [];
+        const asyncMethods = new Set();
+        const finishMethods = new Set();
+        for (const method of methods) {
+            if (this.hasAsyncCallback(method)) {
+                asyncMethods.add(method.name);
+                finishMethods.add(`${method.name}_finish`);
+            }
+        }
         for (const method of methods) {
             const methodKey = `${toCamelCase(method.name)}:${method.cIdentifier}`;
             if (generatedMethods.has(methodKey))
                 continue;
             generatedMethods.add(methodKey);
+            if (asyncMethods.has(method.name) || finishMethods.has(method.name)) {
+                const asyncWrapper = this.generateAsyncWrapper(method, methods, sharedLibrary, className);
+                if (asyncWrapper) {
+                    sections.push(asyncWrapper);
+                }
+                continue;
+            }
             sections.push(this.generateMethod(method, sharedLibrary, className));
         }
         return sections.join("\n");
     }
+    hasAsyncCallback(method) {
+        return method.parameters.some((p) => p.type.name === "Gio.AsyncReadyCallback");
+    }
+    findFinishMethod(asyncMethod, allMethods) {
+        const finishName = `${asyncMethod.name}_finish`;
+        return allMethods.find((m) => m.name === finishName);
+    }
+    generateAsyncWrapper(method, allMethods, sharedLibrary, className) {
+        if (!this.hasAsyncCallback(method))
+            return null;
+        const finishMethod = this.findFinishMethod(method, allMethods);
+        if (!finishMethod)
+            return null;
+        let methodName = toCamelCase(method.name);
+        if (className) {
+            const renames = METHOD_RENAMES.get(className);
+            const renamed = renames?.get(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));
+        let hasRequiredAfterOptional = false;
+        let seenOptional = false;
+        for (const p of paramsWithoutCallback) {
+            const isOptional = this.typeMapper.isNullable(p);
+            if (isOptional)
+                seenOptional = true;
+            else if (seenOptional)
+                hasRequiredAfterOptional = true;
+        }
+        if (hasRequiredAfterOptional) {
+            return null;
+        }
+        const params = paramsWithoutCallback
+            .map((p) => {
+            const mapped = this.typeMapper.mapParameter(p);
+            const paramName = toValidIdentifier(toCamelCase(p.name));
+            const isOptional = this.typeMapper.isNullable(p);
+            return `${paramName}${isOptional ? "?" : ""}: ${mapped.ts}`;
+        })
+            .join(", ");
+        const finishParams = finishMethod.parameters.filter((p) => !isVararg(p));
+        const outputParams = finishParams.filter((p) => p.direction === "out" || (p.type.name !== "Gio.AsyncResult" && p.direction !== "in"));
+        const returnTypeMapping = this.typeMapper.mapType(finishMethod.returnType, true);
+        const mainReturnType = returnTypeMapping.ts;
+        const hasMainReturn = mainReturnType !== "void";
+        this.addGioImport = true;
+        const promiseType = this.buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams);
+        const lines = [];
+        lines.push(`  /**`);
+        lines.push(`   * Promise-based version of ${methodName}.`);
+        if (method.doc) {
+            const docLines = sanitizeDoc(method.doc).split("\n").slice(0, 3);
+            for (const line of docLines) {
+                lines.push(`   * ${line.trim()}`);
+            }
+        }
+        lines.push(`   */`);
+        lines.push(`  ${methodName}(${params}): Promise<${promiseType}> {`);
+        lines.push(`    return new Promise((resolve, reject) => {`);
+        const callArgs = this.buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary);
+        lines.push(callArgs);
+        lines.push(`    });`);
+        lines.push(`  }`);
+        return `${lines.join("\n")}\n`;
+    }
+    buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams) {
+        if (outputParams.length === 0) {
+            return hasMainReturn ? mainReturnType : "void";
+        }
+        const outputTypes = [];
+        if (hasMainReturn) {
+            outputTypes.push(`result: ${mainReturnType}`);
+        }
+        for (const param of outputParams) {
+            const paramName = toValidIdentifier(toCamelCase(param.name));
+            const mapped = this.typeMapper.mapParameter(param);
+            let paramType = mapped.ts;
+            if (paramType.startsWith("Ref<") && paramType.endsWith(">")) {
+                paramType = paramType.slice(4, -1);
+            }
+            outputTypes.push(`${paramName}: ${paramType}`);
+        }
+        return `{ ${outputTypes.join("; ")} }`;
+    }
+    buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary) {
+        const returnTypeMapping = this.typeMapper.mapType(finishMethod.returnType, true);
+        const hasMainReturn = returnTypeMapping.ts !== "void";
+        const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
+            returnTypeMapping.ts !== "unknown";
+        const lines = [];
+        for (const param of outputParams) {
+            const paramName = toValidIdentifier(toCamelCase(param.name));
+            lines.push(`      const ${paramName}Ref = { value: null as unknown };`);
+        }
+        const nonCallbackParams = method.parameters.filter((p, i) => !isVararg(p) &&
+            p.type.name !== "Gio.AsyncReadyCallback" &&
+            !this.typeMapper.isClosureTarget(i, method.parameters));
+        const asyncCallArgs = nonCallbackParams
+            .map((param) => {
+            const mapped = this.typeMapper.mapParameter(param);
+            const jsParamName = toValidIdentifier(toCamelCase(param.name));
+            const needsPtr = mapped.ffi.type === "gobject" || mapped.ffi.type === "boxed";
+            const valueName = needsPtr ? `(${jsParamName} as any)?.ptr ?? ${jsParamName}` : jsParamName;
+            return `          {\n            type: ${this.generateTypeDescriptor(mapped.ffi)},\n            value: ${valueName},\n          }`;
+        })
+            .join(",\n");
+        const finishCallArgs = this.generateFinishCallArguments(finishMethod.parameters, outputParams);
+        const finishReturnType = this.typeMapper.mapType(finishMethod.returnType, true);
+        lines.push(`      const callback = (_source: unknown, asyncResult: unknown) => {`);
+        lines.push(`        try {`);
+        if (finishMethod.throws) {
+            lines.push(`          const error = { value: null as unknown };`);
+        }
+        const errorArg = finishMethod.throws
+            ? `,\n            { type: { type: "ref", innerType: { type: "boxed", innerType: "GError", lib: "libglib-2.0.so.0" } }, value: error }`
+            : "";
+        if (hasMainReturn) {
+            const varName = needsObjectWrap ? "ptr" : "result";
+            const castType = needsObjectWrap ? "unknown" : finishReturnType.ts;
+            lines.push(`          const ${varName} = call(`);
+            lines.push(`            "${sharedLibrary}",`);
+            lines.push(`            "${finishMethod.cIdentifier}",`);
+            lines.push(`            [`);
+            lines.push(`              { type: { type: "gobject" }, value: this.ptr },`);
+            lines.push(`${finishCallArgs}${errorArg}`);
+            lines.push(`            ],`);
+            lines.push(`            ${this.generateTypeDescriptor(finishReturnType.ffi)}`);
+            lines.push(`          ) as ${castType};`);
+        }
+        else {
+            lines.push(`          call(`);
+            lines.push(`            "${sharedLibrary}",`);
+            lines.push(`            "${finishMethod.cIdentifier}",`);
+            lines.push(`            [`);
+            lines.push(`              { type: { type: "gobject" }, value: this.ptr },`);
+            lines.push(`${finishCallArgs}${errorArg}`);
+            lines.push(`            ],`);
+            lines.push(`            { type: "undefined" }`);
+            lines.push(`          );`);
+        }
+        if (finishMethod.throws) {
+            lines.push(`          if (error.value !== null) {`);
+            lines.push(`            throw new NativeError(error.value);`);
+            lines.push(`          }`);
+            this.usesNativeError = true;
+        }
+        if (outputParams.length === 0) {
+            if (hasMainReturn) {
+                if (needsObjectWrap) {
+                    lines.push(`          if (ptr === null) { resolve(null as unknown as ${finishReturnType.ts}); return; }`);
+                    lines.push(`          const instance = Object.create(${finishReturnType.ts}.prototype) as ${finishReturnType.ts} & { ptr: unknown };`);
+                    lines.push(`          instance.ptr = ptr;`);
+                    lines.push(`          resolve(instance);`);
+                }
+                else {
+                    lines.push(`          resolve(result);`);
+                }
+            }
+            else {
+                lines.push(`          resolve();`);
+            }
+        }
+        else {
+            const resolveFields = [];
+            if (hasMainReturn) {
+                if (needsObjectWrap) {
+                    lines.push(`          const result = (ptr === null ? null : (() => {`);
+                    lines.push(`            const instance = Object.create(${finishReturnType.ts}.prototype) as ${finishReturnType.ts} & { ptr: unknown };`);
+                    lines.push(`            instance.ptr = ptr;`);
+                    lines.push(`            return instance;`);
+                    lines.push(`          })()) as ${finishReturnType.ts};`);
+                }
+                resolveFields.push("result");
+            }
+            for (const param of outputParams) {
+                const paramName = toValidIdentifier(toCamelCase(param.name));
+                const mapped = this.typeMapper.mapParameter(param);
+                let paramType = mapped.ts;
+                if (paramType.startsWith("Ref<") && paramType.endsWith(">")) {
+                    paramType = paramType.slice(4, -1);
+                }
+                resolveFields.push(`${paramName}: ${paramName}Ref.value as ${paramType}`);
+            }
+            lines.push(`          resolve({ ${resolveFields.join(", ")} });`);
+        }
+        lines.push(`        } catch (err) {`);
+        lines.push(`          reject(err);`);
+        lines.push(`        }`);
+        lines.push(`      };`);
+        lines.push(`      call(`);
+        lines.push(`        "${sharedLibrary}",`);
+        lines.push(`        "${method.cIdentifier}",`);
+        lines.push(`        [`);
+        lines.push(`          { type: { type: "gobject" }, value: this.ptr },`);
+        if (asyncCallArgs) {
+            lines.push(`${asyncCallArgs},`);
+        }
+        lines.push(`          {`);
+        lines.push(`            type: { type: "asyncCallback", sourceType: { type: "gobject", borrowed: true }, resultType: { type: "gobject", borrowed: true } },`);
+        lines.push(`            value: callback,`);
+        lines.push(`          },`);
+        lines.push(`        ],`);
+        lines.push(`        { type: "undefined" }`);
+        lines.push(`      );`);
+        return lines.join("\n");
+    }
+    generateFinishCallArguments(parameters, outputParams) {
+        return parameters
+            .filter((p) => !isVararg(p))
+            .map((param) => {
+            const paramName = toValidIdentifier(toCamelCase(param.name));
+            if (param.type.name === "Gio.AsyncResult") {
+                return `              { type: { type: "gobject" }, value: asyncResult }`;
+            }
+            if (outputParams.some((op) => op.name === param.name)) {
+                const mapped = this.typeMapper.mapParameter(param);
+                return `              { type: ${this.generateTypeDescriptor(mapped.ffi)}, value: ${paramName}Ref }`;
+            }
+            const mapped = this.typeMapper.mapParameter(param);
+            const needsPtr = mapped.ffi.type === "gobject" || mapped.ffi.type === "boxed";
+            const valueName = needsPtr ? `(${paramName} as any)?.ptr ?? ${paramName}` : paramName;
+            return `              { type: ${this.generateTypeDescriptor(mapped.ffi)}, value: ${valueName} }`;
+        })
+            .join(",\n");
+    }
     generateMethod(method, sharedLibrary, className) {
         let methodName = toCamelCase(method.name);
         if (className) {
@@ -522,7 +958,9 @@ ${allArgs ? `${allArgs},` : ""}
         const returnTypeAnnotation = tsReturnType !== "void" ? `: ${tsReturnType}` : "";
         const hasResultParam = method.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
         const resultVarName = hasResultParam ? "_result" : "result";
-        const needsCast = returnTypeMapping.ts !== "void" && returnTypeMapping.ts !== "unknown";
+        const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
+            tsReturnType !== "unknown" &&
+            returnTypeMapping.kind !== "interface";
         const hasReturnValue = returnTypeMapping.ts !== "void";
         const lines = [];
         const methodDoc = formatMethodDoc(method.doc, method.parameters);
@@ -533,17 +971,46 @@ ${allArgs ? `${allArgs},` : ""}
         if (method.throws) {
             lines.push(`    const error = { value: null as unknown };`);
         }
-        const callPrefix = method.throws
-            ? hasReturnValue
-                ? `const ${resultVarName} = `
-                : ""
-            : hasReturnValue
-                ? "return "
-                : "";
         const args = this.generateCallArguments(method.parameters);
         const errorArg = method.throws ? this.generateErrorArgument() : "";
         const allArgs = errorArg ? args + (args ? ",\n" : "") + errorArg : args;
-        lines.push(`    ${callPrefix}call(
+        if (needsObjectWrap && hasReturnValue) {
+            const isCyclic = this.cyclicReturnTypes.has(tsReturnType);
+            lines.push(`    const ptr = call(
+      "${sharedLibrary}",
+      "${method.cIdentifier}",
+      [
+        {
+          type: { type: "gobject" },
+          value: this.ptr,
+        },
+${allArgs ? `${allArgs},` : ""}
+      ],
+      ${this.generateTypeDescriptor(returnTypeMapping.ffi)}
+    );`);
+            if (method.throws) {
+                lines.push(this.generateErrorCheck());
+            }
+            lines.push(`    if (ptr === null) return null as unknown as ${tsReturnType};`);
+            if (isCyclic) {
+                lines.push(`    return { ptr } as unknown as ${tsReturnType};`);
+            }
+            else {
+                lines.push(`    const instance = Object.create(${tsReturnType}.prototype) as ${tsReturnType} & { ptr: unknown };`);
+                lines.push(`    instance.ptr = ptr;`);
+                lines.push(`    return instance;`);
+            }
+        }
+        else {
+            const callPrefix = method.throws
+                ? hasReturnValue
+                    ? `const ${resultVarName} = `
+                    : ""
+                : hasReturnValue
+                    ? "return "
+                    : "";
+            const needsCast = returnTypeMapping.ts !== "void" && returnTypeMapping.ts !== "unknown";
+            lines.push(`    ${callPrefix}call(
       "${sharedLibrary}",
       "${method.cIdentifier}",
       [
@@ -555,10 +1022,11 @@ ${allArgs ? `${allArgs},` : ""}
       ],
       ${this.generateTypeDescriptor(returnTypeMapping.ffi)}
     )${needsCast ? ` as ${tsReturnType}` : ""};`);
-        if (method.throws) {
-            lines.push(this.generateErrorCheck());
-            if (hasReturnValue) {
-                lines.push(`    return ${resultVarName};`);
+            if (method.throws) {
+                lines.push(this.generateErrorCheck());
+                if (hasReturnValue) {
+                    lines.push(`    return ${resultVarName};`);
+                }
             }
         }
         lines.push(`  }`);
@@ -624,6 +1092,8 @@ ${allArgs ? `${allArgs},` : ""}
         const savedRecordCallback = this.typeMapper.getRecordUsageCallback();
         this.typeMapper.setEnumUsageCallback(null);
         this.typeMapper.setRecordUsageCallback(null);
+        this.typeMapper.setExternalTypeUsageCallback(null);
+        this.typeMapper.setSameNamespaceClassUsageCallback(null);
         const signalMetadata = signals.map((signal) => {
             const paramEntries = (signal.parameters ?? []).map((param) => {
                 const ffiType = JSON.stringify(this.typeMapper.mapType(param.type).ffi);
@@ -638,6 +1108,13 @@ ${allArgs ? `${allArgs},` : ""}
         });
         this.typeMapper.setEnumUsageCallback(savedEnumCallback);
         this.typeMapper.setRecordUsageCallback(savedRecordCallback);
+        this.typeMapper.setExternalTypeUsageCallback((usage) => {
+            const key = `${usage.namespace}.${usage.transformedName}`;
+            this.usedExternalTypes.set(key, usage);
+        });
+        this.typeMapper.setSameNamespaceClassUsageCallback((className, originalName) => {
+            this.usedSameNamespaceClasses.set(className, originalName);
+        });
         this.usesType = true;
         const signalMapCode = signalMetadata.length > 0
             ? `const signalMeta: Record<string, { type: Type; cls?: { prototype: object } }[]> = {\n${signalMetadata.join(",\n")}\n  };
@@ -679,22 +1156,27 @@ ${allArgs ? `${allArgs},` : ""}
   }
 `;
     }
-    async generateInterface(iface, sharedLibrary, classMap) {
+    async generateInterface(iface, sharedLibrary, _classMap) {
         this.resetState();
-        this.usesRef = iface.methods.some((m) => hasOutParameter(m.parameters));
-        this.usesCall = iface.methods.length > 0 || iface.signals.length > 0;
         const interfaceName = toPascalCase(iface.name);
         const sections = [];
+        this.usesCall = iface.methods.length > 0;
+        this.usesRef = iface.methods.some((m) => hasOutParameter(m.parameters));
         if (iface.doc) {
             sections.push(formatDoc(iface.doc));
         }
-        sections.push(`export abstract class ${interfaceName} {`);
-        sections.push(`  protected abstract ptr: unknown;\n`);
-        sections.push(this.generateMethods(iface.methods, sharedLibrary, iface.name));
-        sections.push(this.generateProperties(iface.properties, iface.methods));
-        if (iface.signals.length > 0) {
-            const hasConnectMethod = iface.methods.some((m) => toCamelCase(m.name) === "connect");
-            sections.push(this.generateSignalConnect(sharedLibrary, iface.signals, hasConnectMethod, classMap));
+        sections.push(`export class ${interfaceName} {`);
+        sections.push(`  ptr: unknown;`);
+        sections.push(``);
+        sections.push(`  protected constructor(ptr: unknown) {`);
+        sections.push(`    this.ptr = ptr;`);
+        sections.push(`  }`);
+        sections.push(``);
+        sections.push(`  static fromPtr(ptr: unknown): ${interfaceName} {`);
+        sections.push(`    return new ${interfaceName}(ptr);`);
+        sections.push(`  }`);
+        if (iface.methods.length > 0) {
+            sections.push(this.generateMethods(iface.methods, sharedLibrary, interfaceName));
         }
         sections.push("}");
         const imports = this.generateImports(interfaceName);
@@ -706,8 +1188,7 @@ ${allArgs ? `${allArgs},` : ""}
             record.methods.some((m) => hasOutParameter(m.parameters)) ||
                 record.constructors.some((c) => hasOutParameter(c.parameters)) ||
                 record.functions.some((f) => hasOutParameter(f.parameters));
-        this.usesCall =
-            record.methods.length > 0 || record.constructors.length > 0 || record.functions.length > 0;
+        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) {
             this.usesRead = true;
@@ -955,7 +1436,11 @@ ${args}
     }
     isWritableType(type) {
         const typeName = type.name;
-        if (typeName === "gboolean" || typeName === "guint8" || typeName === "gint8" || typeName === "guchar" || typeName === "gchar") {
+        if (typeName === "gboolean" ||
+            typeName === "guint8" ||
+            typeName === "gint8" ||
+            typeName === "guchar" ||
+            typeName === "gchar") {
             return true;
         }
         if (typeName === "gint16" || typeName === "guint16" || typeName === "gshort" || typeName === "gushort") {
@@ -964,7 +1449,12 @@ ${args}
         if (typeName === "gint" || typeName === "guint" || typeName === "gint32" || typeName === "guint32") {
             return true;
         }
-        if (typeName === "gint64" || typeName === "guint64" || typeName === "glong" || typeName === "gulong" || typeName === "gsize" || typeName === "gssize") {
+        if (typeName === "gint64" ||
+            typeName === "guint64" ||
+            typeName === "glong" ||
+            typeName === "gulong" ||
+            typeName === "gsize" ||
+            typeName === "gssize") {
             return true;
         }
         if (typeName === "gfloat" || typeName === "float" || typeName === "gdouble" || typeName === "double") {
@@ -974,16 +1464,35 @@ ${args}
     }
     getFieldSize(type) {
         const typeName = type.name;
-        if (typeName === "gboolean" || typeName === "guint8" || typeName === "gint8" || typeName === "guchar" || typeName === "gchar") {
+        if (typeName === "gboolean" ||
+            typeName === "guint8" ||
+            typeName === "gint8" ||
+            typeName === "guchar" ||
+            typeName === "gchar") {
             return 1;
         }
         if (typeName === "gint16" || typeName === "guint16" || typeName === "gshort" || typeName === "gushort") {
             return 2;
         }
-        if (typeName === "gint" || typeName === "guint" || typeName === "gint32" || typeName === "guint32" || typeName === "gfloat" || typeName === "float" || typeName === "Quark" || typeName === "GQuark") {
+        if (typeName === "gint" ||
+            typeName === "guint" ||
+            typeName === "gint32" ||
+            typeName === "guint32" ||
+            typeName === "gfloat" ||
+            typeName === "float" ||
+            typeName === "Quark" ||
+            typeName === "GQuark") {
             return 4;
         }
-        if (typeName === "gint64" || typeName === "guint64" || typeName === "gdouble" || typeName === "double" || typeName === "glong" || typeName === "gulong" || typeName === "gsize" || typeName === "gssize" || typeName === "GType") {
+        if (typeName === "gint64" ||
+            typeName === "guint64" ||
+            typeName === "gdouble" ||
+            typeName === "double" ||
+            typeName === "glong" ||
+            typeName === "gulong" ||
+            typeName === "gsize" ||
+            typeName === "gssize" ||
+            typeName === "GType") {
             return 8;
         }
         return 8;
@@ -1009,7 +1518,9 @@ ${args}
         const tsReturnType = returnTypeMapping.ts === "void" ? "" : `: ${returnTypeMapping.ts}`;
         const hasResultParam = func.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
         const resultVarName = hasResultParam ? "_result" : "result";
-        const needsCast = returnTypeMapping.ts !== "void" && returnTypeMapping.ts !== "unknown";
+        const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
+            returnTypeMapping.ts !== "unknown" &&
+            returnTypeMapping.kind !== "interface";
         const hasReturnValue = returnTypeMapping.ts !== "void";
         const lines = [];
         const funcDoc = formatMethodDoc(func.doc, func.parameters, "");
@@ -1020,23 +1531,38 @@ ${args}
         if (func.throws) {
             lines.push(`  const error = { value: null as unknown };`);
         }
-        const callPrefix = func.throws
-            ? hasReturnValue
-                ? `const ${resultVarName} = `
-                : ""
-            : hasReturnValue
-                ? "return "
-                : "";
         const args = this.generateCallArguments(func.parameters, "  ");
         const errorArg = func.throws ? this.generateErrorArgument("  ") : "";
         const allArgs = errorArg ? args + (args ? ",\n" : "") + errorArg : args;
-        lines.push(`  ${callPrefix}call("${sharedLibrary}", "${func.cIdentifier}", [
+        if (needsObjectWrap && hasReturnValue) {
+            lines.push(`  const ptr = call("${sharedLibrary}", "${func.cIdentifier}", [
+${allArgs ? `${allArgs},` : ""}
+  ], ${this.generateTypeDescriptor(returnTypeMapping.ffi)});`);
+            if (func.throws) {
+                lines.push(this.generateErrorCheck(""));
+            }
+            lines.push(`  if (ptr === null) return null as unknown as ${returnTypeMapping.ts};`);
+            lines.push(`  const instance = Object.create(${returnTypeMapping.ts}.prototype) as ${returnTypeMapping.ts} & { ptr: unknown };`);
+            lines.push(`  instance.ptr = ptr;`);
+            lines.push(`  return instance;`);
+        }
+        else {
+            const callPrefix = func.throws
+                ? hasReturnValue
+                    ? `const ${resultVarName} = `
+                    : ""
+                : hasReturnValue
+                    ? "return "
+                    : "";
+            const needsCast = returnTypeMapping.ts !== "void" && returnTypeMapping.ts !== "unknown";
+            lines.push(`  ${callPrefix}call("${sharedLibrary}", "${func.cIdentifier}", [
 ${allArgs ? `${allArgs},` : ""}
   ], ${this.generateTypeDescriptor(returnTypeMapping.ffi)})${needsCast ? ` as ${returnTypeMapping.ts}` : ""};`);
-        if (func.throws) {
-            lines.push(this.generateErrorCheck(""));
-            if (hasReturnValue) {
-                lines.push(`  return ${resultVarName};`);
+            if (func.throws) {
+                lines.push(this.generateErrorCheck(""));
+                if (hasReturnValue) {
+                    lines.push(`  return ${resultVarName};`);
+                }
             }
         }
         lines.push(`};`);
@@ -1064,7 +1590,7 @@ ${allArgs ? `${allArgs},` : ""}
         return this.formatCode(`${exports.join("\n")}\n`);
     }
     generateParameterList(parameters, makeAllOptional = false) {
-        const filteredParams = parameters.filter((p) => !isVararg(p));
+        const filteredParams = parameters.filter((p, i) => !isVararg(p) && !this.typeMapper.isClosureTarget(i, parameters));
         const required = [];
         const optional = [];
         for (const param of filteredParams) {
@@ -1078,11 +1604,13 @@ ${allArgs ? `${allArgs},` : ""}
     }
     generateCallArguments(parameters, indent = "      ") {
         return parameters
-            .filter((p) => !isVararg(p))
+            .filter((p, i) => !isVararg(p) && !this.typeMapper.isClosureTarget(i, parameters))
             .map((param) => {
             const mapped = this.typeMapper.mapParameter(param);
             const jsParamName = toValidIdentifier(toCamelCase(param.name));
-            return `${indent}  {\n${indent}    type: ${this.generateTypeDescriptor(mapped.ffi)},\n${indent}    value: ${jsParamName},\n${indent}  }`;
+            const needsPtr = mapped.ffi.type === "gobject" || mapped.ffi.type === "boxed";
+            const valueName = needsPtr ? `(${jsParamName} as any)?.ptr ?? ${jsParamName}` : jsParamName;
+            return `${indent}  {\n${indent}    type: ${this.generateTypeDescriptor(mapped.ffi)},\n${indent}    value: ${valueName},\n${indent}  }`;
         })
             .join(",\n");
     }
@@ -1118,6 +1646,9 @@ ${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)} }`;
+        }
         return `{ type: "${type.type}" }`;
     }
     generateImports(currentClassName, parentClassName) {
@@ -1150,7 +1681,26 @@ ${indent}  }`;
             const normalizedParentClass = parentClassName ? normalizeClassName(parentClassName) : "";
             if (normalizedRecordName !== normalizedCurrentClass && normalizedRecordName !== normalizedParentClass) {
                 const originalName = this.recordNameToFile.get(normalizedRecordName) ?? normalizedRecordName;
-                lines.push(`import type { ${normalizedRecordName} } from "./${toKebabCase(originalName)}.js";`);
+                lines.push(`import { ${normalizedRecordName} } from "./${toKebabCase(originalName)}.js";`);
+            }
+        }
+        for (const [interfaceName, originalName] of Array.from(this.usedInterfaces.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+            const originalFileName = this.interfaceNameToFile.get(interfaceName) ?? originalName;
+            lines.push(`import { ${interfaceName} } from "./${toKebabCase(originalFileName)}.js";`);
+        }
+        for (const [className, originalName] of Array.from(this.usedSameNamespaceClasses.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+            const normalizedCurrentClass = currentClassName ? normalizeClassName(currentClassName) : "";
+            const normalizedParentClass = parentClassName ? normalizeClassName(parentClassName) : "";
+            if (className !== normalizedCurrentClass &&
+                className !== normalizedParentClass &&
+                !this.signalClasses.has(className) &&
+                !this.usedInterfaces.has(className)) {
+                if (this.cyclicReturnTypes.has(className)) {
+                    lines.push(`import type { ${className} } from "./${toKebabCase(originalName)}.js";`);
+                }
+                else {
+                    lines.push(`import { ${className} } from "./${toKebabCase(originalName)}.js";`);
+                }
             }
         }
         for (const className of Array.from(this.signalClasses).sort()) {
@@ -1158,6 +1708,19 @@ ${indent}  }`;
                 lines.push(`import { ${className} } from "./${toKebabCase(className)}.js";`);
             }
         }
+        const externalNamespaces = new Set();
+        for (const usage of this.usedExternalTypes.values()) {
+            if (usage.namespace === this.options.namespace)
+                continue;
+            externalNamespaces.add(usage.namespace);
+        }
+        if (this.addGioImport && this.options.namespace !== "Gio") {
+            externalNamespaces.add("Gio");
+        }
+        for (const namespace of Array.from(externalNamespaces).sort()) {
+            const nsLower = namespace.toLowerCase();
+            lines.push(`import * as ${namespace} from "../${nsLower}/index.js";`);
+        }
         return lines.length > 0 ? `${lines.join("\n")}\n` : "";
     }
     async formatCode(code) {