@gtkx/gir 0.1.17 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/gir",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "GObject Introspection file parser for GTKX",
   "keywords": [
     "gtk",

package/src/parser.ts

@@ -1,5 +1,6 @@
 import { XMLParser } from "fast-xml-parser";
 import type {
+    GirCallback,
     GirClass,
     GirConstructor,
     GirEnumeration,
@@ -23,6 +24,7 @@ const ARRAY_ELEMENT_PATHS = new Set<string>([
     "namespace.enumeration",
     "namespace.bitfield",
     "namespace.record",
+    "namespace.callback",
     "namespace.class.method",
     "namespace.class.constructor",
     "namespace.class.function",
@@ -49,6 +51,7 @@ const ARRAY_ELEMENT_PATHS = new Set<string>([
     "namespace.record.method.parameters.parameter",
     "namespace.record.constructor.parameters.parameter",
     "namespace.record.function.parameters.parameter",
+    "namespace.callback.parameters.parameter",
 ]);
 
 const extractDoc = (node: Record<string, unknown>): string | undefined => {
@@ -105,15 +108,38 @@ export class GirParser {
             enumerations: this.parseEnumerations(namespace.enumeration ?? []),
             bitfields: this.parseEnumerations(namespace.bitfield ?? []),
             records: this.parseRecords(namespace.record ?? []),
+            callbacks: this.parseCallbacks(namespace.callback ?? []),
         };
     }
 
+    private parseCallbacks(callbacks: Record<string, unknown>[]): GirCallback[] {
+        if (!callbacks || !Array.isArray(callbacks)) {
+            return [];
+        }
+        return callbacks
+            .filter((cb) => cb["@_introspectable"] !== "0")
+            .map((cb) => ({
+                name: String(cb["@_name"] ?? ""),
+                cType: String(cb["@_c:type"] ?? ""),
+                returnType: this.parseReturnType(cb["return-value"] as Record<string, unknown> | undefined),
+                parameters: this.parseParameters(
+                    (cb.parameters && typeof cb.parameters === "object" && cb.parameters !== null
+                        ? cb.parameters
+                        : {}) as Record<string, unknown>,
+                ),
+                doc: extractDoc(cb),
+            }));
+    }
+
     private parseClasses(classes: Record<string, unknown>[]): GirClass[] {
         return classes.map((cls) => ({
             name: String(cls["@_name"] ?? ""),
             cType: String(cls["@_c:type"] ?? cls["@_glib:type-name"] ?? ""),
             parent: String(cls["@_parent"] ?? ""),
             abstract: cls["@_abstract"] === "1",
+            glibTypeName: cls["@_glib:type-name"] ? String(cls["@_glib:type-name"]) : undefined,
+            glibGetType: cls["@_glib:get-type"] ? String(cls["@_glib:get-type"]) : undefined,
+            cSymbolPrefix: cls["@_c:symbol-prefix"] ? String(cls["@_c:symbol-prefix"]) : undefined,
             implements: this.parseImplements(
                 cls.implements as Record<string, unknown>[] | Record<string, unknown> | undefined,
             ),
@@ -193,6 +219,7 @@ export class GirParser {
                         ? ctor.parameters
                         : {}) as Record<string, unknown>,
                 ),
+                throws: ctor["@_throws"] === "1",
                 doc: extractDoc(ctor),
             }));
     }
@@ -227,6 +254,7 @@ export class GirParser {
         return params.map((param: Record<string, unknown>) => {
             const scope = param["@_scope"] as string | undefined;
             const closure = param["@_closure"] as string | undefined;
+            const destroy = param["@_destroy"] as string | undefined;
             return {
                 name: String(param["@_name"] ?? ""),
                 type: this.parseType((param.type ?? param.array) as Record<string, unknown> | undefined),
@@ -235,6 +263,7 @@ export class GirParser {
                 optional: param["@_allow-none"] === "1",
                 scope: scope as "async" | "call" | "notified" | undefined,
                 closure: closure !== undefined ? parseInt(closure, 10) : undefined,
+                destroy: destroy !== undefined ? parseInt(destroy, 10) : undefined,
                 doc: extractDoc(param),
             };
         });
@@ -263,7 +292,7 @@ export class GirParser {
         const typeName = typeNode["@_name"] ? String(typeNode["@_name"]) : undefined;
 
         if (typeName === "GLib.List" || typeName === "GLib.SList") {
-            const innerType = typeNode.type as Record<string, unknown> | undefined;
+            const innerType = (typeNode.type ?? typeNode.array) as Record<string, unknown> | undefined;
             return {
                 name: "array",
                 cType: typeNode["@_c:type"] ? String(typeNode["@_c:type"]) : undefined,

package/src/types.ts

@@ -22,10 +22,28 @@ export interface GirNamespace {
     bitfields: GirEnumeration[];
     /** All records (structs) defined in this namespace. */
     records: GirRecord[];
+    /** All callback types defined in this namespace. */
+    callbacks: GirCallback[];
     /** Documentation for the namespace. */
     doc?: string;
 }
 
+/**
+ * Represents a GIR callback type definition.
+ */
+export interface GirCallback {
+    /** The callback name. */
+    name: string;
+    /** The C type name. */
+    cType: string;
+    /** The return type. */
+    returnType: GirType;
+    /** The callback parameters. */
+    parameters: GirParameter[];
+    /** Documentation for the callback. */
+    doc?: string;
+}
+
 /**
  * Represents a GIR interface definition.
  */
@@ -56,6 +74,12 @@ export interface GirClass {
     parent?: string;
     /** Whether this is an abstract class. */
     abstract?: boolean;
+    /** The GLib type name. */
+    glibTypeName?: string;
+    /** The GLib get-type function. */
+    glibGetType?: string;
+    /** The C symbol prefix for this class. */
+    cSymbolPrefix?: string;
     /** List of interface names this class implements. */
     implements: string[];
     /** Methods defined on this class. */
@@ -148,6 +172,8 @@ export interface GirConstructor {
     returnType: GirType;
     /** The constructor parameters. */
     parameters: GirParameter[];
+    /** Whether this constructor can throw a GError. */
+    throws?: boolean;
     /** Documentation for the constructor. */
     doc?: string;
 }
@@ -188,6 +214,8 @@ export interface GirParameter {
     scope?: "async" | "call" | "notified";
     /** Index of the closure/user_data parameter for callbacks. */
     closure?: number;
+    /** Index of the destroy notifier parameter for callbacks. */
+    destroy?: number;
     /** Documentation for the parameter. */
     doc?: string;
 }
@@ -296,12 +324,14 @@ export interface FfiTypeDescriptor {
     itemType?: FfiTypeDescriptor;
     /** List type for arrays (glist, gslist) - indicates native GList/GSList iteration. */
     listType?: "glist" | "gslist";
-    /** Trampoline type for callbacks (asyncReady, destroy, sourceFunc). Default is "closure". */
-    trampoline?: "asyncReady" | "destroy" | "sourceFunc";
+    /** Trampoline type for callbacks (asyncReady, destroy, sourceFunc, drawFunc). Default is "closure". */
+    trampoline?: "asyncReady" | "destroy" | "sourceFunc" | "drawFunc";
     /** Source type for asyncReady callback (the GObject source). */
     sourceType?: FfiTypeDescriptor;
     /** Result type for asyncReady callback (the GAsyncResult). */
     resultType?: FfiTypeDescriptor;
+    /** Argument types for callbacks that need explicit type info (e.g., drawFunc). */
+    argTypes?: FfiTypeDescriptor[];
 }
 
 /**
@@ -350,7 +380,7 @@ export const registerEnumsFromNamespace = (typeMapper: TypeMapper, namespace: Gi
 
 type TypeMapping = { ts: string; ffi: FfiTypeDescriptor };
 
-export type TypeKind = "class" | "interface" | "enum" | "record";
+export type TypeKind = "class" | "interface" | "enum" | "record" | "callback";
 
 export interface RegisteredType {
     kind: TypeKind;
@@ -414,6 +444,16 @@ export class TypeRegistry {
         });
     }
 
+    registerCallback(namespace: string, name: string): void {
+        const transformedName = toPascalCase(name);
+        this.types.set(`${namespace}.${name}`, {
+            kind: "callback",
+            name,
+            namespace,
+            transformedName,
+        });
+    }
+
     resolve(qualifiedName: string): RegisteredType | undefined {
         return this.types.get(qualifiedName);
     }
@@ -441,16 +481,13 @@ export class TypeRegistry {
                 registry.registerEnum(ns.name, bitfield.name);
             }
             for (const record of ns.records) {
-                if (
-                    record.glibTypeName &&
-                    !record.disguised &&
-                    !record.name.endsWith("Class") &&
-                    !record.name.endsWith("Private") &&
-                    !record.name.endsWith("Iface")
-                ) {
+                if (record.glibTypeName && !record.disguised) {
                     registry.registerRecord(ns.name, record.name, record.glibTypeName);
                 }
             }
+            for (const callback of ns.callbacks) {
+                registry.registerCallback(ns.name, callback.name);
+            }
         }
         return registry;
     }
@@ -458,6 +495,65 @@ export class TypeRegistry {
 
 const STRING_TYPES = new Set(["utf8", "filename"]);
 
+const POINTER_TYPE: TypeMapping = { ts: "number", ffi: { type: "int", size: 64, unsigned: true } };
+
+const C_TYPE_MAP = new Map<string, TypeMapping>([
+    ["void", { ts: "void", ffi: { type: "undefined" } }],
+    ["gboolean", { ts: "boolean", ffi: { type: "boolean" } }],
+    ["gchar", { ts: "number", ffi: { type: "int", size: 8, unsigned: false } }],
+    ["guchar", { ts: "number", ffi: { type: "int", size: 8, unsigned: true } }],
+    ["gint", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
+    ["guint", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
+    ["gshort", { ts: "number", ffi: { type: "int", size: 16, unsigned: false } }],
+    ["gushort", { ts: "number", ffi: { type: "int", size: 16, unsigned: true } }],
+    ["glong", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
+    ["gulong", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["gint8", { ts: "number", ffi: { type: "int", size: 8, unsigned: false } }],
+    ["guint8", { ts: "number", ffi: { type: "int", size: 8, unsigned: true } }],
+    ["gint16", { ts: "number", ffi: { type: "int", size: 16, unsigned: false } }],
+    ["guint16", { ts: "number", ffi: { type: "int", size: 16, unsigned: true } }],
+    ["gint32", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
+    ["guint32", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
+    ["gint64", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
+    ["guint64", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["gfloat", { ts: "number", ffi: { type: "float", size: 32 } }],
+    ["gdouble", { ts: "number", ffi: { type: "float", size: 64 } }],
+    ["gsize", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["gssize", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
+    ["goffset", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
+    ["int", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
+    ["unsigned int", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
+    ["long", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
+    ["unsigned long", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["double", { ts: "number", ffi: { type: "float", size: 64 } }],
+    ["float", { ts: "number", ffi: { type: "float", size: 32 } }],
+    ["size_t", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["ssize_t", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
+    ["GType", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["GQuark", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
+]);
+
+const mapCType = (cType: string | undefined): TypeMapping => {
+    if (!cType) {
+        return POINTER_TYPE;
+    }
+
+    if (cType.endsWith("*")) {
+        return POINTER_TYPE;
+    }
+
+    const mapped = C_TYPE_MAP.get(cType);
+    if (mapped) {
+        return mapped;
+    }
+
+    if (cType.startsWith("const ")) {
+        return mapCType(cType.slice(6));
+    }
+
+    return POINTER_TYPE;
+};
+
 const BASIC_TYPE_MAP = new Map<string, TypeMapping>([
     ["gboolean", { ts: "boolean", ffi: { type: "boolean" } }],
     ["gchar", { ts: "number", ffi: { type: "int", size: 8, unsigned: false } }],
@@ -518,16 +614,6 @@ const BASIC_TYPE_MAP = new Map<string, TypeMapping>([
     ["FreeFunc", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
 ]);
 
-const LIBRARY_MAP: Record<string, string> = {
-    Gtk: "libgtk-4.so.1",
-    GObject: "libgobject-2.0.so.0",
-    GLib: "libglib-2.0.so.0",
-    Gio: "libgio-2.0.so.0",
-    GdkPixbuf: "libgdk_pixbuf-2.0.so.0",
-    Pango: "libpango-1.0.so.0",
-    Cairo: "libcairo.so.2",
-};
-
 export interface ExternalTypeUsage {
     namespace: string;
     name: string;
@@ -763,6 +849,9 @@ export class TypeMapper {
                             externalType: isExternal ? externalType : undefined,
                         };
                     }
+                    if (registered.kind === "callback") {
+                        return POINTER_TYPE;
+                    }
                     return {
                         ts: qualifiedName,
                         ffi: { type: "gobject", borrowed: isReturn },
@@ -771,10 +860,7 @@ export class TypeMapper {
                     };
                 }
             }
-            return {
-                ts: "unknown",
-                ffi: { type: "gobject", borrowed: isReturn },
-            };
+            return mapCType(girType.cType);
         }
 
         if (this.typeRegistry && this.currentNamespace) {
@@ -816,6 +902,9 @@ export class TypeMapper {
                         kind: registered.kind,
                     };
                 }
+                if (registered.kind === "callback") {
+                    return POINTER_TYPE;
+                }
                 return {
                     ts: qualifiedName,
                     ffi: { type: "gobject", borrowed: isReturn },
@@ -825,10 +914,17 @@ export class TypeMapper {
             }
         }
 
-        return {
-            ts: "unknown",
-            ffi: { type: "gobject", borrowed: isReturn },
-        };
+        return mapCType(girType.cType);
+    }
+
+    isCallback(typeName: string): boolean {
+        if (this.typeRegistry) {
+            const resolved = this.currentNamespace
+                ? this.typeRegistry.resolveInNamespace(typeName, this.currentNamespace)
+                : this.typeRegistry.resolve(typeName);
+            return resolved?.kind === "callback";
+        }
+        return false;
     }
 
     /**
@@ -881,7 +977,23 @@ export class TypeMapper {
             };
         }
 
-        if (param.type.name === "GLib.Closure" || param.type.name.endsWith("Func")) {
+        if (param.type.name === "Gtk.DrawingAreaDrawFunc" || param.type.name === "DrawingAreaDrawFunc") {
+            return {
+                ts: "(self: unknown, cr: unknown, width: number, height: number) => void",
+                ffi: {
+                    type: "callback",
+                    trampoline: "drawFunc",
+                    argTypes: [
+                        { type: "gobject", borrowed: true },
+                        { type: "int", size: 64, unsigned: true }, // cairo_t* as raw pointer
+                        { type: "int", size: 32, unsigned: false },
+                        { type: "int", size: 32, unsigned: false },
+                    ],
+                },
+            };
+        }
+
+        if (param.type.name === "GLib.Closure" || this.isCallback(param.type.name)) {
             return {
                 ts: "(...args: unknown[]) => unknown",
                 ffi: { type: "callback" },
@@ -892,13 +1004,17 @@ export class TypeMapper {
     }
 
     /**
-     * Checks if a parameter is a closure/user_data target for a GAsyncReadyCallback.
+     * Checks if a parameter is a closure/user_data target or destroy notifier for a callback that uses trampolines.
+     * These parameters are handled automatically by the trampoline mechanism.
      * @param paramIndex - The index of the parameter to check
      * @param allParams - All parameters in the method
-     * @returns True if this parameter is user_data for a GAsyncReadyCallback
+     * @returns True if this parameter is user_data or destroy for a trampoline callback
      */
     isClosureTarget(paramIndex: number, allParams: GirParameter[]): boolean {
-        return allParams.some((p) => p.type.name === "Gio.AsyncReadyCallback" && p.closure === paramIndex);
+        const trampolineCallbacks = ["Gio.AsyncReadyCallback", "Gtk.DrawingAreaDrawFunc", "DrawingAreaDrawFunc"];
+        return allParams.some(
+            (p) => trampolineCallbacks.includes(p.type.name) && (p.closure === paramIndex || p.destroy === paramIndex),
+        );
     }
 
     /**
@@ -909,13 +1025,4 @@ export class TypeMapper {
     isNullable(param: GirParameter): boolean {
         return param.nullable === true || param.optional === true;
     }
-
-    /**
-     * Gets the shared library name for a namespace.
-     * @param namespace - The namespace name
-     * @returns The shared library file name
-     */
-    getLibraryName(namespace: string): string {
-        return LIBRARY_MAP[namespace] ?? `lib${namespace.toLowerCase()}.so`;
-    }
 }