@gtkx/gir 0.20.0 → 0.21.0

package/src/model/record.ts

@@ -0,0 +1,97 @@
+import type { GirConstructor, GirFunction, GirMethod } from "./callables.js";
+import type { GirField } from "./field.js";
+
+/**
+ * Record (boxed type or plain struct) with helper methods.
+ */
+export class GirRecord {
+    readonly name: string;
+    readonly qualifiedName: string;
+    readonly cType: string;
+    readonly opaque: boolean;
+    readonly disguised: boolean;
+    readonly glibTypeName?: string;
+    readonly glibGetType?: string;
+    readonly isGtypeStructFor?: string;
+    readonly copyFunction?: string;
+    readonly freeFunction?: string;
+    readonly fields: GirField[];
+    readonly methods: GirMethod[];
+    readonly constructors: GirConstructor[];
+    readonly staticFunctions: GirFunction[];
+    readonly doc?: string;
+
+    constructor(data: {
+        name: string;
+        qualifiedName: string;
+        cType: string;
+        opaque: boolean;
+        disguised: boolean;
+        glibTypeName?: string;
+        glibGetType?: string;
+        isGtypeStructFor?: string;
+        copyFunction?: string;
+        freeFunction?: string;
+        fields: GirField[];
+        methods: GirMethod[];
+        constructors: GirConstructor[];
+        staticFunctions: GirFunction[];
+        doc?: string;
+    }) {
+        this.name = data.name;
+        this.qualifiedName = data.qualifiedName;
+        this.cType = data.cType;
+        this.opaque = data.opaque;
+        this.disguised = data.disguised;
+        this.glibTypeName = data.glibTypeName;
+        this.glibGetType = data.glibGetType;
+        this.isGtypeStructFor = data.isGtypeStructFor;
+        this.copyFunction = data.copyFunction;
+        this.freeFunction = data.freeFunction;
+        this.fields = data.fields;
+        this.methods = data.methods;
+        this.constructors = data.constructors;
+        this.staticFunctions = data.staticFunctions;
+        this.doc = data.doc;
+    }
+
+    /** True if this has custom copy/free functions. */
+    isFundamental(): boolean {
+        return this.copyFunction !== undefined && this.freeFunction !== undefined;
+    }
+
+    /** True if this is a GLib boxed type (has glibTypeName). */
+    isBoxed(): boolean {
+        return this.glibTypeName !== undefined;
+    }
+
+    /** True if this is a GType struct (vtable for a class/interface). */
+    isGtypeStruct(): boolean {
+        return this.isGtypeStructFor !== undefined;
+    }
+
+    /** True if this is a plain C struct (no GType, has public fields). */
+    isPlainStruct(): boolean {
+        return !this.glibTypeName && !this.opaque && this.getPublicFields().length > 0;
+    }
+
+    /** Gets public (non-private) fields only. */
+    getPublicFields(): GirField[] {
+        return this.fields.filter((f) => !f.private);
+    }
+
+    /** Finds a method by name. */
+    getMethod(name: string): GirMethod | null {
+        return this.methods.find((m) => m.name === name) ?? null;
+    }
+
+    /** Finds a field by name. */
+    getField(name: string): GirField | null {
+        return this.fields.find((f) => f.name === name) ?? null;
+    }
+
+    /** Finds a constructor by name. */
+    getConstructor(name: string): GirConstructor | null {
+        return this.constructors.find((c) => c.name === name) ?? null;
+    }
+}

package/src/model/repository-like.ts

@@ -0,0 +1,20 @@
+import type { GirClass } from "./class.js";
+import type { GirInterface } from "./interface.js";
+
+/**
+ * The kind of a user-defined type (not intrinsic).
+ */
+export type TypeKind = "class" | "interface" | "record" | "enum" | "flags" | "callback";
+
+/**
+ * Minimal repository interface used by model classes for type graph traversal.
+ *
+ * This interface breaks the circular dependency between model classes and
+ * the concrete GirRepository. Model classes depend on this interface,
+ * and GirRepository implements it.
+ */
+export type RepositoryLike = {
+    resolveClass(qualifiedName: string): GirClass | null;
+    resolveInterface(qualifiedName: string): GirInterface | null;
+    findClasses(predicate: (cls: GirClass) => boolean): GirClass[];
+};

package/src/model/signal.ts

@@ -0,0 +1,32 @@
+import type { GirParameter } from "./parameter.js";
+import type { GirType } from "./type.js";
+
+/**
+ * GObject signal with helper methods.
+ */
+export class GirSignal {
+    readonly name: string;
+    readonly when: "first" | "last" | "cleanup";
+    readonly returnType: GirType | null;
+    readonly parameters: GirParameter[];
+    readonly doc?: string;
+
+    constructor(data: {
+        name: string;
+        when: "first" | "last" | "cleanup";
+        returnType: GirType | null;
+        parameters: GirParameter[];
+        doc?: string;
+    }) {
+        this.name = data.name;
+        this.when = data.when;
+        this.returnType = data.returnType;
+        this.parameters = data.parameters;
+        this.doc = data.doc;
+    }
+
+    /** True if the signal returns a value. */
+    hasReturnValue(): boolean {
+        return this.returnType !== null && !this.returnType.isVoid();
+    }
+}

package/src/model/type.ts

@@ -0,0 +1,143 @@
+import { isIntrinsicType, isNumericType, isStringType, isVoidType } from "../intrinsics.js";
+
+/**
+ * Container type discriminator for generic GLib containers.
+ */
+export type ContainerType = "ghashtable" | "gptrarray" | "garray" | "gbytearray" | "glist" | "gslist";
+
+/**
+ * Type reference with helper methods.
+ *
+ * Type names are either fully qualified (`"Gtk.Widget"`) for namespace types
+ * or unqualified (`"gint"`, `"utf8"`) for intrinsic types.
+ */
+export class GirType {
+    readonly name: string;
+    readonly cType?: string;
+    readonly isArray: boolean;
+    readonly elementType: GirType | null;
+    readonly typeParameters: readonly GirType[];
+    readonly containerType?: ContainerType;
+    readonly transferOwnership?: "none" | "full" | "container";
+    readonly nullable: boolean;
+    readonly sizeParamIndex?: number;
+    readonly zeroTerminated?: boolean;
+    readonly fixedSize?: number;
+
+    constructor(data: {
+        name: string;
+        cType?: string;
+        isArray: boolean;
+        elementType: GirType | null;
+        typeParameters?: readonly GirType[];
+        containerType?: ContainerType;
+        transferOwnership?: "none" | "full" | "container";
+        nullable: boolean;
+        sizeParamIndex?: number;
+        zeroTerminated?: boolean;
+        fixedSize?: number;
+    }) {
+        this.name = data.name;
+        this.cType = data.cType;
+        this.isArray = data.isArray;
+        this.elementType = data.elementType;
+        this.typeParameters = data.typeParameters ?? [];
+        this.containerType = data.containerType;
+        this.transferOwnership = data.transferOwnership;
+        this.nullable = data.nullable;
+        this.sizeParamIndex = data.sizeParamIndex;
+        this.zeroTerminated = data.zeroTerminated;
+        this.fixedSize = data.fixedSize;
+    }
+
+    /** True if this is an intrinsic/primitive type. */
+    isIntrinsic(): boolean {
+        return isIntrinsicType(this.name);
+    }
+
+    /** True if this is a string type (utf8 or filename). */
+    isString(): boolean {
+        return isStringType(this.name);
+    }
+
+    /** True if this is a numeric type. */
+    isNumeric(): boolean {
+        return isNumericType(this.name);
+    }
+
+    /** True if this is a boolean type. */
+    isBoolean(): boolean {
+        return this.name === "gboolean";
+    }
+
+    /** True if this is void. */
+    isVoid(): boolean {
+        return isVoidType(this.name);
+    }
+
+    /** True if this is GVariant. */
+    isVariant(): boolean {
+        return this.name === "GVariant";
+    }
+
+    /** True if this is GParamSpec. */
+    isParamSpec(): boolean {
+        return this.name === "GParamSpec";
+    }
+
+    /** True if this is a GHashTable container. */
+    isHashTable(): boolean {
+        return this.containerType === "ghashtable";
+    }
+
+    /** True if this is a GPtrArray container. */
+    isPtrArray(): boolean {
+        return this.containerType === "gptrarray";
+    }
+
+    /** True if this is a GArray container. */
+    isGArray(): boolean {
+        return this.containerType === "garray";
+    }
+
+    /** True if this is a GByteArray container. */
+    isByteArray(): boolean {
+        return this.containerType === "gbytearray";
+    }
+
+    /** True if this is a GList or GSList container. */
+    isList(): boolean {
+        return this.containerType === "glist" || this.containerType === "gslist";
+    }
+
+    /** True if this is any generic container type. */
+    isGenericContainer(): boolean {
+        return this.containerType !== undefined;
+    }
+
+    /** Gets the key type for GHashTable, or null for other types. */
+    getKeyType(): GirType | null {
+        if (!this.isHashTable() || this.typeParameters.length < 1) return null;
+        return this.typeParameters[0] ?? null;
+    }
+
+    /** Gets the value type for GHashTable, or null for other types. */
+    getValueType(): GirType | null {
+        if (!this.isHashTable() || this.typeParameters.length < 2) return null;
+        return this.typeParameters[1] ?? null;
+    }
+
+    /** Gets the namespace part of a qualified name, or null for intrinsics. */
+    getNamespace(): string | null {
+        if (this.isIntrinsic()) return null;
+        const dot = this.name.indexOf(".");
+        return dot >= 0 ? this.name.slice(0, dot) : null;
+    }
+
+    /** Gets the simple name part (without namespace). */
+    getSimpleName(): string {
+        if (this.isIntrinsic()) return this.name;
+        const dot = this.name.indexOf(".");
+        return dot >= 0 ? this.name.slice(dot + 1) : this.name;
+    }
+}