@gtkx/gir 0.5.2 → 0.6.0

package/package.json

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

package/src/parser.ts

@@ -57,8 +57,9 @@ const ARRAY_ELEMENT_PATHS = new Set<string>([
 const extractDoc = (node: Record<string, unknown>): string | undefined => {
     const doc = node.doc as Record<string, unknown> | undefined;
     if (!doc) return undefined;
-    const text = doc["#text"] as string | undefined;
-    return text?.trim();
+    const text = doc["#text"];
+    if (typeof text !== "string") return undefined;
+    return text.trim();
 };
 
 const ensureArray = (value: unknown): Record<string, unknown>[] =>

package/src/types.ts

@@ -398,14 +398,17 @@ export interface RegisteredType {
     glibTypeName?: string;
 }
 
-const CLASS_RENAMES = new Map<string, string>([
-    ["Error", "GError"],
-    ["Object", "GObject"],
-]);
+const CLASS_RENAMES = new Map<string, string>([["Error", "GError"]]);
 
-const normalizeTypeName = (name: string): string => {
+const normalizeTypeName = (name: string, namespace: string): string => {
     const pascalName = toPascalCase(name);
-    return CLASS_RENAMES.get(pascalName) ?? pascalName;
+    if (CLASS_RENAMES.has(pascalName)) {
+        return CLASS_RENAMES.get(pascalName) as string;
+    }
+    if (pascalName === "Object") {
+        return namespace === "GObject" ? "GObject" : `${namespace}Object`;
+    }
+    return pascalName;
 };
 
 /**
@@ -421,7 +424,7 @@ export class TypeRegistry {
      * @param name - The class name
      */
     registerType(namespace: string, name: string): void {
-        const transformedName = normalizeTypeName(name);
+        const transformedName = normalizeTypeName(name, namespace);
         this.types.set(`${namespace}.${name}`, {
             kind: "class",
             name,
@@ -436,7 +439,7 @@ export class TypeRegistry {
      * @param name - The interface name
      */
     registerInterface(namespace: string, name: string): void {
-        const transformedName = normalizeTypeName(name);
+        const transformedName = normalizeTypeName(name, namespace);
         this.types.set(`${namespace}.${name}`, {
             kind: "class",
             name,
@@ -467,7 +470,7 @@ export class TypeRegistry {
      * @param glibTypeName - Optional GLib type name for boxed type handling
      */
     registerRecord(namespace: string, name: string, glibTypeName?: string): void {
-        const transformedName = normalizeTypeName(name);
+        const transformedName = normalizeTypeName(name, namespace);
         this.types.set(`${namespace}.${name}`, {
             kind: "record",
             name,
@@ -503,15 +506,28 @@ export class TypeRegistry {
 
     /**
      * Resolves a type name within a namespace context.
+     * First tries the current namespace, then searches all namespaces.
      * @param name - The type name (may or may not be qualified)
-     * @param currentNamespace - The namespace to use if name is not qualified
+     * @param currentNamespace - The namespace to try first if name is not qualified
      * @returns The registered type or undefined if not found
      */
     resolveInNamespace(name: string, currentNamespace: string): RegisteredType | undefined {
         if (name.includes(".")) {
             return this.resolve(name);
         }
-        return this.resolve(`${currentNamespace}.${name}`);
+
+        const inCurrent = this.resolve(`${currentNamespace}.${name}`);
+        if (inCurrent) {
+            return inCurrent;
+        }
+
+        for (const type of this.types.values()) {
+            if (type.name === name || type.transformedName === name) {
+                return type;
+            }
+        }
+
+        return undefined;
     }
 
     /**
@@ -845,6 +861,65 @@ export class TypeMapper {
             return basicType;
         }
 
+        if (this.typeRegistry && this.currentNamespace && !girType.name.includes(".")) {
+            const registered = this.typeRegistry.resolveInNamespace(girType.name, this.currentNamespace);
+            if (registered) {
+                const isExternal = registered.namespace !== this.currentNamespace;
+                const qualifiedName = isExternal
+                    ? `${registered.namespace}.${registered.transformedName}`
+                    : registered.transformedName;
+                const externalType: ExternalTypeUsage | undefined = isExternal
+                    ? {
+                          namespace: registered.namespace,
+                          name: registered.name,
+                          transformedName: registered.transformedName,
+                          kind: registered.kind,
+                      }
+                    : undefined;
+                if (isExternal) {
+                    this.onExternalTypeUsed?.(externalType as ExternalTypeUsage);
+                } else if (registered.kind === "class" || registered.kind === "interface") {
+                    this.onSameNamespaceClassUsed?.(registered.transformedName, registered.name);
+                } else if (registered.kind === "enum") {
+                    this.onEnumUsed?.(registered.transformedName);
+                } else if (registered.kind === "record") {
+                    this.onRecordUsed?.(registered.transformedName);
+                }
+
+                if (registered.kind === "enum") {
+                    return {
+                        ts: qualifiedName,
+                        ffi: { type: "int", size: 32, unsigned: false },
+                        externalType,
+                    };
+                }
+
+                if (registered.kind === "record") {
+                    return {
+                        ts: qualifiedName,
+                        ffi: {
+                            type: "boxed",
+                            borrowed: isReturn,
+                            innerType: registered.glibTypeName ?? registered.transformedName,
+                        },
+                        externalType,
+                        kind: registered.kind,
+                    };
+                }
+
+                if (registered.kind === "callback") {
+                    return POINTER_TYPE;
+                }
+
+                return {
+                    ts: qualifiedName,
+                    ffi: { type: "gobject", borrowed: isReturn },
+                    externalType,
+                    kind: registered.kind,
+                };
+            }
+        }
+
         if (this.enumNames.has(girType.name)) {
             const transformedName = this.enumTransforms.get(girType.name) ?? girType.name;
             this.onEnumUsed?.(transformedName);
@@ -1056,7 +1131,7 @@ export class TypeMapper {
             };
         }
 
-        if (param.type.name === "GLib.DestroyNotify") {
+        if (param.type.name === "GLib.DestroyNotify" || param.type.name === "DestroyNotify") {
             return {
                 ts: "() => void",
                 ffi: {
@@ -1066,7 +1141,7 @@ export class TypeMapper {
             };
         }
 
-        if (param.type.name === "GLib.SourceFunc") {
+        if (param.type.name === "GLib.SourceFunc" || param.type.name === "SourceFunc") {
             return {
                 ts: "() => boolean",
                 ffi: {