@gtkx/gir 0.8.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/gir",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "GObject Introspection file parser for GTKX",
   "keywords": [
     "gtk",
@@ -29,6 +29,9 @@
   "files": [
     "src"
   ],
+  "dependencies": {
+    "fast-xml-parser": "^5.3.3"
+  },
   "scripts": {
     "test": "vitest run"
   }

package/src/parser.ts

@@ -186,18 +186,22 @@ export class GirParser {
         }
         return methods
             .filter((method) => method["@_introspectable"] !== "0")
-            .map((method) => ({
-                name: String(method["@_name"] ?? ""),
-                cIdentifier: String(method["@_c:identifier"] ?? ""),
-                returnType: this.parseReturnType(method["return-value"] as Record<string, unknown> | undefined),
-                parameters: this.parseParameters(
-                    (method.parameters && typeof method.parameters === "object" && method.parameters !== null
-                        ? method.parameters
-                        : {}) as Record<string, unknown>,
-                ),
-                throws: method["@_throws"] === "1",
-                doc: extractDoc(method),
-            }));
+            .map((method) => {
+                const returnValue = method["return-value"] as Record<string, unknown> | undefined;
+                return {
+                    name: String(method["@_name"] ?? ""),
+                    cIdentifier: String(method["@_c:identifier"] ?? ""),
+                    returnType: this.parseReturnType(returnValue),
+                    parameters: this.parseParameters(
+                        (method.parameters && typeof method.parameters === "object" && method.parameters !== null
+                            ? method.parameters
+                            : {}) as Record<string, unknown>,
+                    ),
+                    throws: method["@_throws"] === "1",
+                    doc: extractDoc(method),
+                    returnDoc: returnValue ? extractDoc(returnValue) : undefined,
+                };
+            });
     }
 
     private parseConstructors(constructors: Record<string, unknown>[]): GirConstructor[] {
@@ -206,18 +210,22 @@ export class GirParser {
         }
         return constructors
             .filter((ctor) => ctor["@_introspectable"] !== "0")
-            .map((ctor) => ({
-                name: String(ctor["@_name"] ?? ""),
-                cIdentifier: String(ctor["@_c:identifier"] ?? ""),
-                returnType: this.parseReturnType(ctor["return-value"] as Record<string, unknown> | undefined),
-                parameters: this.parseParameters(
-                    (ctor.parameters && typeof ctor.parameters === "object" && ctor.parameters !== null
-                        ? ctor.parameters
-                        : {}) as Record<string, unknown>,
-                ),
-                throws: ctor["@_throws"] === "1",
-                doc: extractDoc(ctor),
-            }));
+            .map((ctor) => {
+                const returnValue = ctor["return-value"] as Record<string, unknown> | undefined;
+                return {
+                    name: String(ctor["@_name"] ?? ""),
+                    cIdentifier: String(ctor["@_c:identifier"] ?? ""),
+                    returnType: this.parseReturnType(returnValue),
+                    parameters: this.parseParameters(
+                        (ctor.parameters && typeof ctor.parameters === "object" && ctor.parameters !== null
+                            ? ctor.parameters
+                            : {}) as Record<string, unknown>,
+                    ),
+                    throws: ctor["@_throws"] === "1",
+                    doc: extractDoc(ctor),
+                    returnDoc: returnValue ? extractDoc(returnValue) : undefined,
+                };
+            });
     }
 
     private parseFunctions(functions: Record<string, unknown>[]): GirFunction[] {
@@ -226,18 +234,22 @@ export class GirParser {
         }
         return functions
             .filter((func) => func["@_introspectable"] !== "0")
-            .map((func) => ({
-                name: String(func["@_name"] ?? ""),
-                cIdentifier: String(func["@_c:identifier"] ?? ""),
-                returnType: this.parseReturnType(func["return-value"] as Record<string, unknown> | undefined),
-                parameters: this.parseParameters(
-                    (func.parameters && typeof func.parameters === "object" && func.parameters !== null
-                        ? func.parameters
-                        : {}) as Record<string, unknown>,
-                ),
-                throws: func["@_throws"] === "1",
-                doc: extractDoc(func),
-            }));
+            .map((func) => {
+                const returnValue = func["return-value"] as Record<string, unknown> | undefined;
+                return {
+                    name: String(func["@_name"] ?? ""),
+                    cIdentifier: String(func["@_c:identifier"] ?? ""),
+                    returnType: this.parseReturnType(returnValue),
+                    parameters: this.parseParameters(
+                        (func.parameters && typeof func.parameters === "object" && func.parameters !== null
+                            ? func.parameters
+                            : {}) as Record<string, unknown>,
+                    ),
+                    throws: func["@_throws"] === "1",
+                    doc: extractDoc(func),
+                    returnDoc: returnValue ? extractDoc(returnValue) : undefined,
+                };
+            });
     }
 
     private parseParameters(parametersNode: Record<string, unknown>): GirParameter[] {

package/src/types.ts

@@ -178,6 +178,8 @@ export type GirMethod = {
     throws?: boolean;
     /** Documentation for the method. */
     doc?: string;
+    /** Documentation for the return value. */
+    returnDoc?: string;
 };
 
 /**
@@ -196,6 +198,8 @@ export type GirConstructor = {
     throws?: boolean;
     /** Documentation for the constructor. */
     doc?: string;
+    /** Documentation for the return value. */
+    returnDoc?: string;
 };
 
 /**
@@ -214,6 +218,8 @@ export type GirFunction = {
     throws?: boolean;
     /** Documentation for the function. */
     doc?: string;
+    /** Documentation for the return value. */
+    returnDoc?: string;
 };
 
 /**
@@ -344,12 +350,16 @@ export type FfiTypeDescriptor = {
     borrowed?: boolean;
     /** Inner type for ref types (as descriptor) or boxed types (as GLib type name string). */
     innerType?: FfiTypeDescriptor | string;
+    /** Library name for boxed types that need dynamic type lookup. */
+    lib?: string;
+    /** Explicit get_type function name for boxed types (when naive transformation doesn't work). */
+    getTypeFn?: string;
     /** Item type for array types. */
     itemType?: FfiTypeDescriptor;
     /** List type for arrays (glist, gslist) - indicates native GList/GSList iteration. */
     listType?: "glist" | "gslist";
-    /** Trampoline type for callbacks (asyncReady, destroy, sourceFunc, drawFunc, compareDataFunc, tickFunc). Default is "closure". */
-    trampoline?: "asyncReady" | "destroy" | "sourceFunc" | "drawFunc" | "compareDataFunc" | "tickFunc";
+    /** Trampoline type for callbacks. Default is "closure". */
+    trampoline?: "asyncReady" | "destroy" | "drawFunc" | "scaleFormatValueFunc";
     /** Source type for asyncReady callback (the GObject source). */
     sourceType?: FfiTypeDescriptor;
     /** Result type for asyncReady callback (the GAsyncResult). */
@@ -441,7 +451,7 @@ export class TypeRegistry {
      * @param namespace - The namespace containing the class
      * @param name - The class name
      */
-    registerType(namespace: string, name: string): void {
+    registerNativeClass(namespace: string, name: string): void {
         const transformedName = normalizeTypeName(name, namespace);
         this.types.set(`${namespace}.${name}`, {
             kind: "class",
@@ -557,7 +567,7 @@ export class TypeRegistry {
         const registry = new TypeRegistry();
         for (const ns of namespaces) {
             for (const cls of ns.classes) {
-                registry.registerType(ns.name, cls.name);
+                registry.registerNativeClass(ns.name, cls.name);
             }
             for (const iface of ns.interfaces) {
                 registry.registerInterface(ns.name, iface.name);
@@ -727,6 +737,7 @@ export class TypeMapper {
     private recordNames: Set<string> = new Set();
     private recordTransforms: Map<string, string> = new Map();
     private recordGlibTypes: Map<string, string> = new Map();
+    private skippedClasses: Set<string> = new Set();
     private onEnumUsed?: (enumName: string) => void;
     private onRecordUsed?: (recordName: string) => void;
     private onExternalTypeUsed?: (usage: ExternalTypeUsage) => void;
@@ -836,6 +847,14 @@ export class TypeMapper {
         this.currentNamespace = currentNamespace;
     }
 
+    registerSkippedClass(name: string): void {
+        this.skippedClasses.add(name);
+    }
+
+    clearSkippedClasses(): void {
+        this.skippedClasses.clear();
+    }
+
     /**
      * Maps a GIR type to TypeScript and FFI type descriptors.
      * @param girType - The GIR type to map
@@ -897,6 +916,12 @@ export class TypeMapper {
                 if (isExternal) {
                     this.onExternalTypeUsed?.(externalType as ExternalTypeUsage);
                 } else if (registered.kind === "class" || registered.kind === "interface") {
+                    if (this.skippedClasses.has(registered.name)) {
+                        return {
+                            ts: "unknown",
+                            ffi: { type: "gobject", borrowed: isReturn },
+                        };
+                    }
                     this.onSameNamespaceClassUsed?.(registered.transformedName, registered.name);
                 } else if (registered.kind === "enum") {
                     this.onEnumUsed?.(registered.transformedName);
@@ -1044,6 +1069,12 @@ export class TypeMapper {
                 if (isExternal) {
                     this.onExternalTypeUsed?.(externalType as ExternalTypeUsage);
                 } else if (registered.kind === "class" || registered.kind === "interface") {
+                    if (this.skippedClasses.has(registered.name)) {
+                        return {
+                            ts: "unknown",
+                            ffi: { type: "gobject", borrowed: isReturn },
+                        };
+                    }
                     this.onSameNamespaceClassUsed?.(registered.transformedName, registered.name);
                 }
                 if (registered.kind === "enum") {
@@ -1159,25 +1190,28 @@ export class TypeMapper {
             };
         }
 
-        if (param.type.name === "GLib.SourceFunc" || param.type.name === "SourceFunc") {
-            return {
-                ts: "() => boolean",
-                ffi: {
-                    type: "callback",
-                    trampoline: "sourceFunc",
-                },
-            };
-        }
-
         if (param.type.name === "Gtk.DrawingAreaDrawFunc" || param.type.name === "DrawingAreaDrawFunc") {
+            this.onExternalTypeUsed?.({
+                namespace: "Cairo",
+                name: "Context",
+                transformedName: "Context",
+                kind: "record",
+            });
+            this.onSameNamespaceClassUsed?.("DrawingArea", "DrawingArea");
             return {
-                ts: "(self: unknown, cr: unknown, width: number, height: number) => void",
+                ts: "(self: DrawingArea, cr: Cairo.Context, width: number, height: number) => void",
                 ffi: {
                     type: "callback",
                     trampoline: "drawFunc",
                     argTypes: [
                         { type: "gobject", borrowed: true },
-                        { type: "int", size: 64, unsigned: true },
+                        {
+                            type: "boxed",
+                            borrowed: true,
+                            innerType: "CairoContext",
+                            lib: "libcairo-gobject.so.2",
+                            getTypeFn: "cairo_gobject_context_get_type",
+                        },
                         { type: "int", size: 32, unsigned: false },
                         { type: "int", size: 32, unsigned: false },
                     ],
@@ -1185,34 +1219,6 @@ export class TypeMapper {
             };
         }
 
-        if (param.type.name === "GLib.CompareDataFunc" || param.type.name === "CompareDataFunc") {
-            return {
-                ts: "(a: unknown, b: unknown) => number",
-                ffi: {
-                    type: "callback",
-                    trampoline: "compareDataFunc",
-                    argTypes: [
-                        { type: "gobject", borrowed: true },
-                        { type: "gobject", borrowed: true },
-                    ],
-                },
-            };
-        }
-
-        if (param.type.name === "Gtk.TickCallback" || param.type.name === "TickCallback") {
-            return {
-                ts: "(widget: unknown, frameClock: unknown) => boolean",
-                ffi: {
-                    type: "callback",
-                    trampoline: "tickFunc",
-                    argTypes: [
-                        { type: "gobject", borrowed: true },
-                        { type: "gobject", borrowed: true },
-                    ],
-                },
-            };
-        }
-
         if (param.type.name === "GLib.Closure" || this.isCallback(param.type.name)) {
             return {
                 ts: "(...args: unknown[]) => unknown",
@@ -1278,4 +1284,20 @@ export class TypeMapper {
     isNullable(param: GirParameter): boolean {
         return param.nullable === true || param.optional === true;
     }
+
+    hasUnsupportedCallback(param: GirParameter): boolean {
+        const supportedCallbacks = [
+            "Gio.AsyncReadyCallback",
+            "GLib.DestroyNotify",
+            "DestroyNotify",
+            "Gtk.DrawingAreaDrawFunc",
+            "DrawingAreaDrawFunc",
+        ];
+
+        if (supportedCallbacks.includes(param.type.name)) {
+            return false;
+        }
+
+        return param.type.name === "GLib.Closure" || this.isCallback(param.type.name);
+    }
 }