@gtkx/gir 0.4.0 → 0.4.3

package/package.json

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

package/src/parser.ts

@@ -248,10 +248,12 @@ export class GirParser {
             const closure = param["@_closure"] as string | undefined;
             const destroy = param["@_destroy"] as string | undefined;
             const transferOwnership = param["@_transfer-ownership"] as string | undefined;
+            const callerAllocates = param["@_caller-allocates"] as string | undefined;
             return {
                 name: String(param["@_name"] ?? ""),
                 type: this.parseType((param.type ?? param.array) as Record<string, unknown> | undefined),
                 direction: (String(param["@_direction"] ?? "in") as "in" | "out" | "inout") || "in",
+                callerAllocates: callerAllocates === "1",
                 nullable: param["@_nullable"] === "1",
                 optional: param["@_allow-none"] === "1",
                 scope: scope as "async" | "call" | "notified" | undefined,

package/src/types.ts

@@ -208,6 +208,8 @@ export interface GirParameter {
     type: GirType;
     /** The parameter direction (in, out, or inout). */
     direction?: "in" | "out" | "inout";
+    /** Whether the caller allocates memory for out parameters. */
+    callerAllocates?: boolean;
     /** Whether this parameter can be null. */
     nullable?: boolean;
     /** Whether this parameter is optional. */
@@ -766,6 +768,14 @@ export class TypeMapper {
         this.onExternalTypeUsed = callback ?? undefined;
     }
 
+    /**
+     * Gets the current external type usage callback.
+     * @returns The callback or null if not set
+     */
+    getExternalTypeUsageCallback(): ((usage: ExternalTypeUsage) => void) | null {
+        return this.onExternalTypeUsed ?? null;
+    }
+
     /**
      * Sets a callback to track same-namespace class/interface usage during type mapping.
      * @param callback - Called when a same-namespace class is used, or null to clear
@@ -774,6 +784,14 @@ export class TypeMapper {
         this.onSameNamespaceClassUsed = callback ?? undefined;
     }
 
+    /**
+     * Gets the current same-namespace class usage callback.
+     * @returns The callback or null if not set
+     */
+    getSameNamespaceClassUsageCallback(): ((className: string, originalName: string) => void) | null {
+        return this.onSameNamespaceClassUsed ?? null;
+    }
+
     /**
      * Sets the type registry for cross-namespace type resolution.
      * @param registry - The TypeRegistry instance
@@ -992,38 +1010,37 @@ export class TypeMapper {
      */
     mapParameter(param: GirParameter): MappedType {
         if (param.direction === "out" || param.direction === "inout") {
-            // Temporarily disable callbacks while mapping the inner type,
-            // since Ref<unknown> doesn't need the type import
-            const savedRecordCallback = this.onRecordUsed;
-            const savedExternalCallback = this.onExternalTypeUsed;
-            const savedClassCallback = this.onSameNamespaceClassUsed;
-            this.onRecordUsed = undefined;
-            this.onExternalTypeUsed = undefined;
-            this.onSameNamespaceClassUsed = undefined;
-
             const innerType = this.mapType(param.type);
-
-            // Restore callbacks
-            this.onRecordUsed = savedRecordCallback;
-            this.onExternalTypeUsed = savedExternalCallback;
-            this.onSameNamespaceClassUsed = savedClassCallback;
-
-            // For boxed/gobject types, Ref wraps the raw ptr (unknown), not the wrapper class
             const isBoxedOrGObject = innerType.ffi.type === "boxed" || innerType.ffi.type === "gobject";
-            const tsType = isBoxedOrGObject ? "unknown" : innerType.ts;
 
-            // Only trigger callbacks for non-boxed/gobject types that will actually appear in TS
+            if (param.callerAllocates && isBoxedOrGObject) {
+                return {
+                    ...innerType,
+                    ffi: {
+                        ...innerType.ffi,
+                        borrowed: true,
+                    },
+                };
+            }
+
             if (!isBoxedOrGObject) {
-                // Re-map with callbacks enabled to register the type usage
-                this.mapType(param.type);
+                return {
+                    ts: `Ref<${innerType.ts}>`,
+                    ffi: {
+                        type: "ref",
+                        innerType: innerType.ffi,
+                    },
+                };
             }
 
             return {
-                ts: `Ref<${tsType}>`,
+                ts: `Ref<${innerType.ts}>`,
                 ffi: {
                     type: "ref",
                     innerType: innerType.ffi,
                 },
+                externalType: innerType.externalType,
+                kind: innerType.kind,
             };
         }