@ts-for-gir/cli 4.0.0-beta.4 → 4.0.0-beta.40

package/src/config.ts

@@ -1,454 +1,7 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /**
  * Default values, parse the config file and handle CLI flags
+ *
+ * This file re-exports all config functionality from the config module
  */
-import { Options } from 'yargs'
-import { cosmiconfig, Options as ConfigSearchOptions } from 'cosmiconfig'
-import { join, extname, dirname, resolve } from 'path'
-import { writeFile } from 'fs/promises'
-import { existsSync } from 'fs'
-import { merge, isEqual, Logger, APP_NAME, APP_USAGE, ERROR_CONFIG_EXTENSION_UNSUPPORTED } from '@ts-for-gir/lib'
 
-import type { UserConfig, ConfigFlags, UserConfigLoadResult, OptionsGeneration } from '@ts-for-gir/lib'
-
-export class Config {
-    static appName = APP_NAME
-
-    static usage = APP_USAGE
-
-    /**
-     * Default cli flag and argument values
-     */
-    static defaults = {
-        print: false,
-        configName: '.ts-for-girrc.js',
-        root: process.cwd(),
-        outdir: './@types',
-        girDirectories: getDefaultGirDirectories(),
-        modules: ['*'],
-        ignore: [],
-        verbose: false,
-        ignoreVersionConflicts: false,
-        noNamespace: false,
-        noComments: false,
-        noDebugComments: false,
-        fixConflicts: true,
-        promisify: true,
-        npmScope: '@girs',
-        packageYarn: false,
-    }
-
-    static configFilePath = join(process.cwd(), Config.defaults.configName)
-
-    /**
-     * CLI options used in commands/generate.ts and commands/list.ts
-     */
-    static options: { [name: string]: Options } = {
-        modules: {
-            description: "GIR modules to load, e.g. 'Gio-2.0'. Accepts multiple modules",
-            array: true,
-            default: Config.defaults.modules,
-            normalize: true,
-        },
-        girDirectories: {
-            type: 'string',
-            alias: 'g',
-            description: 'GIR directories',
-            array: true,
-            default: Config.defaults.girDirectories,
-            normalize: true,
-        },
-        root: {
-            type: 'string',
-            description: 'Root directory of your project',
-            default: Config.defaults.root,
-            normalize: true,
-        },
-        outdir: {
-            type: 'string',
-            alias: 'o',
-            description: 'Directory to output to',
-            default: Config.defaults.outdir,
-            normalize: true,
-        },
-        ignore: {
-            type: 'string',
-            alias: 'i',
-            description: 'Modules that should be ignored',
-            array: true,
-            default: Config.defaults.ignore,
-            normalize: true,
-        },
-        verbose: {
-            type: 'boolean',
-            alias: 'v',
-            description: 'Switch on/off the verbose mode',
-            default: Config.defaults.verbose,
-            normalize: true,
-        },
-        ignoreVersionConflicts: {
-            type: 'boolean',
-            description: 'Do not ask for package versions if multiple versions are found',
-            default: Config.defaults.ignoreVersionConflicts,
-            normalize: true,
-        },
-        print: {
-            type: 'boolean',
-            alias: 'p',
-            description: 'Print the output to console and create no files',
-            default: Config.defaults.print,
-            normalize: true,
-        },
-        configName: {
-            type: 'string',
-            description: 'Name of the config if you want to use a different name',
-            default: Config.defaults.configName,
-            normalize: true,
-        },
-        noNamespace: {
-            type: 'boolean',
-            alias: 'd',
-            description: 'Do not export all symbols for each module as a namespace',
-            default: Config.defaults.noNamespace,
-            normalize: true,
-        },
-        noComments: {
-            type: 'boolean',
-            alias: 'n',
-            description: 'Do not generate documentation comments',
-            default: Config.defaults.noComments,
-            normalize: true,
-        },
-        noDebugComments: {
-            type: 'boolean',
-            description: 'Do not generate debugging inline comments',
-            default: Config.defaults.noDebugComments,
-            normalize: true,
-        },
-        fixConflicts: {
-            type: 'boolean',
-            description: 'Fix Inheritance and implementation type conflicts',
-            default: Config.defaults.fixConflicts,
-            normalize: true,
-        },
-        promisify: {
-            type: 'boolean',
-            description: 'Generate promisified functions for async/finish calls',
-            default: Config.defaults.promisify,
-            normalize: true,
-        },
-        npmScope: {
-            type: 'string',
-            description: 'Scope of the generated NPM packages',
-            default: Config.defaults.npmScope,
-            normalize: true,
-        },
-        packageYarn: {
-            type: 'boolean',
-            description: 'Adds Yarn workspace support to the NPM packages',
-            default: Config.defaults.packageYarn,
-            normalize: true,
-        },
-    }
-
-    /**
-     * CLI flags used in commands/generate.ts
-     */
-    static generateOptions = {
-        modules: this.options.modules,
-        girDirectories: this.options.girDirectories,
-        root: this.options.root,
-        outdir: this.options.outdir,
-        ignore: this.options.ignore,
-        verbose: this.options.verbose,
-        ignoreVersionConflicts: this.options.ignoreVersionConflicts,
-        print: this.options.print,
-        configName: this.options.configName,
-        noNamespace: this.options.noNamespace,
-        noComments: this.options.noComments,
-        noDebugComments: this.options.noDebugComments,
-        fixConflicts: this.options.fixConflicts,
-        promisify: this.options.promisify,
-        npmScope: this.options.npmScope,
-        packageYarn: this.options.packageYarn,
-    }
-
-    static listOptions = {
-        modules: this.options.modules,
-        girDirectories: Config.options.girDirectories,
-        root: this.options.root,
-        ignore: Config.options.ignore,
-        configName: Config.options.configName,
-        verbose: Config.options.verbose,
-    }
-
-    static copyOptions = {
-        modules: this.options.modules,
-        girDirectories: Config.options.girDirectories,
-        root: this.options.root,
-        outdir: Config.options.outdir,
-        ignore: Config.options.ignore,
-        configName: Config.options.configName,
-        verbose: Config.options.verbose,
-    }
-
-    static docOptions = {
-        modules: this.options.modules,
-        girDirectories: Config.options.girDirectories,
-        root: this.options.root,
-        outdir: Config.options.outdir,
-        ignore: Config.options.ignore,
-        verbose: Config.options.verbose,
-        ignoreVersionConflicts: Config.options.ignoreVersionConflicts,
-        configName: Config.options.configName,
-    }
-
-    /**
-     * Overwrites values in the user config file
-     * @param configsToAdd
-     */
-    public static async addToConfig(configsToAdd: Partial<UserConfig>, configName?: string): Promise<void> {
-        const userConfig = await this.loadConfigFile(configName)
-        const path = userConfig?.filepath || this.configFilePath
-        const configToStore = {}
-        merge(configToStore, userConfig?.config || {}, configsToAdd)
-        const fileExtension = extname(path)
-        let writeConfigString = ''
-        switch (fileExtension) {
-            case '.js':
-                writeConfigString = `export default ${JSON.stringify(configToStore, null, 4)}`
-                break
-            case '.json':
-                writeConfigString = `${JSON.stringify(configToStore, null, 4)}`
-                break
-            default:
-                Logger.error(ERROR_CONFIG_EXTENSION_UNSUPPORTED)
-                break
-        }
-        if (writeConfigString && path) {
-            return writeFile(path, writeConfigString)
-        }
-    }
-
-    /**
-     * The user can create a `.ts-for-girrc` file for his default configs,
-     * this method load this config file an returns the user configuration
-     * @param configName If the user uses a custom config file name
-     */
-    private static async loadConfigFile(configName?: string): Promise<UserConfigLoadResult | null> {
-        const configSearchOptions: Partial<ConfigSearchOptions> = {
-            loaders: {
-                // ESM loader
-                '.js': async (filepath) => {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    const file = await import(filepath)
-
-                    // Files with `exports.default = { ... }`
-                    if (file?.default?.default) {
-                        return file.default.default as Partial<UserConfig>
-                    }
-                    // Files with `export default { ... }`
-                    if (file?.default) {
-                        return file.default as Partial<UserConfig>
-                    }
-                    // Files with `export { ... }`
-                    return file as Partial<UserConfig>
-                },
-            },
-        }
-        if (configName) {
-            configSearchOptions.searchPlaces = [configName]
-        }
-        const configFile: UserConfigLoadResult | null = await cosmiconfig(Config.appName, configSearchOptions).search()
-        if (configFile?.filepath) {
-            Config.configFilePath = configFile.filepath
-        }
-
-        return configFile
-    }
-
-    public static getOptionsGeneration(config: UserConfig): OptionsGeneration {
-        const generateConfig: OptionsGeneration = {
-            girDirectories: config.girDirectories,
-            root: config.root,
-            outdir: config.outdir,
-            verbose: config.verbose,
-            noNamespace: config.noNamespace,
-            noComments: config.noComments,
-            noDebugComments: config.noDebugComments,
-            fixConflicts: config.fixConflicts,
-            promisify: config.promisify,
-            npmScope: config.npmScope,
-            packageYarn: config.packageYarn,
-            noPrettyPrint: false,
-            noAdvancedVariants: true,
-        }
-        return generateConfig
-    }
-
-    public static validate(config: UserConfig): UserConfig {
-        return config
-    }
-
-    /**
-     * Loads the values of the config file and concatenate them with passed cli flags / arguments.
-     * The values from config file are preferred if the cli flag value is the default (and so not set / overwritten)
-     * @param options
-     */
-    public static async load(options: ConfigFlags): Promise<UserConfig> {
-        const configFile = await this.loadConfigFile(options.configName)
-        const configFileData = configFile?.config || {}
-
-        const config: UserConfig = {
-            verbose: options.verbose,
-            ignoreVersionConflicts: options.ignoreVersionConflicts,
-            print: options.print,
-            root: options.root,
-            outdir: options.outdir,
-            girDirectories: options.girDirectories,
-            ignore: options.ignore,
-            modules: options.modules,
-            noNamespace: options.noNamespace,
-            noComments: options.noComments,
-            noDebugComments: options.noDebugComments,
-            fixConflicts: options.fixConflicts,
-            promisify: options.promisify,
-            npmScope: options.npmScope,
-            packageYarn: options.packageYarn,
-        }
-
-        if (configFileData) {
-            // verbose
-            if (config.verbose === Config.options.verbose.default && typeof configFileData.verbose === 'boolean') {
-                config.verbose = configFileData.verbose
-            }
-            // ignoreVersionConflicts
-            if (
-                config.ignoreVersionConflicts === Config.options.ignoreVersionConflicts.default &&
-                typeof configFileData.ignoreVersionConflicts === 'boolean'
-            ) {
-                config.ignoreVersionConflicts = configFileData.ignoreVersionConflicts
-            }
-            // print
-            if (config.print === Config.options.print.default && typeof configFileData.print === 'boolean') {
-                config.print = configFileData.print
-            }
-            // root
-            if (config.root === Config.options.root.default && (configFileData.root || configFile?.filepath)) {
-                // Use the config file path as the root path if no root path is set
-                config.root =
-                    configFileData.root ||
-                    (configFile?.filepath ? dirname(configFile.filepath) : (Config.options.root.default as string))
-            }
-            // outdir
-            if (config.outdir === Config.options.outdir.default && configFileData.outdir) {
-                config.outdir = config.print ? null : configFileData.outdir
-            }
-            // girDirectories
-            if (config.girDirectories === Config.options.girDirectories.default && configFileData.girDirectories) {
-                config.girDirectories = configFileData.girDirectories
-            }
-            // ignore
-            if (
-                (!config.ignore || config.ignore.length <= 0 || isEqual(config.ignore, Config.defaults.ignore)) &&
-                configFileData.ignore
-            ) {
-                config.ignore = configFileData.ignore
-            }
-            // modules
-            if (
-                (config.modules.length <= 0 || isEqual(config.modules, Config.defaults.modules)) &&
-                configFileData.modules
-            ) {
-                config.modules = configFileData.modules
-            }
-            // noNamespace
-            if (
-                config.noNamespace === Config.options.noNamespace.default &&
-                typeof configFileData.noNamespace === 'boolean'
-            ) {
-                config.noNamespace = configFileData.noNamespace
-            }
-            // noComments
-            if (
-                config.noComments === Config.options.noComments.default &&
-                typeof configFileData.noComments === 'boolean'
-            ) {
-                config.noComments = configFileData.noComments
-            }
-            // noDebugComments
-            if (
-                config.noDebugComments === Config.options.noDebugComments.default &&
-                typeof configFileData.noDebugComments === 'boolean'
-            ) {
-                config.noDebugComments = configFileData.noDebugComments
-            }
-            // fixConflicts
-            if (
-                config.fixConflicts === Config.options.fixConflicts.default &&
-                typeof configFileData.fixConflicts === 'boolean'
-            ) {
-                config.fixConflicts = configFileData.fixConflicts
-            }
-            // promisify
-            if (
-                config.promisify === Config.options.promisify.default &&
-                typeof configFileData.promisify === 'boolean'
-            ) {
-                config.promisify = configFileData.promisify
-            }
-            // npmScope
-            if (config.npmScope === Config.options.npmScope.default && configFileData.npmScope) {
-                config.npmScope = configFileData.npmScope
-            }
-            // packageYarn
-            if (
-                config.packageYarn === Config.options.packageYarn.default &&
-                typeof configFileData.packageYarn === 'boolean'
-            ) {
-                config.packageYarn = configFileData.packageYarn
-            }
-        }
-
-        // If outdir is not absolute, make it absolute to the root path
-        if (config.outdir && !config.outdir?.startsWith('/')) {
-            config.outdir = resolve(config.root, config.outdir)
-        }
-
-        // Same for girDirectories
-        if (config.girDirectories) {
-            config.girDirectories = config.girDirectories.map((dir) => {
-                if (!dir.startsWith('/')) {
-                    return resolve(config.root, dir)
-                }
-                return dir
-            })
-        }
-
-        return this.validate(config)
-    }
-}
-
-function getDefaultGirDirectories(): string[] {
-    const girDirectories = [
-        '/usr/local/share/gir-1.0',
-        '/usr/share/gir-1.0',
-        '/usr/share/*/gir-1.0',
-        '/usr/share/gnome-shell',
-        '/usr/share/gnome-shell/gir-1.0',
-        '/usr/lib64/mutter-*',
-        '/usr/lib/mutter-*',
-        '/usr/lib/x86_64-linux-gnu/mutter-*',
-    ]
-    // NixOS and other distributions does not have a /usr/local/share directory.
-    // Instead, the nix store paths with Gir files are set as XDG_DATA_DIRS.
-    // See https://github.com/NixOS/nixpkgs/blob/96e18717904dfedcd884541e5a92bf9ff632cf39/pkgs/development/libraries/gobject-introspection/setup-hook.sh#L7-L10
-    const dataDirs = process.env['XDG_DATA_DIRS']?.split(':') || []
-    for (let dataDir of dataDirs) {
-        dataDir = join(dataDir, 'gir-1.0')
-        if (!girDirectories.includes(dataDir) && existsSync(dataDir)) {
-            girDirectories.push(dataDir)
-        }
-    }
-    return girDirectories
-}
+export * from "./config/index.ts";

package/src/formatters/typescript-formatter.ts

@@ -0,0 +1,24 @@
+/**
+ * TypeScript formatter using Prettier
+ */
+
+import { Formatter, Logger } from "@ts-for-gir/lib";
+import prettier from "prettier";
+
+const logger = new Logger(false, "TypeScriptFormatter");
+
+export class TypeScriptFormatter extends Formatter {
+	format(input: string): Promise<string> {
+		try {
+			return prettier.format(input, {
+				singleQuote: true,
+				parser: "typescript",
+				printWidth: 120,
+				tabWidth: 4,
+			});
+		} catch (error) {
+			logger.warn("Failed to format with prettier, returning original input", error);
+			return Promise.resolve(input);
+		}
+	}
+}

package/src/generation-handler.ts

@@ -1,71 +1,126 @@
-import { mkdir } from 'fs/promises'
+import { mkdir } from "node:fs/promises";
+import { type Generator, GeneratorType } from "@ts-for-gir/generator-base";
+import { HtmlDocGenerator } from "@ts-for-gir/generator-html-doc";
+import { JsonDefinitionGenerator } from "@ts-for-gir/generator-json";
+import { TypeDefinitionGenerator } from "@ts-for-gir/generator-typescript";
 import {
-    GirModule,
-    Logger,
-    START_MODULE,
-    FILE_PARSING_DONE,
-    TSDATA_PARSING_DONE,
-    GENERATING_TYPES_DONE,
-    ERROR_NO_MODULE_SPECIFIED,
-} 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 type { OptionsGeneration, NSRegistry } from '@ts-for-gir/lib'
+	configureConflictsReporter,
+	ERROR_NO_MODULE_SPECIFIED,
+	FILE_PARSING_DONE,
+	GENERATING_TYPES_DONE,
+	type GirModule,
+	type NSRegistry,
+	type OptionsGeneration,
+	Reporter,
+	ReporterService,
+	START_MODULE,
+	TSDATA_PARSING_DONE,
+	TypeIdentifier,
+} from "@ts-for-gir/lib";
 
 export class GenerationHandler {
-    log: Logger
-    generator: Generator
-
-    constructor(
-        private readonly config: OptionsGeneration,
-        type: GeneratorType,
-    ) {
-        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
-            default:
-                throw new Error('Unknown Generator')
-        }
-    }
-
-    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)
-        }
-
-        this.log.info(FILE_PARSING_DONE)
-
-        this.log.info(TSDATA_PARSING_DONE)
-
-        if (this.config.outdir) {
-            await mkdir(this.config.outdir, { recursive: true })
-        }
-
-        // 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) {
-            this.log.log(` - ${girModule.packageName} ...`)
-            await this.generator.generate(registry, girModule)
-        }
-
-        await this.generator.finish(registry)
-
-        this.log.success(GENERATING_TYPES_DONE)
-    }
+	log: Reporter;
+	generator: Generator;
+	protected readonly config: OptionsGeneration;
+	protected readonly registry: NSRegistry;
+	private readonly reporterService: ReporterService;
+
+	constructor(config: OptionsGeneration, type: GeneratorType, registry: NSRegistry) {
+		this.registry = registry;
+		this.config = config;
+		this.log = new Reporter(config.verbose, "GenerationHandler", config.reporter, config.reporterOutput);
+		this.reporterService = ReporterService.getInstance();
+
+		// Configure the reporter service
+		this.reporterService.configure(config.reporter, config.reporterOutput);
+
+		// Configure TypeIdentifier and ConflictsReporter globally
+		TypeIdentifier.configureReporter(config.reporter, config.reporterOutput);
+		configureConflictsReporter(config.reporter, config.reporterOutput);
+
+		// Register the main handler reporter
+		if (config.reporter) {
+			this.reporterService.registerReporter("GenerationHandler", this.log);
+		}
+
+		switch (type) {
+			case GeneratorType.TYPES:
+				this.generator = new TypeDefinitionGenerator(config, this.registry);
+				break;
+			case GeneratorType.HTML_DOC:
+				this.generator = new HtmlDocGenerator(config, this.registry);
+				break;
+			case GeneratorType.JSON:
+				this.generator = new JsonDefinitionGenerator(config, this.registry);
+				break;
+			default:
+				throw new Error("Unknown Generator");
+		}
+	}
+
+	public async start(girModules: GirModule[]): Promise<void> {
+		this.log.info(START_MODULE);
+
+		if (girModules.length === 0) {
+			this.log.error(ERROR_NO_MODULE_SPECIFIED);
+		}
+
+		this.log.info(FILE_PARSING_DONE);
+
+		this.log.info(TSDATA_PARSING_DONE);
+
+		try {
+			if (this.config.outdir) {
+				await mkdir(this.config.outdir, { recursive: true });
+			}
+
+			// TODO: Put this somewhere that makes sense
+			this.registry.transform({
+				inferGenerics: true,
+				verbose: this.config.verbose,
+				reporter: this.config.reporter,
+				reporterOutput: this.config.reporterOutput,
+			});
+
+			await this.generator.start();
+
+			for (const girModule of girModules) {
+				this.log.log(` - ${girModule.packageName} ...`);
+				await this.generator.generate(girModule);
+			}
+
+			await this.generator.finish(girModules);
+
+			this.log.success(GENERATING_TYPES_DONE);
+		} finally {
+			// Generate comprehensive report if reporter is enabled
+			// This will run even if there's an error
+			if (this.config.reporter) {
+				await this.generateComprehensiveReport();
+			}
+		}
+	}
+
+	private async generateComprehensiveReport(): Promise<void> {
+		try {
+			// Print comprehensive summary to console
+			this.reporterService.printComprehensiveSummary();
+
+			// Save comprehensive report to file
+			await this.reporterService.saveComprehensiveReport();
+
+			// Log final statistics
+			const report = this.reporterService.generateComprehensiveReport();
+			const totalProblems = report.statistics.totalProblems;
+			const modulesProcessed = this.reporterService.getReporters().size;
+
+			if (totalProblems > 0) {
+				this.log.info(`📊 Generated comprehensive report: ${totalProblems} issues across ${modulesProcessed} modules`);
+			} else {
+				this.log.success("🎉 Generation completed without any reported issues across all modules!");
+			}
+		} catch (error) {
+			this.log.danger(`Failed to generate comprehensive report: ${error}`);
+		}
+	}
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from './commands/index.js'
-export * from './config.js'
-export * from './generation-handler.js'
-export * from './module-loader.js'
+export * from "./commands/index.ts";
+export * from "./config.ts";
+export * from "./generation-handler.ts";
+export * from "./module-loader.ts";