@gtkx/gir 0.18.0 → 0.18.2

package/src/internal/raw-types.ts

@@ -0,0 +1,268 @@
+/**
+ * Raw GIR type definitions.
+ *
+ * These types represent the structure of parsed GIR XML data before normalization.
+ * They are internal to the @gtkx/gir package and not exported publicly.
+ *
+ * @internal
+ */
+
+import type { ContainerType } from "../types.js";
+
+export type { ContainerType };
+
+/**
+ * Represents a parsed GIR namespace (library).
+ *
+ * Contains all type definitions from a single GIR file, including
+ * classes, interfaces, functions, enums, records, and callbacks.
+ */
+export type RawNamespace = {
+    name: string;
+    version: string;
+    sharedLibrary: string;
+    cPrefix: string;
+    classes: RawClass[];
+    interfaces: RawInterface[];
+    functions: RawFunction[];
+    enumerations: RawEnumeration[];
+    bitfields: RawEnumeration[];
+    records: RawRecord[];
+    callbacks: RawCallback[];
+    constants: RawConstant[];
+    aliases: RawAlias[];
+    doc?: string;
+};
+
+/**
+ * A constant value defined in a GIR namespace.
+ */
+export type RawConstant = {
+    name: string;
+    cType: string;
+    value: string;
+    type: RawType;
+    doc?: string;
+};
+
+/**
+ * A callback type definition (function pointer type).
+ */
+export type RawCallback = {
+    name: string;
+    cType: string;
+    returnType: RawType;
+    parameters: RawParameter[];
+    doc?: string;
+};
+
+/**
+ * A GObject interface definition.
+ */
+export type RawInterface = {
+    name: string;
+    cType: string;
+    glibTypeName?: string;
+    prerequisites: string[];
+    methods: RawMethod[];
+    properties: RawProperty[];
+    signals: RawSignal[];
+    doc?: string;
+};
+
+/**
+ * A GObject class definition.
+ */
+export type RawClass = {
+    name: string;
+    cType: string;
+    parent?: string;
+    abstract?: boolean;
+    glibTypeName?: string;
+    glibGetType?: string;
+    cSymbolPrefix?: string;
+    fundamental?: boolean;
+    refFunc?: string;
+    unrefFunc?: string;
+    implements: string[];
+    methods: RawMethod[];
+    constructors: RawConstructor[];
+    functions: RawFunction[];
+    properties: RawProperty[];
+    signals: RawSignal[];
+    doc?: string;
+};
+
+/**
+ * A GLib record (boxed type or struct).
+ */
+export type RawRecord = {
+    name: string;
+    cType: string;
+    opaque?: boolean;
+    disguised?: boolean;
+    glibTypeName?: string;
+    glibGetType?: string;
+    isGtypeStructFor?: string;
+    copyFunction?: string;
+    freeFunction?: string;
+    fields: RawField[];
+    methods: RawMethod[];
+    constructors: RawConstructor[];
+    functions: RawFunction[];
+    doc?: string;
+};
+
+/**
+ * A field within a record or class.
+ */
+export type RawField = {
+    name: string;
+    type: RawType;
+    writable?: boolean;
+    readable?: boolean;
+    private?: boolean;
+    doc?: string;
+};
+
+/**
+ * A method on a class, interface, or record.
+ */
+export type RawMethod = {
+    name: string;
+    cIdentifier: string;
+    returnType: RawType;
+    parameters: RawParameter[];
+    instanceParameter?: RawParameter;
+    throws?: boolean;
+    doc?: string;
+    returnDoc?: string;
+    /** For async methods, the name of the corresponding finish function */
+    finishFunc?: string;
+    shadows?: string;
+    shadowedBy?: string;
+};
+
+/**
+ * A constructor for a class or record.
+ */
+export type RawConstructor = {
+    name: string;
+    cIdentifier: string;
+    returnType: RawType;
+    parameters: RawParameter[];
+    throws?: boolean;
+    doc?: string;
+    returnDoc?: string;
+    shadows?: string;
+    shadowedBy?: string;
+};
+
+/**
+ * A standalone function or static method.
+ */
+export type RawFunction = {
+    name: string;
+    cIdentifier: string;
+    returnType: RawType;
+    parameters: RawParameter[];
+    throws?: boolean;
+    doc?: string;
+    returnDoc?: string;
+    shadows?: string;
+    shadowedBy?: string;
+};
+
+/**
+ * A parameter to a function, method, or callback.
+ */
+export type RawParameter = {
+    name: string;
+    type: RawType;
+    direction?: "in" | "out" | "inout";
+    callerAllocates?: boolean;
+    nullable?: boolean;
+    optional?: boolean;
+    scope?: "async" | "call" | "notified";
+    closure?: number;
+    destroy?: number;
+    transferOwnership?: "none" | "full" | "container";
+    doc?: string;
+};
+
+/**
+ * A type reference in GIR.
+ *
+ * Type names may be unqualified (e.g., "Widget") for local types
+ * or qualified (e.g., "GObject.Object") for cross-namespace references.
+ */
+export type RawType = {
+    name: string;
+    cType?: string;
+    isArray?: boolean;
+    elementType?: RawType;
+    typeParameters?: RawType[];
+    containerType?: ContainerType;
+    transferOwnership?: "none" | "full" | "container";
+    nullable?: boolean;
+    sizeParamIndex?: number;
+    zeroTerminated?: boolean;
+    fixedSize?: number;
+};
+
+/**
+ * A GObject property definition.
+ */
+export type RawProperty = {
+    name: string;
+    type: RawType;
+    readable?: boolean;
+    writable?: boolean;
+    constructOnly?: boolean;
+    defaultValueRaw?: string;
+    getter?: string;
+    setter?: string;
+    doc?: string;
+};
+
+/**
+ * A GObject signal definition.
+ */
+export type RawSignal = {
+    name: string;
+    when?: "first" | "last" | "cleanup";
+    returnType?: RawType;
+    parameters?: RawParameter[];
+    doc?: string;
+};
+
+/**
+ * An enumeration or bitfield definition.
+ */
+export type RawEnumeration = {
+    name: string;
+    cType: string;
+    members: RawEnumerationMember[];
+    glibGetType?: string;
+    doc?: string;
+};
+
+/**
+ * A member of an enumeration or bitfield.
+ */
+export type RawEnumerationMember = {
+    name: string;
+    value: string;
+    cIdentifier: string;
+    doc?: string;
+};
+
+/**
+ * A type alias definition.
+ */
+export type RawAlias = {
+    name: string;
+    cType: string;
+    targetType: RawType;
+    doc?: string;
+};

package/src/intrinsics.ts

@@ -0,0 +1,129 @@
+/**
+ * Intrinsic (primitive) types that are not namespace-qualified.
+ *
+ * These are fundamental GLib/GObject types that exist outside of any namespace.
+ * When normalizing type references, intrinsic types remain as-is rather than
+ * being qualified with a namespace prefix.
+ */
+export const INTRINSIC_TYPES = new Set([
+    "void",
+    "none",
+    "gboolean",
+    "gint",
+    "gint8",
+    "gint16",
+    "gint32",
+    "gint64",
+    "gchar",
+    "gshort",
+    "glong",
+    "gssize",
+    "goffset",
+    "gintptr",
+    "guint",
+    "guint8",
+    "guint16",
+    "guint32",
+    "guint64",
+    "guchar",
+    "gushort",
+    "gulong",
+    "gsize",
+    "guintptr",
+    "gfloat",
+    "gdouble",
+    "gpointer",
+    "gconstpointer",
+    "utf8",
+    "filename",
+    "GType",
+    "GParamSpec",
+    "GVariant",
+    "int",
+    "uint",
+    "long",
+    "ulong",
+    "float",
+    "double",
+    "size_t",
+    "ssize_t",
+]);
+
+/**
+ * Checks if a type name is an intrinsic (primitive) type.
+ *
+ * @param typeName - The type name to check
+ * @returns True if the type is intrinsic and should not be namespace-qualified
+ */
+export const isIntrinsicType = (typeName: string): boolean => {
+    return INTRINSIC_TYPES.has(typeName);
+};
+
+/**
+ * String type names (utf8 and filename).
+ */
+export const STRING_TYPES = new Set(["utf8", "filename"]);
+
+/**
+ * Checks if a type name is a string type.
+ */
+export const isStringType = (typeName: string): boolean => {
+    return STRING_TYPES.has(typeName);
+};
+
+/**
+ * Numeric type names (integers and floats).
+ */
+export const NUMERIC_TYPES = new Set([
+    "gint",
+    "guint",
+    "gint8",
+    "guint8",
+    "gint16",
+    "guint16",
+    "gint32",
+    "guint32",
+    "gint64",
+    "guint64",
+    "gchar",
+    "guchar",
+    "gshort",
+    "gushort",
+    "glong",
+    "gulong",
+    "gsize",
+    "gssize",
+    "goffset",
+    "gintptr",
+    "guintptr",
+    "gfloat",
+    "gdouble",
+    "int",
+    "uint",
+    "long",
+    "ulong",
+    "float",
+    "double",
+    "size_t",
+    "ssize_t",
+    "GType",
+]);
+
+/**
+ * Checks if a type name is a numeric type.
+ */
+export const isNumericType = (typeName: string): boolean => {
+    return NUMERIC_TYPES.has(typeName);
+};
+
+/**
+ * Void type names.
+ */
+export const VOID_TYPES = new Set(["void", "none"]);
+
+/**
+ * Checks if a type name is void.
+ */
+export const isVoidType = (typeName: string): boolean => {
+    return VOID_TYPES.has(typeName);
+};