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

package/src/commands/doc.ts

@@ -28,26 +28,23 @@ const builder: BuilderCallback<any, ConfigFlags> = (yargs: Argv<any>) => {
 const handler = async (args: ConfigFlags) => {
     const config = await Config.load(args)
 
-    for (let i = 0; i < config.environments.length; i++) {
-        if (config.environments[i]) {
-            const generateConfig = Config.getGenerateConfig(config, config.environments[i])
-            const moduleLoader = new ModuleLoader(generateConfig)
-            const { keep, grouped } = await moduleLoader.getModulesResolved(
-                config.modules,
-                config.ignore || [],
-                config.ignoreVersionConflicts,
-            )
-            if (keep.length === 0) {
-                return Logger.error(ERROR_NO_MODULES_FOUND(config.girDirectories))
-            }
-            const tsForGir = new GenerationHandler(generateConfig, GeneratorType.HTML_DOC)
-
-            await tsForGir.start(
-                Array.from(keep).map((girModuleResolvedBy) => girModuleResolvedBy.module),
-                Object.values(grouped),
-            )
-        }
+    const generateConfig = Config.getOptionsGeneration(config)
+    const moduleLoader = new ModuleLoader(generateConfig)
+    const { keep } = await moduleLoader.getModulesResolved(
+        config.modules,
+        config.ignore || [],
+        config.ignoreVersionConflicts,
+    )
+    if (keep.length === 0) {
+        return Logger.error(ERROR_NO_MODULES_FOUND(config.girDirectories))
     }
+    const tsForGir = new GenerationHandler(generateConfig, GeneratorType.HTML_DOC)
+    const registry = moduleLoader.dependencyManager
+
+    await tsForGir.start(
+        Array.from(keep).map((girModuleResolvedBy) => girModuleResolvedBy.module),
+        registry,
+    )
 }
 
 const examples: ReadonlyArray<[string, string?]> = []

package/src/commands/generate.ts

@@ -8,12 +8,14 @@ import { GeneratorType } from '@ts-for-gir/generator-base'
 import { GenerationHandler } from '../generation-handler.js'
 import { Config } from '../config.js'
 import { ModuleLoader } from '../module-loader.js'
+import prettier from 'prettier'
 
 import type { ConfigFlags } from '@ts-for-gir/lib'
+import { Formatter } from '@ts-for-gir/lib'
 
 const command = 'generate [modules..]'
 
-const description = 'Generates .d.ts files from GIR for GJS or node-gtk'
+const description = 'Generates Typescript type definition .d.ts files from GIR for GJS'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const builder: BuilderCallback<any, ConfigFlags> = (yargs: Argv<any>) => {
@@ -28,35 +30,35 @@ const builder: BuilderCallback<any, ConfigFlags> = (yargs: Argv<any>) => {
 const handler = async (args: ConfigFlags) => {
     const config = await Config.load(args)
 
-    for (const env of config.environments) {
-        const generateConfig = Config.getGenerateConfig(config, env)
-        const moduleLoader = new ModuleLoader(generateConfig)
-        const { keep, grouped } = await moduleLoader.getModulesResolved(
-            config.modules,
-            config.ignore || [],
-            config.ignoreVersionConflicts,
-        )
-        if (keep.length === 0) {
-            return Logger.error(ERROR_NO_MODULES_FOUND(config.girDirectories))
-        }
-        const tsForGir = new GenerationHandler(generateConfig, GeneratorType.TYPES)
-
-        const girModules = Array.from(keep).map((girModuleResolvedBy) => girModuleResolvedBy.module)
-        const girModulesGrouped = Object.values(grouped)
+    const generateConfig = Config.getOptionsGeneration(config)
+    const moduleLoader = new ModuleLoader(generateConfig)
+    const { keep } = await moduleLoader.getModulesResolved(
+        config.modules,
+        config.ignore || [],
+        config.ignoreVersionConflicts,
+    )
 
-        await tsForGir.start(girModules, girModulesGrouped)
+    if (keep.length === 0) {
+        return Logger.error(ERROR_NO_MODULES_FOUND(config.girDirectories))
     }
+
+    moduleLoader.parse(keep)
+
+    const tsForGir = new GenerationHandler(generateConfig, GeneratorType.TYPES)
+
+    const girModules = Array.from(keep).map((girModuleResolvedBy) => girModuleResolvedBy.module)
+
+    moduleLoader.dependencyManager.registerFormatter('dts', new TypeScriptFormatter())
+    await tsForGir.start(girModules, moduleLoader.dependencyManager)
 }
 
 const examples: ReadonlyArray<[string, string?]> = [
     [
         `${Config.appName} generate`,
-        `Run '${Config.appName} generate' in your gjs or node-gtk project to generate typings for your project, pass the gir modules you need for your project`,
+        `Run '${Config.appName} generate' in your gjs project to generate typings for your project, pass the gir modules you need for your project`,
     ],
     [`${Config.appName} generate Gtk*`, 'You can also use wild cards'],
     [`${Config.appName} generate '*'`, 'If you want to parse all of your locally installed gir modules run'],
-    [`${Config.appName} generate '*' -e gjs`, 'Generate .d.ts. files only for gjs'],
-    [`${Config.appName} generate '*' -e node`, 'Generate .d.ts. files only for node'],
     [`${Config.appName} generate --configName='.ts-for-gir.gtk4.rc.js`, 'Use a special config file'],
     [
         `${Config.appName} generate --ignore=Gtk-4.0 xrandr-1.3`,
@@ -64,6 +66,21 @@ const examples: ReadonlyArray<[string, string?]> = [
     ],
 ]
 
+class TypeScriptFormatter extends Formatter {
+    format(input: string): Promise<string> {
+        try {
+            return prettier.format(input, {
+                singleQuote: true,
+                parser: 'typescript',
+                printWidth: 120,
+                tabWidth: 4,
+            })
+        } catch (error) {
+            return Promise.resolve(input)
+        }
+    }
+}
+
 export const generate = {
     command,
     description,

package/src/commands/index.ts

@@ -1,3 +1,4 @@
+export * from './copy.js'
 export * from './doc.js'
 export * from './generate.js'
 export * from './list.js'

package/src/commands/list.ts

@@ -25,7 +25,7 @@ const builder: BuilderCallback<any, ConfigFlags> = (yargs: Argv<any>) => {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const handler = async (args: ConfigFlags) => {
     const config = await Config.load(args)
-    const generateConfig = Config.getGenerateConfig(config)
+    const generateConfig = Config.getOptionsGeneration(config)
     const moduleLoader = new ModuleLoader(generateConfig)
     const { grouped, failed } = await moduleLoader.getModules(config.modules, config.ignore)
     const moduleGroups = Object.values(grouped)
@@ -43,10 +43,16 @@ const handler = async (args: ConfigFlags) => {
         (moduleGroup) => moduleGroup.modules[0].resolvedBy === ResolveType.DEPENDENCE,
     )
 
+    Logger.info('\nSearch for gir files in:')
+    for (const dir of config.girDirectories) {
+        Logger.white(`- ${dir}`)
+    }
+
     Logger.info('\nSelected Modules:')
     for (const moduleGroup of byHandModules) {
         for (const depModule of moduleGroup.modules) {
             Logger.white(`- ${depModule.packageName}`)
+            Logger.gray(`  - ${depModule.path}`)
         }
     }
 
@@ -55,6 +61,7 @@ const handler = async (args: ConfigFlags) => {
         for (const moduleGroup of depModules) {
             for (const depModule of moduleGroup.modules) {
                 Logger.white(`- ${depModule.packageName}`)
+                Logger.gray(`- ${depModule.path}`)
             }
         }
     }
@@ -65,6 +72,7 @@ const handler = async (args: ConfigFlags) => {
             Logger.white(`- ${moduleGroup.namespace}`)
             for (const conflictModule of moduleGroup.modules) {
                 Logger.white(`  - ${conflictModule.packageName}`)
+                Logger.gray(`  - ${conflictModule.path}`)
             }
         }
     }

package/src/config.ts

@@ -6,18 +6,10 @@ import { Options } from 'yargs'
 import { cosmiconfig, Options as ConfigSearchOptions } from 'cosmiconfig'
 import { join, extname, dirname, resolve } from 'path'
 import { writeFile } from 'fs/promises'
-import {
-    merge,
-    isEqual,
-    Logger,
-    APP_NAME,
-    APP_USAGE,
-    ERROR_CONFIG_EXTENSION_UNSUPPORTED,
-    WARN_USE_ESM_FOR_ALIAS,
-    WARN_USE_GJS_FOR_ALIAS,
-} from '@ts-for-gir/lib'
+import { existsSync } from 'fs'
+import { merge, isEqual, Logger, APP_NAME, APP_USAGE, ERROR_CONFIG_EXTENSION_UNSUPPORTED } from '@ts-for-gir/lib'
 
-import type { Environment, UserConfig, ConfigFlags, UserConfigLoadResult, GenerateConfig } from '@ts-for-gir/lib'
+import type { UserConfig, ConfigFlags, UserConfigLoadResult, OptionsGeneration } from '@ts-for-gir/lib'
 
 export class Config {
     static appName = APP_NAME
@@ -28,7 +20,6 @@ export class Config {
      * Default cli flag and argument values
      */
     static defaults = {
-        environments: ['gjs'],
         print: false,
         configName: '.ts-for-girrc.js',
         root: process.cwd(),
@@ -39,16 +30,17 @@ export class Config {
         verbose: false,
         ignoreVersionConflicts: false,
         noNamespace: false,
-        buildType: 'lib',
-        moduleType: 'esm',
         noComments: false,
-        noDebugComments: false,
-        fixConflicts: true,
-        generateAlias: 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,
-        packageYarn: false,
     }
 
     static configFilePath = join(process.cwd(), Config.defaults.configName)
@@ -84,15 +76,6 @@ export class Config {
             default: Config.defaults.outdir,
             normalize: true,
         },
-        environments: {
-            type: 'string',
-            alias: 'e',
-            description: 'Javascript environment',
-            array: true,
-            choices: ['gjs', 'node'],
-            default: Config.defaults.environments,
-            normalize: true,
-        },
         ignore: {
             type: 'string',
             alias: 'i',
@@ -101,23 +84,6 @@ export class Config {
             default: Config.defaults.ignore,
             normalize: true,
         },
-        buildType: {
-            type: 'string',
-            alias: 'b',
-            description: 'Definitions generation type',
-            array: false,
-            choices: ['lib', 'types'],
-            default: Config.defaults.buildType,
-            normalize: true,
-        },
-        moduleType: {
-            type: 'string',
-            alias: 't',
-            description: 'Specify what module code is generated.',
-            choices: ['esm', 'commonjs', 'cjs'],
-            default: Config.defaults.moduleType,
-            normalize: true,
-        },
         verbose: {
             type: 'boolean',
             alias: 'v',
@@ -127,7 +93,7 @@ export class Config {
         },
         ignoreVersionConflicts: {
             type: 'boolean',
-            description: 'Do not ask for package versions if multiple versions are found',
+            description: 'Skip prompts for library version selection when multiple versions are detected',
             default: Config.defaults.ignoreVersionConflicts,
             normalize: true,
         },
@@ -140,7 +106,7 @@ export class Config {
         },
         configName: {
             type: 'string',
-            description: 'Name of the config if you want to use a different name',
+            description: 'Specify a custom name for the configuration file',
             default: Config.defaults.configName,
             normalize: true,
         },
@@ -158,47 +124,48 @@ export class Config {
             default: Config.defaults.noComments,
             normalize: true,
         },
-        noDebugComments: {
+        promisify: {
             type: 'boolean',
-            description: 'Do not generate debugging inline comments',
-            default: Config.defaults.noDebugComments,
+            description: 'Generate promisified functions for async/finish calls',
+            default: Config.defaults.promisify,
             normalize: true,
         },
-        fixConflicts: {
-            type: 'boolean',
-            description: 'Fix Inheritance and implementation type conflicts',
-            default: Config.defaults.fixConflicts,
+        npmScope: {
+            type: 'string',
+            description: 'Scope of the generated NPM packages',
+            default: Config.defaults.npmScope,
             normalize: true,
         },
-        generateAlias: {
+        workspace: {
             type: 'boolean',
-            alias: 'a',
-            description: 'Generate an alias tsconfig file to support GJS ESM module imports',
-            default: Config.defaults.generateAlias,
+            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,
         },
-        promisify: {
+        onlyVersionPrefix: {
             type: 'boolean',
-            description: 'Generate promisified functions for async/finish calls',
-            default: Config.defaults.promisify,
+            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,
         },
-        npmScope: {
-            type: 'string',
-            description: 'Scope of the generated NPM packages',
-            default: Config.defaults.npmScope,
+        noPrettyPrint: {
+            type: 'boolean',
+            description: 'Do not prettify the generated types',
+            default: Config.defaults.noPrettyPrint,
             normalize: true,
         },
-        package: {
+        noAdvancedVariants: {
             type: 'boolean',
-            description: 'Generates an NPM compatible packages for each GIR module',
-            default: Config.defaults.package,
+            description: 'Disable GLib.Variant class with string parsing',
+            default: Config.defaults.noAdvancedVariants,
             normalize: true,
         },
-        packageYarn: {
+        package: {
             type: 'boolean',
-            description: 'Adds Yarn workspace support to the NPM packages',
-            default: Config.defaults.packageYarn,
+            description: 'Generate the typescript types with package.json support',
+            default: Config.defaults.package,
             normalize: true,
         },
     }
@@ -211,28 +178,36 @@ export class Config {
         girDirectories: this.options.girDirectories,
         root: this.options.root,
         outdir: this.options.outdir,
-        environments: this.options.environments,
         ignore: this.options.ignore,
-        buildType: this.options.buildType,
-        moduleType: this.options.moduleType,
         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,
-        generateAlias: this.options.generateAlias,
         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,
-        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,
@@ -241,8 +216,8 @@ export class Config {
     static docOptions = {
         modules: this.options.modules,
         girDirectories: Config.options.girDirectories,
+        root: this.options.root,
         outdir: Config.options.outdir,
-        environments: Config.options.environments,
         ignore: Config.options.ignore,
         verbose: Config.options.verbose,
         ignoreVersionConflicts: Config.options.ignoreVersionConflicts,
@@ -313,40 +288,14 @@ export class Config {
         return configFile
     }
 
-    public static getGenerateConfig(config: UserConfig, environment: Environment = 'gjs'): GenerateConfig {
-        const generateConfig: GenerateConfig = {
-            environment: environment,
-            girDirectories: config.girDirectories,
-            root: config.root,
-            outdir: config.outdir,
-            verbose: config.verbose,
-            buildType: config.buildType,
-            moduleType: config.moduleType,
-            noNamespace: config.noNamespace,
-            noComments: config.noComments,
-            noDebugComments: config.noDebugComments,
-            fixConflicts: config.fixConflicts,
-            generateAlias: config.generateAlias,
-            promisify: config.promisify,
-            npmScope: config.npmScope,
-            package: config.package,
-            packageYarn: config.packageYarn,
+    public static getOptionsGeneration(config: UserConfig): OptionsGeneration {
+        const generateConfig: OptionsGeneration = {
+            ...config,
         }
         return generateConfig
     }
 
     public static validate(config: UserConfig): UserConfig {
-        if (config.generateAlias) {
-            if (!config.environments.includes('gjs')) {
-                Logger.warn(WARN_USE_GJS_FOR_ALIAS)
-                config.environments.push('gjs')
-            }
-            if (config.moduleType !== 'esm') {
-                Logger.warn(WARN_USE_ESM_FOR_ALIAS)
-                config.moduleType = 'esm'
-            }
-        }
-
         return config
     }
 
@@ -360,41 +309,10 @@ export class Config {
         const configFileData = configFile?.config || {}
 
         const config: UserConfig = {
-            environments: options.environments,
-            buildType: options.buildType,
-            moduleType: options.moduleType,
-            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,
-            generateAlias: options.generateAlias,
-            promisify: options.promisify,
-            npmScope: options.npmScope,
-            package: options.package,
-            packageYarn: options.packageYarn,
+            ...options,
         }
 
         if (configFileData) {
-            // environments
-            if (isEqual(config.environments, Config.defaults.environments) && configFileData.environments) {
-                config.environments = configFileData.environments
-            }
-            // buildType
-            if (config.buildType === Config.options.buildType.default && configFileData.buildType) {
-                config.buildType = configFileData.buildType
-            }
-            // moduleType
-            if (config.moduleType === Config.options.moduleType.default && configFileData.moduleType) {
-                config.moduleType = configFileData.moduleType
-            }
             // verbose
             if (config.verbose === Config.options.verbose.default && typeof configFileData.verbose === 'boolean') {
                 config.verbose = configFileData.verbose
@@ -453,53 +371,49 @@ export class Config {
             ) {
                 config.noComments = configFileData.noComments
             }
-            // noDebugComments
+            // promisify
             if (
-                config.noDebugComments === Config.options.noDebugComments.default &&
-                typeof configFileData.noDebugComments === 'boolean'
+                config.promisify === Config.options.promisify.default &&
+                typeof configFileData.promisify === 'boolean'
             ) {
-                config.noDebugComments = configFileData.noDebugComments
+                config.promisify = configFileData.promisify
             }
-            // fixConflicts
+            // npmScope
+            if (config.npmScope === Config.options.npmScope.default && configFileData.npmScope) {
+                config.npmScope = configFileData.npmScope
+            }
+            // workspace
             if (
-                config.fixConflicts === Config.options.fixConflicts.default &&
-                typeof configFileData.fixConflicts === 'boolean'
+                config.workspace === Config.options.workspace.default &&
+                typeof configFileData.workspace === 'boolean'
             ) {
-                config.fixConflicts = configFileData.fixConflicts
+                config.workspace = configFileData.workspace
             }
-            // generateAlias
+            // onlyVersionPrefix
             if (
-                config.generateAlias === Config.options.generateAlias.default &&
-                typeof configFileData.generateAlias === 'boolean'
+                config.onlyVersionPrefix === Config.options.onlyVersionPrefix.default &&
+                typeof configFileData.onlyVersionPrefix === 'boolean'
             ) {
-                config.generateAlias = configFileData.generateAlias
+                config.onlyVersionPrefix = configFileData.onlyVersionPrefix
             }
-            // promisify
+            // noPrettyPrint
             if (
-                config.promisify === Config.options.promisify.default &&
-                typeof configFileData.promisify === 'boolean'
+                config.noPrettyPrint === Config.options.noPrettyPrint.default &&
+                typeof configFileData.noPrettyPrint === 'boolean'
             ) {
-                config.promisify = configFileData.promisify
+                config.noPrettyPrint = configFileData.noPrettyPrint
             }
-            // npmScope
-            if (config.npmScope === Config.options.npmScope.default && configFileData.npmScope) {
-                config.npmScope = configFileData.npmScope
+            // 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
             }
-            // packageYarn
-            if (
-                config.packageYarn === Config.options.packageYarn.default &&
-                typeof configFileData.packageYarn === 'boolean'
-            ) {
-                config.packageYarn = configFileData.packageYarn
-            }
-        }
-
-        if ((config.moduleType as string) === 'commonjs') {
-            config.moduleType = 'cjs'
         }
 
         // If outdir is not absolute, make it absolute to the root path
@@ -525,14 +439,12 @@ 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-10',
-        '/usr/lib64/mutter-11',
-        '/usr/lib64/mutter-12',
-        '/usr/lib/x86_64-linux-gnu/mutter-10',
-        '/usr/lib/x86_64-linux-gnu/mutter-11',
-        '/usr/lib/x86_64-linux-gnu/mutter-12',
+        '/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.
@@ -540,7 +452,7 @@ function getDefaultGirDirectories(): string[] {
     const dataDirs = process.env['XDG_DATA_DIRS']?.split(':') || []
     for (let dataDir of dataDirs) {
         dataDir = join(dataDir, 'gir-1.0')
-        if (!girDirectories.includes(dataDir)) {
+        if (!girDirectories.includes(dataDir) && existsSync(dataDir)) {
             girDirectories.push(dataDir)
         }
     }