@gtkx/gir 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/gir",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "GObject Introspection file parser for GTKX",
   "keywords": [
     "gtk",
@@ -28,5 +28,8 @@
   },
   "files": [
     "src"
-  ]
+  ],
+  "scripts": {
+    "test": "vitest run"
+  }
 }

package/src/parser.ts

@@ -244,7 +244,15 @@ export class GirParser {
         if (!returnValue) {
             return { name: "void" };
         }
-        return this.parseType((returnValue.type ?? returnValue.array) as Record<string, unknown> | undefined);
+        const type = this.parseType((returnValue.type ?? returnValue.array) as Record<string, unknown> | undefined);
+        const transferOwnership = returnValue["@_transfer-ownership"] as string | undefined;
+        if (transferOwnership === "none" || transferOwnership === "full" || transferOwnership === "container") {
+            type.transferOwnership = transferOwnership;
+        }
+        if (returnValue["@_nullable"] === "1") {
+            type.nullable = true;
+        }
+        return type;
     }
 
     private parseType(typeNode: Record<string, unknown> | undefined): GirType {
@@ -252,9 +260,21 @@ export class GirParser {
             return { name: "void" };
         }
 
-        if (typeNode["@_name"]) {
+        const typeName = typeNode["@_name"] ? String(typeNode["@_name"]) : undefined;
+
+        if (typeName === "GLib.List" || typeName === "GLib.SList") {
+            const innerType = typeNode.type as Record<string, unknown> | undefined;
+            return {
+                name: "array",
+                cType: typeNode["@_c:type"] ? String(typeNode["@_c:type"]) : undefined,
+                isArray: true,
+                elementType: innerType ? this.parseType(innerType) : undefined,
+            };
+        }
+
+        if (typeName) {
             return {
-                name: String(typeNode["@_name"] ?? ""),
+                name: typeName,
                 cType: typeNode["@_c:type"] ? String(typeNode["@_c:type"]) : undefined,
             };
         }

package/src/types.ts

@@ -204,6 +204,10 @@ export interface GirType {
     isArray?: boolean;
     /** The element type for array types. */
     elementType?: GirType;
+    /** Transfer ownership semantics for return types. */
+    transferOwnership?: "none" | "full" | "container";
+    /** Whether this type can be null (for return types). */
+    nullable?: boolean;
 }
 
 /**
@@ -290,9 +294,13 @@ export interface FfiTypeDescriptor {
     innerType?: FfiTypeDescriptor | string;
     /** Item type for array types. */
     itemType?: FfiTypeDescriptor;
-    /** Source type for asyncCallback (the GObject source). */
+    /** 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";
+    /** Source type for asyncReady callback (the GObject source). */
     sourceType?: FfiTypeDescriptor;
-    /** Result type for asyncCallback (the GAsyncResult). */
+    /** Result type for asyncReady callback (the GAsyncResult). */
     resultType?: FfiTypeDescriptor;
 }
 
@@ -448,6 +456,8 @@ export class TypeRegistry {
     }
 }
 
+const STRING_TYPES = new Set(["utf8", "filename"]);
+
 const BASIC_TYPE_MAP = new Map<string, TypeMapping>([
     ["gboolean", { ts: "boolean", ffi: { type: "boolean" } }],
     ["gchar", { ts: "number", ffi: { type: "int", size: 8, unsigned: false } }],
@@ -469,12 +479,29 @@ const BASIC_TYPE_MAP = new Map<string, TypeMapping>([
     ["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 } }],
-    ["utf8", { ts: "string", ffi: { type: "string" } }],
-    ["filename", { ts: "string", ffi: { type: "string" } }],
-    ["gpointer", { ts: "unknown", ffi: { type: "gobject" } }],
-    ["gconstpointer", { ts: "unknown", ffi: { type: "gobject" } }],
+    ["gpointer", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["gconstpointer", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["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 } }],
+    ["guintptr", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["gintptr", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
+    ["pid_t", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
+    ["uid_t", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
+    ["gid_t", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
+    ["time_t", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
     ["Quark", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
     ["GLib.Quark", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
+    ["TimeSpan", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
+    ["GLib.TimeSpan", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
+    ["DateDay", { ts: "number", ffi: { type: "int", size: 8, unsigned: true } }],
+    ["GLib.DateDay", { ts: "number", ffi: { type: "int", size: 8, unsigned: true } }],
+    ["DateYear", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
+    ["GLib.DateYear", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
+    ["DateMonth", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
+    ["GLib.DateMonth", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
+    ["Pid", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
+    ["GLib.Pid", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
     ["void", { ts: "void", ffi: { type: "undefined" } }],
     ["none", { ts: "void", ffi: { type: "undefined" } }],
     ["int", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
@@ -485,6 +512,10 @@ const BASIC_TYPE_MAP = new Map<string, TypeMapping>([
     ["ssize_t", { ts: "number", ffi: { type: "int", size: 64, unsigned: false } }],
     ["double", { ts: "number", ffi: { type: "float", size: 64 } }],
     ["float", { ts: "number", ffi: { type: "float", size: 32 } }],
+    ["GLib.DestroyNotify", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["DestroyNotify", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["GLib.FreeFunc", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
+    ["FreeFunc", { ts: "number", ffi: { type: "int", size: 64, unsigned: true } }],
 ]);
 
 const LIBRARY_MAP: Record<string, string> = {
@@ -509,6 +540,7 @@ export interface MappedType {
     ffi: FfiTypeDescriptor;
     externalType?: ExternalTypeUsage;
     kind?: TypeKind;
+    nullable?: boolean;
 }
 
 /**
@@ -622,16 +654,33 @@ export class TypeMapper {
      */
     mapType(girType: GirType, isReturn = false): MappedType {
         if (girType.isArray || girType.name === "array") {
+            const listType = girType.cType?.includes("GSList")
+                ? "gslist"
+                : girType.cType?.includes("GList")
+                  ? "glist"
+                  : undefined;
             if (girType.elementType) {
                 const elementType = this.mapType(girType.elementType);
                 return {
                     ts: `${elementType.ts}[]`,
-                    ffi: { type: "array", itemType: elementType.ffi },
+                    ffi: listType
+                        ? { type: "array", itemType: elementType.ffi, listType, borrowed: isReturn }
+                        : { type: "array", itemType: elementType.ffi },
                 };
             }
             return {
                 ts: `unknown[]`,
-                ffi: { type: "array", itemType: { type: "undefined" } },
+                ffi: listType
+                    ? { type: "array", itemType: { type: "undefined" }, listType, borrowed: isReturn }
+                    : { type: "array", itemType: { type: "undefined" } },
+            };
+        }
+
+        if (STRING_TYPES.has(girType.name)) {
+            const borrowed = girType.transferOwnership === "none";
+            return {
+                ts: "string",
+                ffi: { type: "string", borrowed },
             };
         }
 
@@ -804,13 +853,34 @@ export class TypeMapper {
             return {
                 ts: "(source: unknown, result: unknown) => void",
                 ffi: {
-                    type: "asyncCallback",
+                    type: "callback",
+                    trampoline: "asyncReady",
                     sourceType: { type: "gobject", borrowed: true },
                     resultType: { type: "gobject", borrowed: true },
                 },
             };
         }
 
+        if (param.type.name === "GLib.DestroyNotify") {
+            return {
+                ts: "() => void",
+                ffi: {
+                    type: "callback",
+                    trampoline: "destroy",
+                },
+            };
+        }
+
+        if (param.type.name === "GLib.SourceFunc") {
+            return {
+                ts: "() => boolean",
+                ffi: {
+                    type: "callback",
+                    trampoline: "sourceFunc",
+                },
+            };
+        }
+
         if (param.type.name === "GLib.Closure" || param.type.name.endsWith("Func")) {
             return {
                 ts: "(...args: unknown[]) => unknown",