@ts-for-gir/cli 3.0.0-beta.10

package/src/constants.ts

@@ -0,0 +1,29 @@
+import { Environment } from './types/index.js'
+
+/**
+ * In gjs all classes have a static name property but the classes listed below already have a static name property
+ */
+export const STATIC_NAME_ALREADY_EXISTS = ['GMime.Charset', 'Camel.StoreInfo']
+
+export const COMMENT_REG_EXP = /\/\*.*\*\//g
+export const PARAM_REG_EXP = /[0-9a-zA-Z_]*:/g
+export const OPT_PARAM_REG_EXP = /[0-9a-zA-Z_]*\?:/g
+export const NEW_LINE_REG_EXP = /[\n\r]+/g
+
+export const MAX_CLASS_PARENT_DEPTH = 100
+
+export const APP_NAME = 'ts-for-gir'
+export const APP_USAGE = 'Typescript .d.ts generator from GIR for gjs or node-gtk'
+export const APP_SOURCE = 'https://github.com/gjsify/ts-for-gjs'
+
+export const GENERIC_NAMES = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K']
+
+export const SIGNAL_METHOD_NAMES_GENERAL = ['connect', 'emit']
+export const SIGNAL_METHOD_NAMES_GJS = ['connect_after', 'emit', 'disconnect']
+export const SIGNAL_METHOD_NAMES_NODE = ['after', 'on', 'once', 'off']
+export const SIGNAL_METHOD_NAMES = (env: Environment) => {
+    if (env === 'node') {
+        return [...SIGNAL_METHOD_NAMES_GENERAL, SIGNAL_METHOD_NAMES_NODE]
+    }
+    return [...SIGNAL_METHOD_NAMES_GENERAL, SIGNAL_METHOD_NAMES_GJS]
+}

package/src/dependency-manager.ts

@@ -0,0 +1,91 @@
+import { findFileInDirs } from './utils.js'
+import { Logger } from './logger.js'
+
+import type { Dependency, GenerateConfig, GirInclude } from './types/index.js'
+
+export class DependencyManager {
+    protected log: Logger
+
+    cache: { [key: string]: Dependency } = {}
+
+    static instance: DependencyManager
+
+    protected constructor(protected readonly config: GenerateConfig) {
+        this.log = new Logger(config.environment, config.verbose, 'DependencyManager')
+    }
+
+    /**
+     * Get the DependencyManager singleton instance
+     */
+    static getInstance(config: GenerateConfig): DependencyManager {
+        if (this.instance) {
+            return this.instance
+        }
+        this.instance = new DependencyManager(config)
+        return this.instance
+    }
+
+    /**
+     * Get the dependency object by namespace and version
+     * @param namespace The namespace of the dependency
+     * @param version The version of the dependency
+     * @returns The dependency object
+     */
+    get(namespace: string, version: string): Dependency {
+        const packageName = `${namespace}-${version}`
+        if (this.cache[packageName]) {
+            return this.cache[packageName]
+        }
+        const filename = `${packageName}.gir`
+        const { exists, path } = findFileInDirs(this.config.girDirectories, filename)
+        const dependency: Dependency = {
+            namespace,
+            exists,
+            filename,
+            path,
+            packageName,
+            version,
+        }
+
+        this.cache[packageName] = dependency
+
+        return dependency
+    }
+
+    /**
+     * Transforms a gir include object array to a dependency object array
+     * @param girIncludes - Array of gir includes
+     * @returns Array of dependencies
+     */
+    fromGirIncludes(girIncludes: GirInclude[]): Dependency[] {
+        const dependencies: Dependency[] = []
+        for (const i of girIncludes) {
+            dependencies.unshift(this.get(i.$.name, i.$.version || '0.0'))
+        }
+        return dependencies
+    }
+
+    /**
+     * Find a dependency by it's namespace from the cache
+     * @param namespace The namespace of the dependency
+     * @returns The dependency object or null if not found
+     */
+    find(namespace: string): Dependency | null {
+        const packageNames = Object.keys(this.cache)
+        const candidates = packageNames.filter((packageName) => {
+            return packageName.startsWith(`${namespace}-`) && this.cache[packageName].namespace === namespace
+        })
+
+        if (candidates.length > 1) {
+            this.log.warn(`Found multiple versions of ${namespace}: ${candidates.join(', ')}`)
+        }
+
+        const latestVersion = candidates.sort().pop()
+
+        if (latestVersion) {
+            return this.cache[latestVersion]
+        }
+
+        return null
+    }
+}

package/src/generation-handler.ts

@@ -0,0 +1,79 @@
+import { mkdir } from 'fs/promises'
+import { GirModule } from './gir-module.js'
+import { Generator } from './generator.js'
+import TypeDefinitionGenerator from './type-definition-generator.js'
+import HTMLDocGenerator from './html-doc-generator.js'
+import { Logger } from './logger.js'
+import { getEnvironmentDir } from './utils.js'
+import { InheritanceTable, GenerateConfig, GirModulesGrouped, GeneratorType } from './types/index.js'
+import {
+    START_MODULE,
+    FILE_PARSING_DONE,
+    TSDATA_PARSING_DONE,
+    GENERATING_TYPES_DONE,
+    ERROR_NO_MODULE_SPECIFIED,
+} from './messages.js'
+
+export class GenerationHandler {
+    log: Logger
+    generator: Generator
+    constructor(private readonly config: GenerateConfig, type: GeneratorType) {
+        this.log = new Logger(config.environment, config.verbose, 'GenerationHandler')
+
+        switch (type) {
+            case GeneratorType.TYPES:
+                this.generator = new TypeDefinitionGenerator(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))
+
+        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.finalizeInheritance(inheritanceTable)
+
+        this.log.info(TSDATA_PARSING_DONE)
+
+        for (const girModule of girModules) {
+            if (this.config.outdir) {
+                const outputDir = getEnvironmentDir(this.config.environment, this.config.outdir)
+                await mkdir(outputDir, { recursive: true })
+            }
+            this.log.log(` - ${girModule.packageName} ...`)
+            girModule.start()
+        }
+
+        await this.generator.start(girModules, girModulesGrouped, inheritanceTable)
+
+        this.log.success(GENERATING_TYPES_DONE)
+    }
+}

package/src/generator.ts

@@ -0,0 +1,10 @@
+import type { InheritanceTable, GirModulesGrouped } from './types/index.js'
+import type { GirModule } from './gir-module.js'
+
+export interface Generator {
+    start(
+        girModules: GirModule[],
+        girModulesGrouped: GirModulesGrouped[],
+        inheritanceTable: InheritanceTable,
+    ): Promise<void>
+}