@ts-for-gir/cli 4.0.0-beta.9 → 4.0.0-rc.1

package/src/config.ts

@@ -1,460 +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,
-        promisify: true,
-        npmScope: '@girs',
-        workspace: false,
-        onlyVersionPrefix: false,
-        noPrettyPrint: false,
-        // Disabled by default because advanced variants are complicated,
-        // it does impact performance (especially on older typescript versions)
-        // and we'd need to test it works with the updated bindings
-        noAdvancedVariants: true,
-        package: 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: 'Skip prompts for library version selection when multiple versions are detected',
-            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: 'Specify a custom name for the configuration file',
-            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,
-        },
-        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,
-        },
-        workspace: {
-            type: 'boolean',
-            description:
-                'Uses the workspace protocol for the generated packages which can be used with package managers like Yarn and PNPM',
-            default: Config.defaults.workspace,
-            normalize: true,
-        },
-        onlyVersionPrefix: {
-            type: 'boolean',
-            description:
-                'Only use the version prefix for the ambient module exports. This is useful if, for whatever reason, you want to use different library versions of the same library in your project.',
-            default: Config.defaults.onlyVersionPrefix,
-            normalize: true,
-        },
-        noPrettyPrint: {
-            type: 'boolean',
-            description: 'Do not prettify the generated types',
-            default: Config.defaults.noPrettyPrint,
-            normalize: true,
-        },
-        noAdvancedVariants: {
-            type: 'boolean',
-            description: 'Disable GLib.Variant class with string parsing',
-            default: Config.defaults.noAdvancedVariants,
-            normalize: true,
-        },
-        package: {
-            type: 'boolean',
-            description: 'Generate the typescript types with package.json support',
-            default: Config.defaults.package,
-            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,
-        promisify: this.options.promisify,
-        npmScope: this.options.npmScope,
-        workspace: this.options.workspace,
-        onlyVersionPrefix: this.options.onlyVersionPrefix,
-        noPrettyPrint: this.options.noPrettyPrint,
-        noAdvancedVariants: this.options.noAdvancedVariants,
-        package: this.options.package,
-    }
-
-    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 = {
-            ...config,
-        }
-        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 = {
-            ...options,
-        }
-
-        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
-            }
-            // 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
-            }
-            // workspace
-            if (
-                config.workspace === Config.options.workspace.default &&
-                typeof configFileData.workspace === 'boolean'
-            ) {
-                config.workspace = configFileData.workspace
-            }
-            // onlyVersionPrefix
-            if (
-                config.onlyVersionPrefix === Config.options.onlyVersionPrefix.default &&
-                typeof configFileData.onlyVersionPrefix === 'boolean'
-            ) {
-                config.onlyVersionPrefix = configFileData.onlyVersionPrefix
-            }
-            // noPrettyPrint
-            if (
-                config.noPrettyPrint === Config.options.noPrettyPrint.default &&
-                typeof configFileData.noPrettyPrint === 'boolean'
-            ) {
-                config.noPrettyPrint = configFileData.noPrettyPrint
-            }
-            // noAdvancedVariants
-            if (
-                config.noAdvancedVariants === Config.options.noAdvancedVariants.default &&
-                typeof configFileData.noAdvancedVariants === 'boolean'
-            ) {
-                config.noAdvancedVariants = configFileData.noAdvancedVariants
-            }
-            // package
-            if (config.package === Config.options.package.default && typeof configFileData.package === 'boolean') {
-                config.package = configFileData.package
-            }
-        }
-
-        // 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'
+	conflictsReporter,
+	ERROR_NO_MODULE_SPECIFIED,
+	FILE_PARSING_DONE,
+	GENERATING_TYPES_DONE,
+	type GirModule,
+	girParsingReporter,
+	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, girModules)
-
-        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 reporters globally
+		TypeIdentifier.configureReporter(config.reporter, config.reporterOutput);
+		conflictsReporter.configure(config.reporter, config.reporterOutput);
+		girParsingReporter.configure(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 {
+			// Generate report once, pass to print and save
+			const report = this.reporterService.generateComprehensiveReport();
+
+			this.reporterService.printComprehensiveSummary(report);
+			await this.reporterService.saveComprehensiveReport(undefined, report);
+
+			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";