@gtkx/ffi 0.8.0 → 0.9.1

package/dist/cairo/cairo.js

@@ -4,7 +4,7 @@
  */
 import { call } from "@gtkx/native";
 const LIB = "libcairo.so.2";
-const CAIRO_T = { type: "int", size: 64, unsigned: true };
+const CAIRO_T = { type: "boxed", innerType: "cairo_t", lib: LIB, borrowed: true };
 /**
  * Begin a new sub-path. After this call the current point will be (x, y).
  */

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

@@ -31,10 +31,10 @@ export declare class CodeGenerator {
     private usesWrite;
     private usesAlloc;
     private usesNativeError;
+    private usesNativeObject;
     private usesGetObject;
-    private usesGetBoxed;
-    private usesGetInterface;
-    private usesRegisterType;
+    private usesRegisterNativeClass;
+    private usesGetClassByTypeName;
     private usesSignalMeta;
     private usedEnums;
     private usedRecords;

package/dist/codegen/ffi-generator.js

@@ -141,7 +141,7 @@ const normalizeClassName = (name, namespace) => {
 };
 const parseParentReference = (parent, classMap, currentNamespace) => {
     if (!parent) {
-        return { hasParent: false, isCrossNamespace: false, className: "", extendsClause: "" };
+        return { hasParent: false, isCrossNamespace: false, className: "", extendsClause: " extends NativeObject" };
     }
     if (parent.includes(".")) {
         const [ns, className] = parent.split(".", 2);
@@ -187,6 +187,9 @@ const hasRefParameter = (params, typeMapper) => {
     return result;
 };
 const isVararg = (param) => param.name === "..." || param.name === "";
+const hasUnsupportedCallbacks = (params, typeMapper) => {
+    return params.some((p) => typeMapper.hasUnsupportedCallback(p));
+};
 /**
  * Generates TypeScript FFI bindings from GIR namespace definitions.
  * Creates classes, methods, properties, and signal handlers that call
@@ -204,10 +207,10 @@ export class CodeGenerator {
     usesWrite = false;
     usesAlloc = false;
     usesNativeError = false;
+    usesNativeObject = false;
     usesGetObject = false;
-    usesGetBoxed = false;
-    usesGetInterface = false;
-    usesRegisterType = false;
+    usesRegisterNativeClass = false;
+    usesGetClassByTypeName = false;
     usesSignalMeta = false;
     usedEnums = new Set();
     usedRecords = new Set();
@@ -239,6 +242,7 @@ export class CodeGenerator {
     async generateNamespace(namespace) {
         const files = new Map();
         this.currentSharedLibrary = namespace.sharedLibrary;
+        this.typeMapper.clearSkippedClasses();
         this.registerEnumsAndBitfields(namespace);
         this.registerRecords(namespace);
         this.registerInterfaces(namespace);
@@ -255,7 +259,13 @@ export class CodeGenerator {
         }
         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));
+            const generatedClass = await this.generateClass(cls, namespace.sharedLibrary, classMap, interfaceMap);
+            if (generatedClass !== null) {
+                files.set(`${toKebabCase(cls.name)}.ts`, generatedClass);
+            }
+            else {
+                this.typeMapper.registerSkippedClass(cls.name);
+            }
         }
         for (const iface of namespace.interfaces) {
             files.set(`${toKebabCase(iface.name)}.ts`, await this.generateInterface(iface, namespace.sharedLibrary, classMap));
@@ -333,10 +343,10 @@ export class CodeGenerator {
         this.usesWrite = false;
         this.usesAlloc = false;
         this.usesNativeError = false;
+        this.usesNativeObject = false;
         this.usesGetObject = false;
-        this.usesGetBoxed = false;
-        this.usesGetInterface = false;
-        this.usesRegisterType = false;
+        this.usesRegisterNativeClass = false;
+        this.usesGetClassByTypeName = false;
         this.usesSignalMeta = false;
         this.usedEnums.clear();
         this.usedRecords.clear();
@@ -356,6 +366,12 @@ export class CodeGenerator {
         });
     }
     async generateClass(cls, sharedLibrary, classMap, interfaceMap) {
+        if (cls.constructors.length > 0) {
+            const hasAnySupportedConstructor = cls.constructors.some((c) => !hasUnsupportedCallbacks(c.parameters, this.typeMapper));
+            if (!hasAnySupportedConstructor) {
+                return null;
+            }
+        }
         this.resetState();
         this.cyclicReturnTypes = this.computeCyclicReturnTypes(cls, classMap);
         const asyncMethods = new Set();
@@ -443,10 +459,11 @@ export class CodeGenerator {
         sections.push(`export class ${className}${parentInfo.extendsClause}${implementsClause} {`);
         if (cls.glibTypeName) {
             const override = parentInfo.hasParent ? "override " : "";
-            sections.push(`  static ${override}readonly glibTypeName: string = "${cls.glibTypeName}";\n`);
+            sections.push(`  static ${override}readonly glibTypeName: string = "${cls.glibTypeName}";`);
+            sections.push(`  static ${override}readonly objectType = "gobject" as const;\n`);
         }
         if (!parentInfo.hasParent) {
-            sections.push(`  id: unknown;\n`);
+            this.usesNativeObject = true;
         }
         sections.push(this.generateConstructors(cls, sharedLibrary, parentInfo.hasParent));
         sections.push(this.generateStaticFunctions(cls.functions, sharedLibrary, className));
@@ -463,8 +480,8 @@ export class CodeGenerator {
         }
         sections.push("}");
         if (cls.glibTypeName) {
-            this.usesRegisterType = true;
-            sections.push(`\nregisterType(${className});`);
+            this.usesRegisterNativeClass = true;
+            sections.push(`\nregisterNativeClass(${className});`);
         }
         if (signalMetaConstant) {
             const classDefIndex = sections.findIndex((s) => s.startsWith("export class "));
@@ -644,18 +661,19 @@ export class CodeGenerator {
         return { signals: allSignals, hasCrossNamespaceParent: false };
     }
     generateConstructors(cls, sharedLibrary, hasParent) {
-        const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
+        const supportedConstructors = cls.constructors.filter((c) => !hasUnsupportedCallbacks(c.parameters, this.typeMapper));
+        const mainConstructor = supportedConstructors.find((c) => !c.parameters.some(isVararg));
         const sections = [];
         if (mainConstructor && hasParent) {
             sections.push(this.generateConstructorWithFlag(mainConstructor, sharedLibrary));
-            for (const ctor of cls.constructors) {
+            for (const ctor of supportedConstructors) {
                 if (ctor !== mainConstructor) {
                     sections.push(this.generateStaticFactoryMethod(ctor, cls.name, sharedLibrary));
                 }
             }
         }
         else {
-            for (const ctor of cls.constructors) {
+            for (const ctor of supportedConstructors) {
                 sections.push(this.generateStaticFactoryMethod(ctor, cls.name, sharedLibrary));
             }
             if (hasParent && cls.glibGetType && !cls.abstract) {
@@ -665,7 +683,7 @@ export class CodeGenerator {
                 sections.push(`  constructor() {\n    super();\n  }\n`);
             }
             else {
-                sections.push(`  constructor() {\n    this.create();\n  }\n`);
+                sections.push(`  constructor() {\n    super();\n    this.create();\n  }\n`);
                 sections.push(`  protected create() {}\n`);
             }
         }
@@ -765,8 +783,9 @@ ${allArgs}
         return `${lines.join("\n")}\n`;
     }
     generateStaticFunctions(functions, sharedLibrary, className) {
+        const supportedFunctions = functions.filter((f) => !hasUnsupportedCallbacks(f.parameters, this.typeMapper));
         const sections = [];
-        for (const func of functions) {
+        for (const func of supportedFunctions) {
             sections.push(this.generateStaticFunction(func, sharedLibrary, className));
         }
         return sections.join("\n");
@@ -856,6 +875,9 @@ ${allArgs ? `${allArgs},` : ""}
             if (generatedMethods.has(methodKey))
                 continue;
             generatedMethods.add(methodKey);
+            if (hasUnsupportedCallbacks(method.parameters, this.typeMapper)) {
+                continue;
+            }
             if (asyncMethods.has(method.name) || finishMethods.has(method.name)) {
                 const asyncWrapper = this.generateAsyncWrapper(method, methods, sharedLibrary, className);
                 if (asyncWrapper) {
@@ -1024,19 +1046,12 @@ ${allArgs ? `${allArgs},` : ""}
         }
         if (outputParams.length === 0) {
             if (hasMainReturn) {
-                if (needsBoxedWrap) {
-                    this.usesGetBoxed = true;
-                    if (isNullable) {
-                        lines.push(`          if (ptr === null) { resolve(null); return; }`);
-                    }
-                    lines.push(`          resolve(getBoxed(ptr, ${finishReturnType.ts}));`);
-                }
-                else if (needsInterfaceWrap) {
-                    this.usesGetInterface = true;
+                if (needsBoxedWrap || needsInterfaceWrap) {
+                    this.usesGetObject = true;
                     if (isNullable) {
                         lines.push(`          if (ptr === null) { resolve(null); return; }`);
                     }
-                    lines.push(`          resolve(getInterface(ptr, ${finishReturnType.ts})!);`);
+                    lines.push(`          resolve(getObject(ptr, ${finishReturnType.ts})!);`);
                 }
                 else if (needsGObjectWrap) {
                     this.usesGetObject = true;
@@ -1056,22 +1071,13 @@ ${allArgs ? `${allArgs},` : ""}
         else {
             const resolveFields = [];
             if (hasMainReturn) {
-                if (needsBoxedWrap) {
-                    this.usesGetBoxed = true;
-                    if (isNullable) {
-                        lines.push(`          const result = ptr === null ? null : getBoxed(ptr, ${finishReturnType.ts});`);
-                    }
-                    else {
-                        lines.push(`          const result = getBoxed(ptr, ${finishReturnType.ts});`);
-                    }
-                }
-                else if (needsInterfaceWrap) {
-                    this.usesGetInterface = true;
+                if (needsBoxedWrap || needsInterfaceWrap) {
+                    this.usesGetObject = true;
                     if (isNullable) {
-                        lines.push(`          const result = ptr === null ? null : getInterface(ptr, ${finishReturnType.ts});`);
+                        lines.push(`          const result = ptr === null ? null : getObject(ptr, ${finishReturnType.ts})!;`);
                     }
                     else {
-                        lines.push(`          const result = getInterface(ptr, ${finishReturnType.ts})!;`);
+                        lines.push(`          const result = getObject(ptr, ${finishReturnType.ts})!;`);
                     }
                 }
                 else if (needsGObjectWrap) {
@@ -1205,13 +1211,9 @@ ${allArgs ? `${allArgs},` : ""}
             if (isCyclic) {
                 lines.push(this.generateCyclicTypeReturn(baseReturnType));
             }
-            else if (needsBoxedWrap) {
-                this.usesGetBoxed = true;
-                lines.push(`    return getBoxed(ptr, ${baseReturnType});`);
-            }
-            else if (needsInterfaceWrap) {
-                this.usesGetInterface = true;
-                lines.push(`    return getInterface(ptr, ${baseReturnType})!;`);
+            else if (needsBoxedWrap || needsInterfaceWrap) {
+                this.usesGetObject = true;
+                lines.push(`    return getObject(ptr, ${baseReturnType})!;`);
             }
             else {
                 this.usesGetObject = true;
@@ -1307,29 +1309,14 @@ ${allArgs ? `${allArgs},` : ""}
         this.typeMapper.setRecordUsageCallback(null);
         this.typeMapper.setExternalTypeUsageCallback(null);
         this.typeMapper.setSameNamespaceClassUsageCallback(null);
+        let hasBoxedSignalParams = false;
         const signalMetadata = signals.map((signal) => {
             const paramEntries = (signal.parameters ?? []).map((param) => {
-                const ffiType = JSON.stringify(this.typeMapper.mapParameter(param).ffi);
-                const signalParamClass = this.extractSignalParamClass(param, classMap);
-                if (signalParamClass) {
-                    const { transformedName, originalName } = signalParamClass;
-                    const dotIndex = transformedName.indexOf(".");
-                    if (dotIndex !== -1) {
-                        const ns = transformedName.slice(0, dotIndex);
-                        const clsName = transformedName.slice(dotIndex + 1);
-                        this.usedExternalTypes.set(transformedName, {
-                            namespace: ns,
-                            name: originalName,
-                            transformedName: clsName,
-                            kind: "class",
-                        });
-                    }
-                    else {
-                        this.signalClasses.set(transformedName, originalName);
-                    }
-                    return `{ type: ${ffiType}, getCls: () => ${transformedName} }`;
+                const ffiType = this.typeMapper.mapParameter(param).ffi;
+                if (ffiType.type === "boxed") {
+                    hasBoxedSignalParams = true;
                 }
-                return `{ type: ${ffiType} }`;
+                return JSON.stringify(ffiType);
             });
             const returnTypeFfi = signal.returnType
                 ? JSON.stringify(this.typeMapper.mapType(signal.returnType).ffi)
@@ -1352,6 +1339,23 @@ ${allArgs ? `${allArgs},` : ""}
             for (const param of signalParams) {
                 const paramName = toValidIdentifier(toCamelCase(param.name));
                 const signalParamClass = this.extractSignalParamClass(param, classMap);
+                if (signalParamClass) {
+                    const { transformedName, originalName } = signalParamClass;
+                    const dotIndex = transformedName.indexOf(".");
+                    if (dotIndex !== -1) {
+                        const ns = transformedName.slice(0, dotIndex);
+                        const clsName = transformedName.slice(dotIndex + 1);
+                        this.usedExternalTypes.set(transformedName, {
+                            namespace: ns,
+                            name: originalName,
+                            transformedName: clsName,
+                            kind: "class",
+                        });
+                    }
+                    else {
+                        this.signalClasses.set(transformedName, originalName);
+                    }
+                }
                 const paramType = signalParamClass?.transformedName ?? this.typeMapper.mapType(param.type).ts;
                 handlerParams.push(`${paramName}: ${paramType}`);
             }
@@ -1374,22 +1378,32 @@ ${allArgs ? `${allArgs},` : ""}
         if (signalMetadata.length > 0) {
             this.usesSignalMeta = true;
         }
+        if (hasBoxedSignalParams) {
+            this.usesGetClassByTypeName = true;
+        }
         const moduleLevel = signalMetadata.length > 0 ? `const SIGNAL_META: SignalMeta = {\n${signalMetadata.join(",\n")}\n};\n` : "";
         const signalMapCode = signalMetadata.length > 0
             ? `const meta = SIGNAL_META[signal];
     const selfType: Type = { type: "gobject", borrowed: true };
-    const argTypes = meta ? [selfType, ...meta.params.map((m) => m.type)] : [selfType];
+    const argTypes = meta ? [selfType, ...meta.params] : [selfType];
     const returnType = meta?.returnType;`
             : `const selfType: Type = { type: "gobject", borrowed: true };\n    const argTypes = [selfType];\n    const returnType = undefined;`;
+        const boxedHandling = hasBoxedSignalParams
+            ? `
+        if (m.type === "boxed" && signalArgs[i] != null) {
+          const cls = getNativeClass(m.innerType);
+          return cls ? getObject(signalArgs[i], cls) : signalArgs[i];
+        }`
+            : "";
         const wrapperCode = signalMetadata.length > 0
             ? `const wrappedHandler = (...args: unknown[]) => {
       const self = getObject(args[0]);
       const signalArgs = args.slice(1);
       if (!meta) return handler(self, ...signalArgs);
       const wrapped = meta.params.map((m, i) => {
-        if (m.getCls && signalArgs[i] != null) {
+        if (m.type === "gobject" && signalArgs[i] != null) {
           return getObject(signalArgs[i]);
-        }
+        }${boxedHandling}
         return signalArgs[i];
       });
       return handler(self, ...wrapped);
@@ -1430,19 +1444,12 @@ ${allArgs ? `${allArgs},` : ""}
         if (iface.doc) {
             sections.push(formatDoc(iface.doc));
         }
-        sections.push(`export class ${interfaceName} {`);
+        this.usesNativeObject = true;
+        sections.push(`export class ${interfaceName} extends NativeObject {`);
         if (iface.glibTypeName) {
-            sections.push(`  static readonly glibTypeName: string = "${iface.glibTypeName}";\n`);
-        }
-        sections.push(`  id: unknown;`);
-        sections.push(``);
-        sections.push(`  protected constructor(id: unknown) {`);
-        sections.push(`    this.id = id;`);
-        sections.push(`  }`);
-        sections.push(``);
-        sections.push(`  static fromPtr(id: unknown): ${interfaceName} {`);
-        sections.push(`    return new ${interfaceName}(id);`);
-        sections.push(`  }`);
+            sections.push(`  static readonly glibTypeName: string = "${iface.glibTypeName}";`);
+            sections.push(`  static readonly objectType = "interface" as const;\n`);
+        }
         if (iface.methods.length > 0) {
             sections.push(this.generateMethods(iface.methods, sharedLibrary, interfaceName));
         }
@@ -1470,11 +1477,12 @@ ${allArgs ? `${allArgs},` : ""}
         if (record.doc) {
             sections.push(formatDoc(record.doc));
         }
-        sections.push(`export class ${recordName} {`);
+        this.usesNativeObject = true;
+        sections.push(`export class ${recordName} extends NativeObject {`);
         if (record.glibTypeName) {
-            sections.push(`  static readonly glibTypeName: string = "${record.glibTypeName}";\n`);
+            sections.push(`  static readonly glibTypeName: string = "${record.glibTypeName}";`);
+            sections.push(`  static readonly objectType = "boxed" as const;\n`);
         }
-        sections.push(`  id: unknown;\n`);
         sections.push(this.generateRecordConstructors(record, sharedLibrary));
         sections.push(this.generateRecordFromPtr(recordName));
         sections.push(this.generateRecordStaticFunctions(record.functions, sharedLibrary, recordName));
@@ -1482,14 +1490,15 @@ ${allArgs ? `${allArgs},` : ""}
         sections.push(this.generateRecordFields(record.fields, record.methods));
         sections.push("}");
         if (record.glibTypeName) {
-            this.usesRegisterType = true;
-            sections.push(`\nregisterType(${recordName});`);
+            this.usesRegisterNativeClass = true;
+            sections.push(`\nregisterNativeClass(${recordName});`);
         }
         const imports = this.generateImports(recordName);
         return this.formatCode(imports + sections.join("\n"));
     }
     generateRecordInitInterface(record) {
-        const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
+        const supportedConstructors = record.constructors.filter((c) => !hasUnsupportedCallbacks(c.parameters, this.typeMapper));
+        const mainConstructor = supportedConstructors.find((c) => !c.parameters.some(isVararg));
         if (mainConstructor)
             return null;
         const initFields = this.getWritableFields(record.fields);
@@ -1501,12 +1510,13 @@ ${allArgs ? `${allArgs},` : ""}
     generateRecordConstructors(record, sharedLibrary) {
         const recordName = normalizeClassName(record.name, this.options.namespace);
         const sections = [];
-        const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
+        const supportedConstructors = record.constructors.filter((c) => !hasUnsupportedCallbacks(c.parameters, this.typeMapper));
+        const mainConstructor = supportedConstructors.find((c) => !c.parameters.some(isVararg));
         if (mainConstructor) {
             const ctorDoc = formatMethodDoc(mainConstructor.doc, mainConstructor.parameters);
             const filteredParams = mainConstructor.parameters.filter((p) => !isVararg(p));
             if (filteredParams.length === 0) {
-                sections.push(`${ctorDoc}  constructor() {\n    this.id = this.createPtr([]);\n  }\n`);
+                sections.push(`${ctorDoc}  constructor() {\n    super();\n    this.id = this.createPtr([]);\n  }\n`);
             }
             else {
                 const typedParams = this.generateParameterList(mainConstructor.parameters, false);
@@ -1515,6 +1525,7 @@ ${allArgs ? `${allArgs},` : ""}
                 const isFirstParamArray = firstParamType.endsWith("[]") || firstParamType.startsWith("Array<");
                 if (isFirstParamArray) {
                     sections.push(`${ctorDoc}  constructor(${typedParams}) {
+    super();
     const _args = [${paramNames.join(", ")}];
     this.id = this.createPtr(_args);
   }
@@ -1524,13 +1535,14 @@ ${allArgs ? `${allArgs},` : ""}
                     sections.push(`${ctorDoc}  constructor(${typedParams});
   constructor(_args: unknown[]);
   constructor(...args: unknown[]) {
+    super();
     const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
     this.id = this.createPtr(_args);
   }
 `);
                 }
             }
-            for (const ctor of record.constructors) {
+            for (const ctor of supportedConstructors) {
                 if (ctor !== mainConstructor) {
                     sections.push(this.generateRecordStaticFactoryMethod(ctor, recordName, sharedLibrary));
                 }
@@ -1539,10 +1551,10 @@ ${allArgs ? `${allArgs},` : ""}
         else {
             const initFields = this.getWritableFields(record.fields);
             if (initFields.length > 0) {
-                sections.push(`  constructor(init: ${recordName}Init = {}) {\n    this.id = this.createPtr(init);\n  }\n`);
+                sections.push(`  constructor(init: ${recordName}Init = {}) {\n    super();\n    this.id = this.createPtr(init);\n  }\n`);
             }
             else {
-                sections.push(`  constructor() {\n    this.id = this.createPtr({});\n  }\n`);
+                sections.push(`  constructor() {\n    super();\n    this.id = this.createPtr({});\n  }\n`);
             }
         }
         sections.push(this.generateRecordCreatePtr(record, sharedLibrary));
@@ -1571,7 +1583,8 @@ ${allArgs ? `${allArgs},` : ""}
     }
     generateRecordCreatePtr(record, sharedLibrary) {
         const recordName = normalizeClassName(record.name, this.options.namespace);
-        const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
+        const supportedConstructors = record.constructors.filter((c) => !hasUnsupportedCallbacks(c.parameters, this.typeMapper));
+        const mainConstructor = supportedConstructors.find((c) => !c.parameters.some(isVararg));
         if (!mainConstructor) {
             if (record.glibTypeName && record.fields.length > 0) {
                 const structSize = this.calculateStructSize(record.fields);
@@ -1789,10 +1802,11 @@ ${args}
     }
     async generateFunctions(functions, sharedLibrary) {
         this.resetState();
-        this.usesRef = functions.some((f) => hasRefParameter(f.parameters, this.typeMapper));
-        this.usesCall = functions.length > 0;
+        const supportedFunctions = functions.filter((f) => !hasUnsupportedCallbacks(f.parameters, this.typeMapper));
+        this.usesRef = supportedFunctions.some((f) => hasRefParameter(f.parameters, this.typeMapper));
+        this.usesCall = supportedFunctions.length > 0;
         const sections = [];
-        for (const func of functions) {
+        for (const func of supportedFunctions) {
             sections.push(this.generateFunction(func, sharedLibrary));
         }
         const imports = this.generateImports();
@@ -1844,13 +1858,9 @@ ${allArgs ? `${allArgs},` : ""}
             if (isNullable) {
                 lines.push(`  if (ptr === null) return null;`);
             }
-            if (needsBoxedWrap) {
-                this.usesGetBoxed = true;
-                lines.push(`  return getBoxed(ptr, ${baseReturnType});`);
-            }
-            else if (needsInterfaceWrap) {
-                this.usesGetInterface = true;
-                lines.push(`  return getInterface(ptr, ${baseReturnType})!;`);
+            if (needsBoxedWrap || needsInterfaceWrap) {
+                this.usesGetObject = true;
+                lines.push(`  return getObject(ptr, ${baseReturnType})!;`);
             }
             else {
                 this.usesGetObject = true;
@@ -1927,7 +1937,7 @@ ${allArgs ? `${allArgs},` : ""}
             const mapped = this.typeMapper.mapParameter(param);
             const paramName = toValidIdentifier(toCamelCase(param.name));
             const isOptional = makeAllOptional || this.typeMapper.isNullable(param);
-            const typeStr = isOptional ? `${mapped.ts} | null` : mapped.ts;
+            const typeStr = mapped.ts;
             const paramStr = `${paramName}${isOptional ? "?" : ""}: ${typeStr}`;
             (isOptional ? optional : required).push(paramStr);
         }
@@ -1978,15 +1988,15 @@ ${allArgs ? `${allArgs},` : ""}
         }
         return gtkAllocatesRefs.map((ref) => {
             if (ref.isBoxed) {
-                this.usesGetBoxed = true;
+                this.usesGetObject = true;
                 return ref.nullable
-                    ? `    if (${ref.paramName}) ${ref.paramName}.value = getBoxed(${ref.paramName}.value, ${ref.innerType});`
-                    : `    ${ref.paramName}.value = getBoxed(${ref.paramName}.value, ${ref.innerType});`;
+                    ? `    if (${ref.paramName}) ${ref.paramName}.value = getObject(${ref.paramName}.value, ${ref.innerType})!;`
+                    : `    ${ref.paramName}.value = getObject(${ref.paramName}.value, ${ref.innerType})!;`;
             }
             this.usesGetObject = true;
             return 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};`;
+                ? `    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 = "      ") {
@@ -2013,10 +2023,15 @@ ${indent}  }`;
         }
         if (type.type === "boxed") {
             const innerType = typeof type.innerType === "string" ? type.innerType : "";
-            const lib = this.currentSharedLibrary;
-            return type.borrowed
-                ? `{ type: "boxed", borrowed: true, innerType: "${innerType}", lib: "${lib}" }`
-                : `{ type: "boxed", innerType: "${innerType}", lib: "${lib}" }`;
+            const lib = type.lib ?? this.currentSharedLibrary;
+            const parts = [`type: "boxed"`, `innerType: "${innerType}"`, `lib: "${lib}"`];
+            if (type.borrowed) {
+                parts.splice(1, 0, `borrowed: true`);
+            }
+            if (type.getTypeFn) {
+                parts.push(`getTypeFn: "${type.getTypeFn}"`);
+            }
+            return `{ ${parts.join(", ")} }`;
         }
         if (type.type === "ref" && type.innerType && typeof type.innerType !== "string") {
             return `{ type: "ref", innerType: ${this.generateTypeDescriptor(type.innerType)} }`;
@@ -2070,22 +2085,26 @@ ${indent}  }`;
             lines.push(`import { call } from "../../batch.js";`);
         }
         if (this.usesNativeError) {
-            lines.push(`import { NativeError } from "../../native-error.js";`);
-        }
-        const nativeJsImports = [];
-        if (this.usesGetObject)
-            nativeJsImports.push("getObject");
-        if (this.usesGetBoxed)
-            nativeJsImports.push("getBoxed");
-        if (this.usesGetInterface)
-            nativeJsImports.push("getInterface");
-        if (this.usesInstantiating)
-            nativeJsImports.push("isInstantiating", "setInstantiating");
-        if (nativeJsImports.length > 0) {
-            lines.push(`import { ${nativeJsImports.join(", ")} } from "../../native.js";`);
+            lines.push(`import { NativeError } from "../../native/error.js";`);
         }
-        if (this.usesRegisterType) {
-            lines.push(`import { registerType } from "../../registry.js";`);
+        if (this.usesGetObject) {
+            lines.push(`import { getObject } from "../../native/object.js";`);
+        }
+        const baseImports = [];
+        if (this.usesInstantiating)
+            baseImports.push("isInstantiating", "setInstantiating");
+        if (this.usesNativeObject)
+            baseImports.push("NativeObject");
+        if (baseImports.length > 0) {
+            lines.push(`import { ${baseImports.join(", ")} } from "../../native/base.js";`);
+        }
+        const registryImports = [];
+        if (this.usesRegisterNativeClass)
+            registryImports.push("registerNativeClass");
+        if (this.usesGetClassByTypeName)
+            registryImports.push("getNativeClass");
+        if (registryImports.length > 0) {
+            lines.push(`import { ${registryImports.join(", ")} } from "../../registry.js";`);
         }
         if (this.usesSignalMeta) {
             lines.push(`import type { SignalMeta } from "../../types.js";`);

package/dist/generated/adw/about-dialog.d.ts

@@ -3,6 +3,7 @@ import * as Gtk from "../gtk/index.js";
 import { Dialog } from "./dialog.js";
 export declare class AboutDialog extends Dialog {
     static readonly glibTypeName: string;
+    static readonly objectType: "gobject";
     /**
      * Creates a new `AdwAboutDialog`.
      */
@@ -32,7 +33,7 @@ export declare class AboutDialog extends Dialog {
      * @param resourcePath - The resource to use
      * @param releaseNotesVersion - The version to retrieve release notes for
      */
-    static dialogNewFromAppdata(resourcePath: string, releaseNotesVersion?: string | null): AboutDialog;
+    static dialogNewFromAppdata(resourcePath: string, releaseNotesVersion?: string): AboutDialog;
     /**
      * Adds a section to the Acknowledgements page.
      *
@@ -54,7 +55,7 @@ export declare class AboutDialog extends Dialog {
      * @param name - the section name
      * @param people - the list of names
      */
-    addAcknowledgementSection(people: string[], name?: string | null): void;
+    addAcknowledgementSection(people: string[], name?: string): void;
     /**
      * Adds an extra section to the Credits page.
      *
@@ -74,7 +75,7 @@ export declare class AboutDialog extends Dialog {
      * @param name - the section name
      * @param people - the list of names
      */
-    addCreditSection(people: string[], name?: string | null): void;
+    addCreditSection(people: string[], name?: string): void;
     /**
      * Adds an extra section to the Legal page.
      *
@@ -121,7 +122,7 @@ export declare class AboutDialog extends Dialog {
      * @param licenseType - the type of license
      * @param license - custom license information
      */
-    addLegalSection(title: string, licenseType: Gtk.License, copyright?: string | null, license?: string | null): void;
+    addLegalSection(title: string, licenseType: Gtk.License, copyright?: string, license?: string): void;
     /**
      * Adds an extra link to the Details page.
      *
@@ -269,7 +270,7 @@ export declare class AboutDialog extends Dialog {
      * * [method@AboutDialog.add_acknowledgement_section]
      * @param artists - the list of artists
      */
-    setArtists(artists?: string[] | null): void;
+    setArtists(artists?: string[]): void;
     /**
      * Sets the comments about the application.
      *
@@ -337,7 +338,7 @@ export declare class AboutDialog extends Dialog {
      * * [method@AboutDialog.add_acknowledgement_section]
      * @param designers - the list of designers
      */
-    setDesigners(designers?: string[] | null): void;
+    setDesigners(designers?: string[]): void;
     /**
      * Sets the developer name for @self.
      *
@@ -368,7 +369,7 @@ export declare class AboutDialog extends Dialog {
      * * [method@AboutDialog.add_acknowledgement_section]
      * @param developers - the list of developers
      */
-    setDevelopers(developers?: string[] | null): void;
+    setDevelopers(developers?: string[]): void;
     /**
      * Sets the list of documenters of the application.
      *
@@ -387,7 +388,7 @@ export declare class AboutDialog extends Dialog {
      * * [method@AboutDialog.add_acknowledgement_section]
      * @param documenters - the list of documenters
      */
-    setDocumenters(documenters?: string[] | null): void;
+    setDocumenters(documenters?: string[]): void;
     /**
      * Sets the issue tracker URL for @self.
      *