@gtkx/gir 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/gir",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "GObject Introspection file parser for GTKX",
   "license": "MPL-2.0",
   "author": "Eugenio Depalo <eugeniodepalo@gmail.com>",

package/src/parser.ts

@@ -4,12 +4,14 @@ import type {
     GirConstructor,
     GirEnumeration,
     GirEnumerationMember,
+    GirField,
     GirFunction,
     GirInterface,
     GirMethod,
     GirNamespace,
     GirParameter,
     GirProperty,
+    GirRecord,
     GirSignal,
     GirType,
 } from "./types.js";
@@ -20,6 +22,7 @@ const ARRAY_ELEMENT_PATHS = new Set<string>([
     "namespace.function",
     "namespace.enumeration",
     "namespace.bitfield",
+    "namespace.record",
     "namespace.class.method",
     "namespace.class.constructor",
     "namespace.class.function",
@@ -30,6 +33,10 @@ const ARRAY_ELEMENT_PATHS = new Set<string>([
     "namespace.interface.property",
     "namespace.interface.signal",
     "namespace.interface.glib:signal",
+    "namespace.record.method",
+    "namespace.record.constructor",
+    "namespace.record.function",
+    "namespace.record.field",
     "namespace.class.method.parameters.parameter",
     "namespace.class.constructor.parameters.parameter",
     "namespace.class.function.parameters.parameter",
@@ -39,6 +46,9 @@ const ARRAY_ELEMENT_PATHS = new Set<string>([
     "namespace.interface.method.parameters.parameter",
     "namespace.class.glib:signal.parameters.parameter",
     "namespace.interface.glib:signal.parameters.parameter",
+    "namespace.record.method.parameters.parameter",
+    "namespace.record.constructor.parameters.parameter",
+    "namespace.record.function.parameters.parameter",
 ]);
 
 const extractDoc = (node: Record<string, unknown>): string | undefined => {
@@ -94,6 +104,7 @@ export class GirParser {
             functions: this.parseFunctions(namespace.function ?? []),
             enumerations: this.parseEnumerations(namespace.enumeration ?? []),
             bitfields: this.parseEnumerations(namespace.bitfield ?? []),
+            records: this.parseRecords(namespace.record ?? []),
         };
     }
 
@@ -290,6 +301,48 @@ export class GirParser {
         });
     }
 
+    private parseRecords(records: Record<string, unknown>[]): GirRecord[] {
+        if (!records || !Array.isArray(records)) {
+            return [];
+        }
+        return records.map((record) => ({
+            name: String(record["@_name"] ?? ""),
+            cType: String(record["@_c:type"] ?? record["@_glib:type-name"] ?? ""),
+            opaque: record["@_opaque"] === "1",
+            disguised: record["@_disguised"] === "1",
+            glibTypeName: record["@_glib:type-name"] ? String(record["@_glib:type-name"]) : undefined,
+            glibGetType: record["@_glib:get-type"] ? String(record["@_glib:get-type"]) : undefined,
+            fields: this.parseFields(Array.isArray(record.field) ? (record.field as Record<string, unknown>[]) : []),
+            methods: this.parseMethods(Array.isArray(record.method) ? (record.method as Record<string, unknown>[]) : []),
+            constructors: this.parseConstructors(
+                Array.isArray(record.constructor) ? (record.constructor as Record<string, unknown>[]) : [],
+            ),
+            functions: this.parseFunctions(
+                Array.isArray(record.function) ? (record.function as Record<string, unknown>[]) : [],
+            ),
+            doc: extractDoc(record),
+        }));
+    }
+
+    private parseFields(fields: Record<string, unknown>[]): GirField[] {
+        if (!fields || !Array.isArray(fields)) {
+            return [];
+        }
+        return fields
+            .filter((field) => {
+                const hasCallback = field.callback !== undefined;
+                return !hasCallback;
+            })
+            .map((field) => ({
+                name: String(field["@_name"] ?? ""),
+                type: this.parseType((field.type ?? field.array) as Record<string, unknown> | undefined),
+                writable: field["@_writable"] === "1",
+                readable: field["@_readable"] !== "0",
+                private: field["@_private"] === "1",
+                doc: extractDoc(field),
+            }));
+    }
+
     private parseEnumerations(enumerations: Record<string, unknown>[]): GirEnumeration[] {
         if (!enumerations || !Array.isArray(enumerations)) {
             return [];

package/src/types.ts

@@ -20,6 +20,8 @@ export interface GirNamespace {
     enumerations: GirEnumeration[];
     /** All bitfield enumerations defined in this namespace. */
     bitfields: GirEnumeration[];
+    /** All records (structs) defined in this namespace. */
+    records: GirRecord[];
     /** Documentation for the namespace. */
     doc?: string;
 }
@@ -70,6 +72,52 @@ export interface GirClass {
     doc?: string;
 }
 
+/**
+ * Represents a GIR record (struct) definition.
+ */
+export interface GirRecord {
+    /** The record name. */
+    name: string;
+    /** The C type name. */
+    cType: string;
+    /** Whether this record is opaque (no field access). */
+    opaque?: boolean;
+    /** Whether this record is disguised (typically internal). */
+    disguised?: boolean;
+    /** The GLib type name for boxed types. */
+    glibTypeName?: string;
+    /** The GLib get-type function. */
+    glibGetType?: string;
+    /** Fields defined in this record. */
+    fields: GirField[];
+    /** Methods defined on this record. */
+    methods: GirMethod[];
+    /** Constructor functions for this record. */
+    constructors: GirConstructor[];
+    /** Static functions defined on this record. */
+    functions: GirFunction[];
+    /** Documentation for the record. */
+    doc?: string;
+}
+
+/**
+ * Represents a GIR field definition in a record.
+ */
+export interface GirField {
+    /** The field name. */
+    name: string;
+    /** The field type. */
+    type: GirType;
+    /** Whether this field is writable. */
+    writable?: boolean;
+    /** Whether this field is readable. */
+    readable?: boolean;
+    /** Whether this field is private. */
+    private?: boolean;
+    /** Documentation for the field. */
+    doc?: string;
+}
+
 /**
  * Represents a GIR method definition.
  */
@@ -230,8 +278,8 @@ export interface FfiTypeDescriptor {
     unsigned?: boolean;
     /** Whether the pointer is borrowed (not owned). */
     borrowed?: boolean;
-    /** Inner type for ref types. */
-    innerType?: FfiTypeDescriptor;
+    /** Inner type for ref types (as descriptor) or boxed types (as GLib type name string). */
+    innerType?: FfiTypeDescriptor | string;
     /** Item type for array types. */
     itemType?: FfiTypeDescriptor;
 }
@@ -307,6 +355,8 @@ const BASIC_TYPE_MAP = new Map<string, TypeMapping>([
     ["filename", { ts: "string", ffi: { type: "string" } }],
     ["gpointer", { ts: "unknown", ffi: { type: "gobject" } }],
     ["gconstpointer", { ts: "unknown", ffi: { type: "gobject" } }],
+    ["Quark", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
+    ["GLib.Quark", { ts: "number", ffi: { type: "int", size: 32, unsigned: true } }],
     ["void", { ts: "void", ffi: { type: "undefined" } }],
     ["none", { ts: "void", ffi: { type: "undefined" } }],
     ["int", { ts: "number", ffi: { type: "int", size: 32, unsigned: false } }],
@@ -331,12 +381,16 @@ const LIBRARY_MAP: Record<string, string> = {
 
 /**
  * Maps GIR types to TypeScript types and FFI type descriptors.
- * Handles basic types, enumerations, arrays, and object references.
+ * Handles basic types, enumerations, records, arrays, and object references.
  */
 export class TypeMapper {
     private enumNames: Set<string> = new Set();
     private enumTransforms: Map<string, string> = new Map();
+    private recordNames: Set<string> = new Set();
+    private recordTransforms: Map<string, string> = new Map();
+    private recordGlibTypes: Map<string, string> = new Map();
     private onEnumUsed?: (enumName: string) => void;
+    private onRecordUsed?: (recordName: string) => void;
 
     /**
      * Registers an enumeration type for mapping.
@@ -350,6 +404,22 @@ export class TypeMapper {
         }
     }
 
+    /**
+     * Registers a record type for mapping.
+     * @param originalName - The original GIR record name
+     * @param transformedName - The transformed TypeScript class name
+     * @param glibTypeName - The GLib type name for boxed type handling
+     */
+    registerRecord(originalName: string, transformedName?: string, glibTypeName?: string): void {
+        this.recordNames.add(originalName);
+        if (transformedName) {
+            this.recordTransforms.set(originalName, transformedName);
+        }
+        if (glibTypeName) {
+            this.recordGlibTypes.set(originalName, glibTypeName);
+        }
+    }
+
     /**
      * Sets a callback to track enum usage during type mapping.
      * @param callback - Called when an enum is used, or null to clear
@@ -366,6 +436,22 @@ export class TypeMapper {
         return this.onEnumUsed ?? null;
     }
 
+    /**
+     * Sets a callback to track record usage during type mapping.
+     * @param callback - Called when a record is used, or null to clear
+     */
+    setRecordUsageCallback(callback: ((recordName: string) => void) | null): void {
+        this.onRecordUsed = callback ?? undefined;
+    }
+
+    /**
+     * Gets the current record usage callback.
+     * @returns The callback or null if not set
+     */
+    getRecordUsageCallback(): ((recordName: string) => void) | null {
+        return this.onRecordUsed ?? null;
+    }
+
     /**
      * Maps a GIR type to TypeScript and FFI type descriptors.
      * @param girType - The GIR type to map
@@ -401,6 +487,16 @@ export class TypeMapper {
             };
         }
 
+        if (this.recordNames.has(girType.name)) {
+            const transformedName = this.recordTransforms.get(girType.name) ?? girType.name;
+            const glibTypeName = this.recordGlibTypes.get(girType.name) ?? transformedName;
+            this.onRecordUsed?.(transformedName);
+            return {
+                ts: transformedName,
+                ffi: { type: "boxed", borrowed: isReturn, innerType: glibTypeName },
+            };
+        }
+
         if (girType.name.includes(".")) {
             const [_ns, typeName] = girType.name.split(".", 2);
             if (typeName && this.enumNames.has(typeName)) {
@@ -411,6 +507,15 @@ export class TypeMapper {
                     ffi: { type: "int", size: 32, unsigned: false },
                 };
             }
+            if (typeName && this.recordNames.has(typeName)) {
+                const transformedName = this.recordTransforms.get(typeName) ?? typeName;
+                const glibTypeName = this.recordGlibTypes.get(typeName) ?? transformedName;
+                this.onRecordUsed?.(transformedName);
+                return {
+                    ts: transformedName,
+                    ffi: { type: "boxed", borrowed: isReturn, innerType: glibTypeName },
+                };
+            }
             return {
                 ts: "unknown",
                 ffi: { type: "gobject", borrowed: isReturn },