@ts-for-gir/lib 4.0.0-beta.1 → 4.0.0-beta.10

package/lib/gir-module.d.ts

@@ -1,9 +1,8 @@
 import { Transformation } from './transformation.js';
 import { Logger } from './logger.js';
 import { DependencyManager } from './dependency-manager.js';
-import { SymTable } from './symtable.js';
 import { LibraryVersion } from './library-version.js';
-import type { Dependency, GirRepository, GirConstantElement, TsDocTag, ParsedGir, GirInfoAttrs, GenerateConfig } from './types/index.js';
+import type { Dependency, GirConstantElement, TsDocTag, OptionsGeneration } from './types/index.js';
 import { GirNSMember } from './gir.js';
 import { IntrospectedAlias } from './gir/alias.js';
 import { IntrospectedNamespaceMember } from './gir/base.js';
@@ -13,39 +12,43 @@ import { IntrospectedFunction, IntrospectedFunctionParameter, IntrospectedClassF
 import { NSRegistry } from './gir/registry.js';
 import { GirVisitor } from './visitor.js';
 export declare class GirModule {
+    readonly dependency: Dependency;
     /**
      * E.g. 'Gtk'
      */
-    namespace: string;
+    get namespace(): string;
     /**
      * E.g. '4.0'
      */
-    version: string;
+    get version(): string;
     /**
      * E.g. 'Gtk-4.0'
      */
-    packageName: string;
+    get packageName(): string;
     /**
      * E.g. 'Gtk40'
      * Is used in the generated index.d.ts, for example: `import * as Gtk40 from "./Gtk-4.0.js";`
      */
-    importNamespace: string;
-    importName: string;
+    get importNamespace(): string;
+    /**
+     * The NPM package name E.g. 'gtk-4.0'
+     */
+    get importName(): string;
+    /**
+     * Import path for the package E.g. './Gtk-4.0.js' or '@girs/Gtk-4.0'
+     */
+    get importPath(): string;
     prefixes: string[];
     /**
      * The version of the library as an object.
      * E.g. `{ major: 4, minor: 0, patch: 0 }` or as string `4.0.0`'
      */
-    libraryVersion: LibraryVersion;
-    dependencies: Dependency[];
-    private _transitiveDependencies;
-    set transitiveDependencies(deps: Dependency[]);
+    get libraryVersion(): LibraryVersion;
+    protected _dependencies: Dependency[] | null;
+    protected _transitiveDependencies: Dependency[] | null;
+    get dependencies(): Dependency[];
     get transitiveDependencies(): Dependency[];
     get allDependencies(): Dependency[];
-    /**
-     * Used to find namespaces that are used in other modules
-     */
-    symTable: SymTable;
     transformation: Transformation;
     dependencyManager: DependencyManager;
     log: Logger;
@@ -57,7 +60,6 @@ export declare class GirModule {
     constNames: {
         [varName: string]: GirConstantElement;
     };
-    readonly name: string;
     readonly c_prefixes: string[];
     private _members?;
     private _enum_constants?;
@@ -65,12 +67,12 @@ export declare class GirModule {
     __dts__references?: string[];
     package_version: readonly [string, string] | readonly [string, string, string];
     parent: NSRegistry;
-    config: GenerateConfig;
-    constructor(repo: GirRepository, name: string, version: string, prefixes: string[], config: GenerateConfig);
+    config: OptionsGeneration;
+    constructor(dependency: Dependency, prefixes: string[], config: OptionsGeneration);
+    initDependencies(): Promise<void>;
+    initTransitiveDependencies(transitiveDependencies: Dependency[]): Promise<void>;
     get ns(): this;
     private checkTransitiveDependencies;
-    private getTsDoc;
-    private getTsDocGirElementTags;
     getTsDocReturnTags(girElement?: IntrospectedFunction | IntrospectedClassFunction): TsDocTag[];
     getTsDocInParamTags(inParams?: IntrospectedFunctionParameter[]): TsDocTag[];
     registerResolveName(resolveName: string, namespace: string, name: string): void;
@@ -80,8 +82,8 @@ export declare class GirModule {
     getImportsForCPrefix(c_prefix: string): GirModule[];
     hasImport(name: string): boolean;
     private _getImport;
-    getInstalledImport(name: string): GirModule | null;
-    assertInstalledImport(name: string): GirModule;
+    getInstalledImport(_namespace: string): GirModule | null;
+    assertInstalledImport(_namespace: string): GirModule;
     getMembers(name: string): IntrospectedNamespaceMember[];
     getMemberWithoutOverrides(name: string): GirNSMember | null | undefined;
     assertClass(name: string): IntrospectedBaseClass;
@@ -97,22 +99,8 @@ export declare class GirModule {
      * libraries that are newer than default.
      */
     ___dts___addReference(reference: string): void;
-    static load(repo: ParsedGir, config: GenerateConfig, registry: NSRegistry): GirModule;
-    /**
-     * Start processing the typescript data
-     */
-    start(girModules: GirModule[]): void;
+    static load(dependency: Dependency, config: OptionsGeneration, registry: NSRegistry): Promise<GirModule>;
+    /** Start to parse all the data from the XML we need for the typescript generation */
+    parse(): void;
 }
-export declare const isIntrospectable: (e: {
-    $?: GirInfoAttrs;
-}) => boolean;
-export declare const isDeprecated: (e: {
-    $: GirInfoAttrs;
-}) => boolean;
-export declare const deprecatedVersion: (e: {
-    $: GirInfoAttrs;
-}) => string | undefined;
-export declare const introducedVersion: (e: {
-    $: GirInfoAttrs;
-}) => string | undefined;
 export declare function promisifyNamespaceFunctions(namespace: GirModule): void;

package/lib/gir-module.js

@@ -1,11 +1,9 @@
 // TODO move this class into a web-worker? https://www.npmjs.com/package/web-worker
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { IGNORE_GIR_TYPE_TS_DOC_TYPES, Transformation } from './transformation.js';
+import { Transformation } from './transformation.js';
 import { Logger } from './logger.js';
 import { DependencyManager } from './dependency-manager.js';
-import { find } from './utils.js';
-import { SymTable } from './symtable.js';
-import { LibraryVersion } from './library-version.js';
+import { find, isIntrospectable } from './utils/index.js';
 import { ClosureType, TypeIdentifier, PromiseType, VoidType, BooleanType, TupleType, BinaryType, NullableType, ObjectType, } from './gir.js';
 import { IntrospectedAlias } from './gir/alias.js';
 import { IntrospectedBase } from './gir/base.js';
@@ -15,45 +13,79 @@ import { IntrospectedEnum, IntrospectedError } from './gir/enum.js';
 import { IntrospectedFunction, IntrospectedCallback, } from './gir/function.js';
 import { isPrimitiveType } from './gir/util.js';
 export class GirModule {
+    dependency;
     /**
      * E.g. 'Gtk'
      */
-    namespace;
+    get namespace() {
+        return this.dependency.namespace;
+    }
     /**
      * E.g. '4.0'
      */
-    version;
+    get version() {
+        return this.dependency.version;
+    }
     /**
      * E.g. 'Gtk-4.0'
      */
-    packageName;
+    get packageName() {
+        return this.dependency.packageName;
+    }
     /**
      * E.g. 'Gtk40'
      * Is used in the generated index.d.ts, for example: `import * as Gtk40 from "./Gtk-4.0.js";`
      */
-    importNamespace;
-    importName;
+    get importNamespace() {
+        return this.dependency.importNamespace;
+    }
+    /**
+     * The NPM package name E.g. 'gtk-4.0'
+     */
+    get importName() {
+        return this.dependency.importName;
+    }
+    /**
+     * Import path for the package E.g. './Gtk-4.0.js' or '@girs/Gtk-4.0'
+     */
+    get importPath() {
+        return this.dependency.importPath;
+    }
     prefixes = [];
     /**
      * The version of the library as an object.
      * E.g. `{ major: 4, minor: 0, patch: 0 }` or as string `4.0.0`'
      */
-    libraryVersion;
-    dependencies = [];
-    _transitiveDependencies = [];
-    set transitiveDependencies(deps) {
-        this._transitiveDependencies = this.checkTransitiveDependencies(deps);
+    get libraryVersion() {
+        // GObject and Gio are following the version of GLib
+        if (this.namespace === 'GObject' || this.namespace === 'Gio') {
+            const dep = this.allDependencies.find((girModule) => girModule.namespace === 'GLib');
+            if (dep) {
+                return dep.libraryVersion;
+            }
+        }
+        return this.dependency.libraryVersion;
+    }
+    _dependencies = null;
+    _transitiveDependencies = null;
+    get dependencies() {
+        if (!this._dependencies) {
+            throw new Error('dependencies is not initialized, run initDependencies() first');
+        }
+        return this._dependencies;
     }
     get transitiveDependencies() {
+        if (!this._transitiveDependencies) {
+            throw new Error('transitiveDependencies is not initialized, run initTransitiveDependencies() first');
+        }
         return this._transitiveDependencies;
     }
     get allDependencies() {
+        if (!this.dependencies) {
+            throw new Error('dependencies is not initialized, run init() first');
+        }
         return [...new Set([...this.dependencies, ...this.transitiveDependencies])];
     }
-    /**
-     * Used to find namespaces that are used in other modules
-     */
-    symTable;
     transformation;
     dependencyManager;
     log;
@@ -63,7 +95,6 @@ export class GirModule {
      * Please note: Such a case is only known for Zeitgeist-2.0 with the constant "ATTACHMENT"
      */
     constNames = {};
-    name;
     c_prefixes;
     _members;
     _enum_constants;
@@ -72,68 +103,48 @@ export class GirModule {
     package_version;
     parent;
     config;
-    constructor(repo, name, version, prefixes, config) {
-        this.name = name;
-        this.version = version;
+    constructor(dependency, prefixes, config) {
+        this.dependency = dependency;
         this.c_prefixes = [...prefixes];
         this.package_version = ['0', '0'];
         this.config = config;
+        // TODO: Make this a singleton
         this.dependencyManager = DependencyManager.getInstance(this.config);
-        this.dependencies = this.dependencyManager.fromGirIncludes(repo.include || []);
+    }
+    async initDependencies() {
+        this._dependencies = await this.dependencyManager.fromGirIncludes(this.dependency.girXML?.repository[0]?.include || []);
+    }
+    async initTransitiveDependencies(transitiveDependencies) {
+        this._transitiveDependencies = await this.checkTransitiveDependencies(transitiveDependencies);
     }
     get ns() {
         return this;
     }
-    checkTransitiveDependencies(transitiveDependencies) {
+    async checkTransitiveDependencies(transitiveDependencies) {
         // Always pull in GObject-2.0, as we may need it for e.g. GObject-2.0.type
         if (this.packageName !== 'GObject-2.0') {
             if (!find(transitiveDependencies, (x) => x.packageName === 'GObject-2.0')) {
-                transitiveDependencies.push(this.dependencyManager.get('GObject', '2.0'));
+                transitiveDependencies.push(await this.dependencyManager.get('GObject', '2.0'));
             }
         }
         // Add missing dependencies
         if (this.packageName === 'UnityExtras-7.0') {
             if (!find(transitiveDependencies, (x) => x.packageName === 'Unity-7.0')) {
-                transitiveDependencies.push(this.dependencyManager.get('Unity', '7.0'));
+                transitiveDependencies.push(await this.dependencyManager.get('Unity', '7.0'));
             }
         }
         if (this.packageName === 'UnityExtras-6.0') {
             if (!find(transitiveDependencies, (x) => x.packageName === 'Unity-6.0')) {
-                transitiveDependencies.push(this.dependencyManager.get('Unity', '6.0'));
+                transitiveDependencies.push(await this.dependencyManager.get('Unity', '6.0'));
             }
         }
         if (this.packageName === 'GTop-2.0') {
             if (!find(transitiveDependencies, (x) => x.packageName === 'GLib-2.0')) {
-                transitiveDependencies.push(this.dependencyManager.get('GLib', '2.0'));
+                transitiveDependencies.push(await this.dependencyManager.get('GLib', '2.0'));
             }
         }
         return transitiveDependencies;
     }
-    getTsDoc(girDoc) {
-        const tsDoc = {
-            text: '',
-            tags: [],
-        };
-        if (girDoc.doc?.[0]?._) {
-            // TODO: Somehow _ is not a string
-            let text = `${girDoc.doc?.[0]?._ || ''}`;
-            text = this.transformation.transformGirDocText(text);
-            tsDoc.text = text;
-        }
-        return tsDoc;
-    }
-    getTsDocGirElementTags(tsTypeName, girTypeName) {
-        const tags = [];
-        if (!girTypeName || IGNORE_GIR_TYPE_TS_DOC_TYPES.includes(girTypeName)) {
-            return tags;
-        }
-        tags.push({
-            tagName: girTypeName,
-            paramName: '',
-            text: '',
-        });
-        return tags;
-    }
     getTsDocReturnTags(girElement) {
         const girReturnValue = girElement?.returnTypeDoc;
         if (!girReturnValue) {
@@ -200,58 +211,58 @@ export class GirModule {
     hasImport(name) {
         return this.dependencies.some((dep) => dep.importName === name);
     }
-    _getImport(name) {
-        if (name === this.name) {
+    _getImport(namespace) {
+        if (namespace === this.namespace) {
             return this;
         }
-        const dep = this.dependencies.find((dep) => dep.namespace === name) ??
-            this.transitiveDependencies.find((dep) => dep.namespace === name);
+        const dep = this.dependencies?.find((dep) => dep.namespace === namespace) ??
+            this.transitiveDependencies.find((dep) => dep.namespace === namespace);
         // Handle finding imports via their other prefixes
         if (!dep) {
-            this.log.info(`Failed to find namespace ${name} in dependencies, resolving via c:prefixes`);
+            this.log.info(`Failed to find namespace ${namespace} in dependencies, resolving via c:prefixes`);
             // TODO: It might make more sense to move this conversion _before_
             // the _getImport call.
-            const resolvedNamespaces = this.dependencyManager.namespacesForPrefix(name);
+            const resolvedNamespaces = this.dependencyManager.namespacesForPrefix(namespace);
             if (resolvedNamespaces.length > 0) {
-                this.log.info(`Found namespaces for prefix ${name}: ${resolvedNamespaces.map((r) => `${r.name} (${r.version})`).join(', ')}`);
+                this.log.info(`Found namespaces for prefix ${namespace}: ${resolvedNamespaces.map((r) => `${r.namespace} (${r.version})`).join(', ')}`);
             }
             for (const resolvedNamespace of resolvedNamespaces) {
-                if (resolvedNamespace.name === this.name && resolvedNamespace.version === this.version) {
+                if (resolvedNamespace.namespace === this.namespace && resolvedNamespace.version === this.version) {
                     return this;
                 }
-                const dep = this.dependencies.find((dep) => dep.namespace === resolvedNamespace.name && dep.version === resolvedNamespace.version) ??
-                    this.transitiveDependencies.find((dep) => dep.namespace === resolvedNamespace.name && dep.version === resolvedNamespace.version);
+                const dep = this.dependencies?.find((dep) => dep.namespace === resolvedNamespace.namespace && dep.version === resolvedNamespace.version) ??
+                    this.transitiveDependencies.find((dep) => dep.namespace === resolvedNamespace.namespace && dep.version === resolvedNamespace.version);
                 if (dep) {
-                    return this.parent.namespace(resolvedNamespace.name, dep.version);
+                    return this.parent.namespace(resolvedNamespace.namespace, dep.version);
                 }
             }
         }
         let version = dep?.version;
         if (!version) {
-            version = this.parent.assertDefaultVersionOf(name);
+            version = this.parent.assertDefaultVersionOf(namespace);
         }
-        return this.parent.namespace(name, version);
+        return this.parent.namespace(namespace, version);
     }
-    getInstalledImport(name) {
-        if (name === this.name) {
+    getInstalledImport(_namespace) {
+        if (_namespace === this.namespace) {
             return this;
         }
-        const dep = this.dependencies.find((dep) => dep.namespace === name) ??
-            this.transitiveDependencies.find((dep) => dep.namespace === name);
+        const dep = this.dependencies?.find((dep) => dep.namespace === _namespace) ??
+            this.transitiveDependencies.find((dep) => dep.namespace === _namespace);
         let version = dep?.version;
         if (!version) {
-            version = this.parent.defaultVersionOf(name) ?? undefined;
+            version = this.parent.defaultVersionOf(_namespace) ?? undefined;
         }
         if (!version) {
             return null;
         }
-        const namespace = this.parent.namespace(name, version);
+        const namespace = this.parent.namespace(_namespace, version);
         return namespace;
     }
-    assertInstalledImport(name) {
-        const namespace = this._getImport(name);
+    assertInstalledImport(_namespace) {
+        const namespace = this._getImport(_namespace);
         if (!namespace) {
-            throw new Error(`Failed to import ${name} in ${this.name}, not installed or accessible.`);
+            throw new Error(`Failed to import ${_namespace} in ${this.namespace}, not installed or accessible.`);
         }
         return namespace;
     }
@@ -282,7 +293,7 @@ export class GirModule {
     assertClass(name) {
         const clazz = this.getClass(name);
         if (!clazz) {
-            throw new Error(`Class ${name} does not exist in namespace ${this.name}.`);
+            throw new Error(`Class ${name} does not exist in namespace ${this.namespace}.`);
         }
         return clazz;
     }
@@ -342,22 +353,17 @@ export class GirModule {
         this.__dts__references ??= [];
         this.__dts__references.push(reference);
     }
-    static load(repo, config, registry) {
-        const ns = repo.repository[0]?.namespace?.[0];
-        if (!ns)
-            throw new Error(`Missing namespace in ${repo.repository[0].package[0].$.name}`);
+    static async load(dependency, config, registry) {
+        const girXML = dependency.girXML;
+        const ns = girXML?.repository[0]?.namespace?.[0];
+        if (!girXML) {
+            throw new Error(`Failed to load gir xml of ${dependency.packageName}`);
+        }
+        if (!ns) {
+            throw new Error(`Missing namespace in ${girXML.repository[0].package[0].$.name}`);
+        }
         const modName = ns.$['name'];
         const version = ns.$['version'];
-        // TODO: Hardcoding HarfBuzz here leads to issues when loading...
-        // Hardcode harfbuzz version for now...
-        // if (modName === 'HarfBuzz' && version === '0.0') {
-        //     version = '2.0'
-        // }
-        const options = {
-            loadDocs: !config.noComments,
-            propertyCase: 'both',
-            verbose: config.verbose,
-        };
         if (!modName) {
             throw new Error('Invalid GIR file: no namespace name specified.');
         }
@@ -365,112 +371,130 @@ export class GirModule {
             throw new Error('Invalid GIR file: no version name specified.');
         }
         const c_prefix = ns.$?.['c:identifier-prefixes']?.split(',') ?? [];
-        if (options.verbose) {
-            console.debug(`Parsing ${modName}...`);
-        }
-        const building = new GirModule(repo.repository[0], modName, version, c_prefix, config);
+        const building = new GirModule(dependency, c_prefix, config);
+        await building.initDependencies();
         building.parent = registry;
         // Set the namespace object here to prevent re-parsing the namespace if
         // another namespace imports it.
         registry.register(building);
-        const prefixes = repo.repository[0]?.$?.['c:identifier-prefixes']?.split(',');
+        const prefixes = girXML.repository[0]?.$?.['c:identifier-prefixes']?.split(',');
         const unknownPrefixes = prefixes?.filter((pre) => pre !== modName);
         if (unknownPrefixes && unknownPrefixes.length > 0) {
-            console.log(`Found additional prefixes for ${modName}: ${unknownPrefixes.join(', ')}`);
+            Logger.log(`Found additional prefixes for ${modName}: ${unknownPrefixes.join(', ')}`);
             building.prefixes.push(...unknownPrefixes);
         }
+        building.transformation = Transformation.getSingleton(config);
+        building.log = new Logger(config.verbose, `GirModule(${building.packageName})`);
+        return building;
+    }
+    /** Start to parse all the data from the XML we need for the typescript generation */
+    parse() {
+        this.log.debug(`Parsing ${this.dependency.packageName}...`);
+        const girXML = this.dependency.girXML;
+        const ns = girXML?.repository[0]?.namespace?.[0];
+        const options = {
+            loadDocs: !this.config.noComments,
+            propertyCase: 'both',
+            verbose: this.config.verbose,
+        };
+        if (!girXML) {
+            throw new Error(`Failed to load gir xml of ${this.dependency.packageName}`);
+        }
+        if (!ns) {
+            throw new Error(`Missing namespace in ${girXML.repository[0].package[0].$.name}`);
+        }
         const importConflicts = (el) => {
-            return !building.hasImport(el.name);
+            return !this.hasImport(el.name);
         };
         if (ns.enumeration) {
             // Get the requested enums
             ns.enumeration
                 ?.map((enumeration) => {
                 if (enumeration.$['glib:error-domain']) {
-                    return IntrospectedError.fromXML(enumeration, building, options);
+                    return IntrospectedError.fromXML(enumeration, this, options);
                 }
                 else {
-                    return IntrospectedEnum.fromXML(enumeration, building, options);
+                    return IntrospectedEnum.fromXML(enumeration, this, options);
                 }
             })
-                .forEach((c) => building.members.set(c.name, c));
+                .forEach((c) => this.members.set(c.name, c));
         }
         // Constants
         if (ns.constant) {
             ns.constant
                 ?.filter(isIntrospectable)
-                .map((constant) => IntrospectedConstant.fromXML(constant, building, options))
+                .map((constant) => IntrospectedConstant.fromXML(constant, this, options))
                 .filter(importConflicts)
-                .forEach((c) => building.members.set(c.name, c));
+                .forEach((c) => this.members.set(c.name, c));
         }
         // Get the requested functions
         if (ns.function) {
             ns.function
                 ?.filter(isIntrospectable)
-                .map((func) => IntrospectedFunction.fromXML(func, building, options))
+                .map((func) => IntrospectedFunction.fromXML(func, this, options))
                 .filter(importConflicts)
-                .forEach((c) => building.members.set(c.name, c));
+                .forEach((c) => this.members.set(c.name, c));
         }
         if (ns.callback) {
             ns.callback
                 ?.filter(isIntrospectable)
-                .map((callback) => IntrospectedCallback.fromXML(callback, building, options))
+                .map((callback) => IntrospectedCallback.fromXML(callback, this, options))
                 .filter(importConflicts)
-                .forEach((c) => building.members.set(c.name, c));
+                .forEach((c) => this.members.set(c.name, c));
         }
         if (ns['glib:boxed']) {
             ns['glib:boxed']
                 ?.filter(isIntrospectable)
                 .map((boxed) => new IntrospectedAlias({
                 name: boxed.$['glib:name'],
-                namespace: building,
+                namespace: this,
                 type: new NullableType(ObjectType),
             }))
-                .forEach((c) => building.members.set(c.name, c));
+                .forEach((c) => this.members.set(c.name, c));
         }
         // Bitfield is a type of enum
         if (ns.bitfield) {
             ns.bitfield
                 ?.filter(isIntrospectable)
-                .map((field) => IntrospectedEnum.fromXML(field, building, options, true))
-                .forEach((c) => building.members.set(c.name, c));
+                .map((field) => IntrospectedEnum.fromXML(field, this, options, true))
+                .forEach((c) => this.members.set(c.name, c));
         }
         // The `enum_constants` map maps the C identifiers (GTK_BUTTON_TYPE_Y)
         // to the name of the enum (Button) to resolve references (Gtk.Button.Y)
-        Array.from(building.members.values())
+        Array.from(this.members.values())
             .filter((m) => m instanceof IntrospectedEnum)
             .forEach((m) => {
             m.members.forEach((member) => {
-                building.enum_constants.set(member.c_identifier, [m.name, member.name]);
+                this.enum_constants.set(member.c_identifier, [m.name, member.name]);
             });
         });
         // Get the requested classes
         if (ns.class) {
             ns.class
                 ?.filter(isIntrospectable)
-                .map((klass) => IntrospectedClass.fromXML(klass, building, options))
+                .map((klass) => IntrospectedClass.fromXML(klass, this, options))
                 .filter(importConflicts)
-                .forEach((c) => building.members.set(c.name, c));
+                .forEach((c) => this.members.set(c.name, c));
         }
         if (ns.record) {
             ns.record
                 ?.filter(isIntrospectable)
-                .map((record) => IntrospectedRecord.fromXML(record, building, options))
+                .map((record) => IntrospectedRecord.fromXML(record, this, options))
                 .filter(importConflicts)
-                .forEach((c) => building.members.set(c.name, c));
+                .forEach((c) => this.members.set(c.name, c));
         }
         if (ns.union) {
             ns.union
                 ?.filter(isIntrospectable)
-                .map((union) => IntrospectedRecord.fromXML(union, building, options))
+                .map((union) => IntrospectedRecord.fromXML(union, this, options))
                 .filter(importConflicts)
-                .forEach((c) => building.members.set(c.name, c));
+                .forEach((c) => this.members.set(c.name, c));
         }
         if (ns.interface) {
             ns.interface
-                ?.map((inter) => IntrospectedInterface.fromXML(inter, building, options))
+                ?.map((inter) => IntrospectedInterface.fromXML(inter, this, options))
                 .filter(importConflicts)
-                .forEach((c) => building.members.set(c.name, c));
+                .forEach((c) => this.members.set(c.name, c));
         }
         if (ns.alias) {
             ns.alias
@@ -481,7 +505,7 @@ export class GirModule {
                     ?.filter((t) => !!(t && t.$.name))
                     .map((t) => {
                     if (t.$.name &&
-                        !building.hasSymbol(t.$.name) &&
+                        !this.hasSymbol(t.$.name) &&
                         !isPrimitiveType(t.$.name) &&
                         !t.$.name.includes('.')) {
                         return { $: { name: 'unknown', 'c:type': 'unknown' } };
@@ -490,38 +514,12 @@ export class GirModule {
                 });
                 return b;
             })
-                .map((alias) => IntrospectedAlias.fromXML(alias, building, options))
+                .map((alias) => IntrospectedAlias.fromXML(alias, this, options))
                 .filter((alias) => alias != null)
-                .forEach((c) => building.members.set(c.name, c));
-        }
-        building.namespace = building.ns.name;
-        building.version = building.ns.version;
-        building.packageName = `${building.namespace}-${building.version}`;
-        building.libraryVersion = new LibraryVersion(ns.constant, building.version);
-        building.transformation = new Transformation(config);
-        building.log = new Logger(config.verbose, building.packageName || 'GirModule');
-        building.importNamespace = building.transformation.transformModuleNamespaceName(building.packageName);
-        building.importName = building.transformation.transformImportName(building.packageName);
-        building.symTable = new SymTable(building.config, building.packageName, building.namespace);
-        return building;
-    }
-    /**
-     * Start processing the typescript data
-     */
-    start(girModules) {
-        // GObject and Gio are following the version of GLib
-        if (this.namespace === 'GObject' || this.namespace === 'Gio') {
-            const glibModule = girModules.find((girModule) => girModule.namespace === 'GLib');
-            if (glibModule) {
-                this.libraryVersion = glibModule.libraryVersion;
-            }
+                .forEach((c) => this.members.set(c.name, c));
         }
     }
 }
-export const isIntrospectable = (e) => !e || !e.$ || !e.$.introspectable || e.$.introspectable === '1';
-export const isDeprecated = (e) => e && e.$ && e.$.deprecated === '1';
-export const deprecatedVersion = (e) => e?.$?.['deprecated-version'];
-export const introducedVersion = (e) => e?.$?.version;
 export function promisifyNamespaceFunctions(namespace) {
     return namespace.members.forEach((node) => {
         if (!(node instanceof IntrospectedFunction))