@ts-for-gir/cli 3.3.0 → 4.0.0-beta.2

package/src/generation-handler.ts

@@ -10,71 +10,63 @@ import {
 } from '@ts-for-gir/lib'
 import { GeneratorType, Generator } from '@ts-for-gir/generator-base'
 import { TypeDefinitionGenerator } from '@ts-for-gir/generator-typescript'
-import { HtmlDocGenerator } from '@ts-for-gir/generator-html-doc'
+// import { HtmlDocGenerator } from '@ts-for-gir/generator-html-doc'
 
-import type { InheritanceTable, GenerateConfig, GirModulesGrouped } from '@ts-for-gir/lib'
+import type { GenerateConfig, NSRegistry } from '@ts-for-gir/lib'
 
 export class GenerationHandler {
     log: Logger
     generator: Generator
+
     constructor(
         private readonly config: GenerateConfig,
         type: GeneratorType,
     ) {
-        this.log = new Logger(config.environment, config.verbose, 'GenerationHandler')
+        this.log = new Logger(config.verbose, 'GenerationHandler')
 
         switch (type) {
             case GeneratorType.TYPES:
                 this.generator = new TypeDefinitionGenerator(config)
                 break
-            case GeneratorType.HTML_DOC:
-                this.generator = new HtmlDocGenerator(config)
-                break
+            // case GeneratorType.HTML_DOC:
+            //     this.generator = new HtmlDocGenerator(config)
+            //     break
             default:
                 throw new Error('Unknown Generator')
         }
     }
 
-    private finalizeInheritance(inheritanceTable: InheritanceTable): void {
-        for (const clsName of Object.keys(inheritanceTable)) {
-            let p: string | string[] = inheritanceTable[clsName][0]
-            while (p) {
-                p = inheritanceTable[p]
-                if (p) {
-                    p = p[0]
-                    inheritanceTable[clsName].push(p)
-                }
-            }
-        }
-    }
-
-    public async start(girModules: GirModule[], girModulesGrouped: GirModulesGrouped[]): Promise<void> {
-        this.log.info(START_MODULE(this.config.environment, this.config.buildType))
+    public async start(girModules: GirModule[], registry: NSRegistry): Promise<void> {
+        this.log.info(START_MODULE)
 
         if (girModules.length == 0) {
             this.log.error(ERROR_NO_MODULE_SPECIFIED)
         }
 
-        GirModule.allGirModules = girModules
-
         this.log.info(FILE_PARSING_DONE)
 
-        const inheritanceTable: InheritanceTable = {}
-        for (const girModule of girModules) girModule.init(inheritanceTable)
+        this.log.info(TSDATA_PARSING_DONE)
 
-        this.finalizeInheritance(inheritanceTable)
+        if (this.config.outdir) {
+            await mkdir(this.config.outdir, { recursive: true })
+        }
 
-        this.log.info(TSDATA_PARSING_DONE)
+        // TODO: Put this somewhere that makes sense
+        registry.transform({
+            inferGenerics: true,
+            verbose: this.config.verbose,
+        })
+
+        await this.generator.start(registry)
 
         for (const girModule of girModules) {
-            if (this.config.outdir) {
-                await mkdir(this.config.outdir, { recursive: true })
-            }
             this.log.log(` - ${girModule.packageName} ...`)
             girModule.start(girModules)
+
+            await this.generator.generate(registry, girModule)
         }
 
-        await this.generator.start(girModules, girModulesGrouped, inheritanceTable)
+        await this.generator.finish(registry)
 
         this.log.success(GENERATING_TYPES_DONE)
     }

package/src/module-loader.ts

@@ -7,6 +7,7 @@ import glob from 'tiny-glob'
 import { basename } from 'path'
 import { readFile } from 'fs/promises'
 import { bold } from 'colorette'
+import { parser } from '@gi.ts/parser'
 import {
     DependencyManager,
     ResolveType,
@@ -15,7 +16,6 @@ import {
     splitModuleName,
     union,
     isIterable,
-    girParser,
     WARN_NO_GIR_FILE_FOUND_FOR_PACKAGE,
 } from '@ts-for-gir/lib'
 import { Config } from './config.js'
@@ -36,7 +36,7 @@ export class ModuleLoader {
     /** Transitive module dependencies */
     modDependencyMap: DependencyMap = {}
     constructor(protected readonly config: GenerateConfig) {
-        this.log = new Logger('', config.verbose, 'ModuleLoader')
+        this.log = new Logger(config.verbose, 'ModuleLoader')
         this.dependencyManager = DependencyManager.getInstance(config)
     }
 
@@ -385,8 +385,8 @@ export class ModuleLoader {
 
         this.log.log(`Parsing ${dependency.path}...`)
         const fileContents = await readFile(dependency.path, 'utf8')
-        const result = girParser(fileContents)
-        const girModule = new GirModule(result, this.config)
+        const result = parser.parseGir(fileContents)
+        const girModule = GirModule.load(result, this.config, this.dependencyManager)
         // Figure out transitive module dependencies
         this.extendDependencyMapByGirModule(girModule)
         return girModule
@@ -548,9 +548,25 @@ export class ModuleLoader {
         ignore: string[] = [],
         doNotAskForVersionOnConflict = true,
     ): Promise<{ keep: GirModuleResolvedBy[]; grouped: GirModulesGroupedMap; ignore: string[]; failed: Set<string> }> {
-        const foundPackageNames = await this.findPackageNames(packageNames, ignore)
+        const foundPackageNames = await this.findPackageNames([...packageNames], ignore)
+        // Always require these because GJS does...
+        const GLib = this.dependencyManager.get('GLib', '2.0')
+        const Gio = this.dependencyManager.get('Gio', '2.0')
+        const GObject = this.dependencyManager.get('GObject', '2.0')
+
         const dependencies = this.packageNamesToDependencies(foundPackageNames)
-        const { loaded, failed } = await this.loadGirModules(dependencies, ignore)
+
+        const { loaded, failed } = await this.loadGirModules(
+            [
+                GLib,
+                Gio,
+                GObject,
+                ...dependencies.filter(
+                    (dep) => dep.namespace !== 'GLib' && dep.namespace !== 'Gio' && dep.namespace !== 'GObject',
+                ),
+            ],
+            ignore,
+        )
         let keep: GirModuleResolvedBy[] = []
         if (doNotAskForVersionOnConflict) {
             keep = loaded