@gtkx/gir 0.10.2 → 0.10.4

package/dist/types.d.ts

@@ -281,7 +281,7 @@ export declare const registerEnumsFromNamespace: (typeMapper: TypeMapper, namesp
 /**
  * The kind of a registered type.
  */
-export type TypeKind = "class" | "interface" | "enum" | "record" | "callback";
+export type TypeKind = "class" | "interface" | "enum" | "flags" | "record" | "callback";
 /**
  * A type registered in the type registry.
  *
@@ -349,6 +349,13 @@ export declare class TypeRegistry {
      * @param name - The enum name
      */
     registerEnum(namespace: string, name: string): void;
+    /**
+     * Registers a flags (bitfield) type.
+     *
+     * @param namespace - The GIR namespace
+     * @param name - The flags name
+     */
+    registerFlags(namespace: string, name: string): void;
     /**
      * Registers a record (boxed) type.
      *
@@ -450,6 +457,8 @@ export type MappedType = {
 export declare class TypeMapper {
     private enumNames;
     private enumTransforms;
+    private flagsNames;
+    private flagsTransforms;
     private recordNames;
     private recordTransforms;
     private recordGlibTypes;
@@ -468,6 +477,13 @@ export declare class TypeMapper {
      * @param transformedName - Optional transformed TypeScript name
      */
     registerEnum(originalName: string, transformedName?: string): void;
+    /**
+     * Registers a flags (bitfield) type for type mapping.
+     *
+     * @param originalName - The GIR flags name
+     * @param transformedName - Optional transformed TypeScript name
+     */
+    registerFlags(originalName: string, transformedName?: string): void;
     /**
      * Registers a record for type mapping.
      *
@@ -499,9 +515,10 @@ export declare class TypeMapper {
      *
      * @param girType - The GIR type to map
      * @param isReturn - Whether this is a return type (affects ownership)
+     * @param parentTransferOwnership - Transfer ownership from parent (used for array elements)
      * @returns The mapped type with TypeScript and FFI descriptors
      */
-    mapType(girType: GirType, isReturn?: boolean): MappedType;
+    mapType(girType: GirType, isReturn?: boolean, parentTransferOwnership?: string): MappedType;
     isCallback(typeName: string): boolean;
     /**
      * Maps a function parameter to TypeScript and FFI representations.

package/dist/types.js

@@ -33,7 +33,7 @@ export const registerEnumsFromNamespace = (typeMapper, namespace) => {
         typeMapper.registerEnum(enumeration.name, toPascalCase(enumeration.name));
     }
     for (const bitfield of namespace.bitfields) {
-        typeMapper.registerEnum(bitfield.name, toPascalCase(bitfield.name));
+        typeMapper.registerFlags(bitfield.name, toPascalCase(bitfield.name));
     }
 };
 /**
@@ -95,6 +95,21 @@ export class TypeRegistry {
             transformedName,
         });
     }
+    /**
+     * Registers a flags (bitfield) type.
+     *
+     * @param namespace - The GIR namespace
+     * @param name - The flags name
+     */
+    registerFlags(namespace, name) {
+        const transformedName = toPascalCase(name);
+        this.types.set(`${namespace}.${name}`, {
+            kind: "flags",
+            name,
+            namespace,
+            transformedName,
+        });
+    }
     /**
      * Registers a record (boxed) type.
      *
@@ -197,7 +212,7 @@ export class TypeRegistry {
                 registry.registerEnum(ns.name, enumeration.name);
             }
             for (const bitfield of ns.bitfields) {
-                registry.registerEnum(ns.name, bitfield.name);
+                registry.registerFlags(ns.name, bitfield.name);
             }
             for (const record of ns.records) {
                 if (record.disguised)
@@ -425,6 +440,8 @@ const BASIC_TYPE_MAP = new Map([
 export class TypeMapper {
     enumNames = new Set();
     enumTransforms = new Map();
+    flagsNames = new Set();
+    flagsTransforms = new Map();
     recordNames = new Set();
     recordTransforms = new Map();
     recordGlibTypes = new Map();
@@ -448,6 +465,18 @@ export class TypeMapper {
             this.enumTransforms.set(originalName, transformedName);
         }
     }
+    /**
+     * Registers a flags (bitfield) type for type mapping.
+     *
+     * @param originalName - The GIR flags name
+     * @param transformedName - Optional transformed TypeScript name
+     */
+    registerFlags(originalName, transformedName) {
+        this.flagsNames.add(originalName);
+        if (transformedName) {
+            this.flagsTransforms.set(originalName, transformedName);
+        }
+    }
     /**
      * Registers a record for type mapping.
      *
@@ -512,9 +541,10 @@ export class TypeMapper {
      *
      * @param girType - The GIR type to map
      * @param isReturn - Whether this is a return type (affects ownership)
+     * @param parentTransferOwnership - Transfer ownership from parent (used for array elements)
      * @returns The mapped type with TypeScript and FFI descriptors
      */
-    mapType(girType, isReturn = false) {
+    mapType(girType, isReturn = false, parentTransferOwnership) {
         if (girType.isArray || girType.name === "array") {
             const listType = girType.cType?.includes("GSList")
                 ? "gslist"
@@ -522,7 +552,8 @@ export class TypeMapper {
                     ? "glist"
                     : undefined;
             if (girType.elementType) {
-                const elementType = this.mapType(girType.elementType);
+                const elementTransferOwnership = girType.transferOwnership ?? parentTransferOwnership;
+                const elementType = this.mapType(girType.elementType, isReturn, elementTransferOwnership);
                 return {
                     ts: `${elementType.ts}[]`,
                     ffi: listType
@@ -538,7 +569,8 @@ export class TypeMapper {
             };
         }
         if (STRING_TYPES.has(girType.name)) {
-            const borrowed = girType.transferOwnership === "none";
+            const effectiveTransferOwnership = girType.transferOwnership ?? parentTransferOwnership;
+            const borrowed = effectiveTransferOwnership === "none";
             return {
                 ts: "string",
                 ffi: { type: "string", borrowed },
@@ -576,7 +608,7 @@ export class TypeMapper {
                     }
                     this.onSameNamespaceClassUsed?.(registered.transformedName, registered.name);
                 }
-                else if (registered.kind === "enum") {
+                else if (registered.kind === "enum" || registered.kind === "flags") {
                     this.onEnumUsed?.(registered.transformedName);
                 }
                 else if (registered.kind === "record") {
@@ -589,6 +621,13 @@ export class TypeMapper {
                         externalType,
                     };
                 }
+                if (registered.kind === "flags") {
+                    return {
+                        ts: qualifiedName,
+                        ffi: { type: "int", size: 32, unsigned: true },
+                        externalType,
+                    };
+                }
                 if (registered.kind === "record") {
                     if (registered.name === "Variant" && registered.namespace === "GLib") {
                         return {
@@ -651,6 +690,14 @@ export class TypeMapper {
                 ffi: { type: "int", size: 32, unsigned: false },
             };
         }
+        if (this.flagsNames.has(girType.name)) {
+            const transformedName = this.flagsTransforms.get(girType.name) ?? girType.name;
+            this.onEnumUsed?.(transformedName);
+            return {
+                ts: transformedName,
+                ffi: { type: "int", size: 32, unsigned: true },
+            };
+        }
         if (this.recordNames.has(girType.name)) {
             const transformedName = this.recordTransforms.get(girType.name) ?? girType.name;
             const glibTypeName = this.recordGlibTypes.get(girType.name) ?? transformedName;
@@ -671,6 +718,14 @@ export class TypeMapper {
                         ffi: { type: "int", size: 32, unsigned: false },
                     };
                 }
+                if (this.flagsNames.has(typeName)) {
+                    const transformedName = this.flagsTransforms.get(typeName) ?? typeName;
+                    this.onEnumUsed?.(transformedName);
+                    return {
+                        ts: transformedName,
+                        ffi: { type: "int", size: 32, unsigned: true },
+                    };
+                }
                 if (this.recordNames.has(typeName)) {
                     const transformedName = this.recordTransforms.get(typeName) ?? typeName;
                     const glibTypeName = this.recordGlibTypes.get(typeName) ?? transformedName;
@@ -705,6 +760,13 @@ export class TypeMapper {
                             externalType: isExternal ? externalType : undefined,
                         };
                     }
+                    if (registered.kind === "flags") {
+                        return {
+                            ts: qualifiedName,
+                            ffi: { type: "int", size: 32, unsigned: true },
+                            externalType: isExternal ? externalType : undefined,
+                        };
+                    }
                     if (registered.kind === "record") {
                         if (registered.name === "Variant" && registered.namespace === "GLib") {
                             return {
@@ -794,6 +856,13 @@ export class TypeMapper {
                         externalType,
                     };
                 }
+                if (registered.kind === "flags") {
+                    return {
+                        ts: qualifiedName,
+                        ffi: { type: "int", size: 32, unsigned: true },
+                        externalType,
+                    };
+                }
                 if (registered.kind === "record") {
                     if (registered.isPlainStruct) {
                         return {
@@ -991,7 +1060,7 @@ export class TypeMapper {
                 ffi: { type: "callback" },
             };
         }
-        const mapped = this.mapType(param.type);
+        const mapped = this.mapType(param.type, false, param.transferOwnership);
         const isObjectType = mapped.ffi.type === "gobject" || mapped.ffi.type === "boxed";
         const isTransferFull = param.transferOwnership === "full";
         const isTransferNone = param.transferOwnership === "none" || param.transferOwnership === undefined;

package/package.json

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