@ts-for-gir/cli 3.0.0-beta.6 → 3.0.0-beta.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-for-gir/cli",
-  "version": "3.0.0-beta.6",
+  "version": "3.0.0-beta.8",
   "description": "Typescript .d.ts generator from GIR for gjs and node-gtk",
   "module": "lib/index.js",
   "type": "module",
@@ -12,7 +12,7 @@
   },
   "scripts": {
     "start": "yarn node --max_old_space_size=9216 lib/start.js",
-    "build": "yarn run clear:build && yarn run lint && yarn run build:ts && yarn run chmod",
+    "build": "yarn run lint && yarn run build:ts && yarn run chmod",
     "chmod": "chmod +x ./lib/start.js",
     "build:ts": "tsc",
     "clear": "yarn run clear:build",
@@ -36,37 +36,52 @@
     "url": "https://github.com/sammydre/ts-for-gjs/issues"
   },
   "homepage": "https://github.com/sammydre/ts-for-gjs#readme",
+  "keywords": [
+    "gjs",
+    "typescript",
+    "generate",
+    "node-gtk",
+    "gir",
+    "gobject-introspection",
+    "gnome",
+    "gtk",
+    "glib",
+    "gobject",
+    "dts",
+    "type definitions"
+  ],
   "devDependencies": {
     "@types/change-case": "^2.3.1",
     "@types/columnify": "^1.5.1",
     "@types/ejs": "^3.1.1",
-    "@types/eslint": "8.4.6",
-    "@types/inquirer": "^9.0.1",
-    "@types/lodash": "^4.14.185",
-    "@types/node": "^18.7.21",
-    "@types/prettier": "^2.7.1",
+    "@types/eslint": "8.4.10",
+    "@types/inquirer": "^9.0.3",
+    "@types/lodash": "^4.14.191",
+    "@types/node": "^18.11.18",
+    "@types/prettier": "^2.7.2",
     "@types/xml2js": "^0.4.11",
-    "@types/yargs": "^17.0.13",
-    "@typescript-eslint/eslint-plugin": "^5.38.0",
-    "@typescript-eslint/parser": "^5.38.0",
-    "eslint": "^8.24.0",
-    "eslint-config-prettier": "^8.5.0",
+    "@types/yargs": "^17.0.19",
+    "@typescript-eslint/eslint-plugin": "^5.48.2",
+    "@typescript-eslint/parser": "^5.48.2",
+    "eslint": "^8.32.0",
+    "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-prettier": "^4.2.1",
-    "rimraf": "^3.0.2"
+    "rimraf": "^4.1.0",
+    "typescript": "^4.9.4"
   },
   "dependencies": {
     "colorette": "^2.0.19",
     "columnify": "^1.6.0",
-    "cosmiconfig": "^7.0.1",
+    "cosmiconfig": "^8.0.0",
     "ejs": "^3.1.8",
     "events": "^3.3.0",
-    "globby": "^13.1.2",
-    "inquirer": "^9.1.2",
+    "get-tsconfig": "^4.3.0",
+    "globby": "^13.1.3",
+    "inquirer": "^9.1.4",
     "lodash": "^4.17.21",
-    "prettier": "^2.7.1",
+    "prettier": "^2.8.3",
     "tiny-glob": "^0.2.9",
-    "typescript": "^4.8.3",
     "xml2js": "^0.4.23",
-    "yargs": "^17.5.1"
+    "yargs": "^17.6.2"
   }
 }

package/src/commands/generate.ts

@@ -35,6 +35,7 @@ const builder = (yargs: Argv) => {
         .option('noCheck', Config.generateOptions.noCheck)
         .option('noDOMLib', Config.generateOptions.noDOMLib)
         .option('fixConflicts', Config.generateOptions.fixConflicts)
+        .option('gnomeShellTypes', Config.generateOptions.gnomeShellTypes)
         .example(examples)
 }
 
@@ -73,8 +74,8 @@ const examples: ReadonlyArray<[string, string?]> = [
     [`${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-3.0 xrandr-1.3`,
-        'Generate .d.ts. files but not for Gtk-3.0 and xrandr-1.3',
+        `${Config.appName} generate --ignore=Gtk-4.0 xrandr-1.3`,
+        'Generate .d.ts. files but not for Gtk-4.0 and xrandr-1.3',
     ],
 ]
 

package/src/config.ts

@@ -35,7 +35,7 @@ export class Config {
         girDirectories: OS.platform() === 'darwin' ? ['/usr/local/share/gir-1.0'] : ['/usr/share/gir-1.0'],
         modules: ['*'],
         ignore: [],
-        verbose: true,
+        verbose: false,
         ignoreVersionConflicts: false,
         useNamespace: false,
         buildType: 'lib',
@@ -45,6 +45,7 @@ export class Config {
         noCheck: false,
         fixConflicts: true,
         noDOMLib: false,
+        gnomeShellTypes: false,
     }
 
     static configFilePath = Path.join(process.cwd(), Config.defaults.configName)
@@ -52,13 +53,13 @@ export class Config {
     /**
      * CLI options used in commands/generate.ts and commands/list.ts
      */
-    static options = {
+    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,
-        } as Options,
+        },
         girDirectories: {
             type: 'string',
             alias: 'g',
@@ -66,14 +67,14 @@ export class Config {
             array: true,
             default: Config.defaults.girDirectories,
             normalize: true,
-        } as Options,
+        },
         outdir: {
             type: 'string',
             alias: 'o',
             description: 'Directory to output to',
             default: Config.defaults.outdir,
             normalize: true,
-        } as Options,
+        },
         environments: {
             type: 'string',
             alias: 'e',
@@ -82,7 +83,7 @@ export class Config {
             choices: ['gjs', 'node'],
             default: Config.defaults.environments,
             normalize: true,
-        } as Options,
+        },
         ignore: {
             type: 'string',
             alias: 'i',
@@ -90,7 +91,7 @@ export class Config {
             array: true,
             default: Config.defaults.ignore,
             normalize: true,
-        } as Options,
+        },
         buildType: {
             type: 'string',
             alias: 'b',
@@ -99,7 +100,7 @@ export class Config {
             choices: ['lib', 'types'],
             default: Config.defaults.buildType,
             normalize: true,
-        } as Options,
+        },
         moduleType: {
             type: 'string',
             alias: 't',
@@ -107,77 +108,83 @@ export class Config {
             choices: ['esm', 'commonjs'],
             default: Config.defaults.moduleType,
             normalize: true,
-        } as Options,
+        },
         pretty: {
             type: 'boolean',
             description: 'Prettifies the generated .d.ts files',
             default: Config.defaults.pretty,
             normalize: true,
-        } as Options,
+        },
         verbose: {
             type: 'boolean',
             alias: 'v',
             description: 'Switch on/off the verbose mode',
             default: Config.defaults.verbose,
             normalize: true,
-        } as Options,
+        },
         ignoreVersionConflicts: {
             type: 'boolean',
             description: 'Do not ask for package versions if multiple versions are found',
             default: Config.defaults.ignoreVersionConflicts,
             normalize: true,
-        } as Options,
+        },
         print: {
             type: 'boolean',
             alias: 'p',
             description: 'Print the output to console and create no files',
             default: Config.defaults.print,
             normalize: true,
-        } as Options,
+        },
         configName: {
             type: 'string',
             description: 'Name of the config if you want to use a different name',
             default: Config.defaults.configName,
             normalize: true,
-        } as Options,
+        },
         useNamespace: {
             type: 'boolean',
             alias: 'd',
             description: 'Export all symbols for each module as a namespace',
             default: Config.defaults.useNamespace,
             normalize: true,
-        } as Options,
+        },
         noComments: {
             type: 'boolean',
             alias: 'n',
             description: 'Do not generate documentation comments',
             default: Config.defaults.noComments,
             normalize: true,
-        } as Options,
+        },
         noDebugComments: {
             type: 'boolean',
             description: 'Do not generate debugging inline comments',
             default: Config.defaults.noDebugComments,
             normalize: true,
-        } as Options,
+        },
         noCheck: {
             type: 'boolean',
             description: 'Disable typescript semantic checks using @ts-nocheck',
             default: Config.defaults.noCheck,
             normalize: true,
-        } as Options,
+        },
         fixConflicts: {
             type: 'boolean',
             description: 'Fix Inheritance and implementation type conflicts',
             default: Config.defaults.fixConflicts,
             normalize: true,
-        } as Options,
+        },
         noDOMLib: {
             type: 'boolean',
             description: 'Disables the generation of types that are in conflict with the DOM types',
             default: Config.defaults.noDOMLib,
             normalize: true,
-        } as Options,
+        },
+        gnomeShellTypes: {
+            type: 'boolean',
+            description: 'Generate types for GNOME Shell',
+            default: Config.defaults.gnomeShellTypes,
+            normalize: true,
+        },
     }
 
     /**
@@ -202,6 +209,7 @@ export class Config {
         noCheck: this.options.noCheck,
         noDOMLib: this.options.noDOMLib,
         fixConflicts: this.options.fixConflicts,
+        gnomeShellTypes: this.options.gnomeShellTypes,
     }
 
     static listOptions = {
@@ -290,28 +298,18 @@ export class Config {
             noCheck: config.noCheck,
             fixConflicts: config.fixConflicts,
             noDOMLib: config.noDOMLib,
+            gnomeShellTypes: config.gnomeShellTypes,
         }
         return generateConfig
     }
 
     protected static async validateTsConfig(config: UserConfig): Promise<UserConfig> {
-        const tsConfig = config.outdir ? readTsJsConfig(config.outdir) : null
-
-        const tsCompilerOptions = (
-            tsConfig &&
-            'compilerOptions' in tsConfig &&
-            typeof tsConfig.compilerOptions === 'object' &&
-            tsConfig.compilerOptions != null
-                ? tsConfig.compilerOptions
-                : {}
-        ) as Record<PropertyKey, unknown>
-
-        const tsConfigHasDOMLib =
-            'noLib' in tsCompilerOptions && tsCompilerOptions.noLib
-                ? false // NoLib makes typescript to ignore the lib property
-                : 'lib' in tsCompilerOptions && Array.isArray(tsCompilerOptions.lib)
-                ? tsCompilerOptions.lib.some((lib) => String(lib).toLowerCase().startsWith('dom'))
-                : true // Typescript icludes DOM lib by default
+        const tsCompilerOptions = (config.outdir && readTsJsConfig(config.outdir)?.compilerOptions) || {}
+        const tsConfigHasDOMLib = tsCompilerOptions.noLib
+            ? false // NoLib makes typescript to ignore the lib property
+            : Array.isArray(tsCompilerOptions.lib)
+            ? tsCompilerOptions.lib.some((lib) => lib.toLowerCase().startsWith('dom'))
+            : true // Typescript icludes DOM lib by default
 
         if (config.environments.includes('gjs') && tsConfigHasDOMLib && !config.noDOMLib) {
             const answer = (
@@ -358,7 +356,7 @@ export class Config {
      * @param options
      */
     public static async load(options: ConfigFlags): Promise<UserConfig> {
-        const configFile = await this.loadConfigFile(options.configName)
+        const configFile = (await this.loadConfigFile(options.configName))?.config || {}
 
         const config: UserConfig = {
             environments: options.environments,
@@ -378,100 +376,102 @@ export class Config {
             noCheck: options.noCheck,
             fixConflicts: options.fixConflicts,
             noDOMLib: options.noDOMLib,
+            gnomeShellTypes: options.gnomeShellTypes,
         }
 
         if (configFile) {
             // environments
-            if (isEqual(config.environments, Config.defaults.environments) && configFile.config.environments) {
-                config.environments = configFile.config.environments
+            if (isEqual(config.environments, Config.defaults.environments) && configFile.environments) {
+                config.environments = configFile.environments
             }
             // buildType
-            if (config.buildType === Config.options.buildType.default && configFile.config.buildType) {
-                config.buildType = configFile.config.buildType
+            if (config.buildType === Config.options.buildType.default && configFile.buildType) {
+                config.buildType = configFile.buildType
             }
             // moduleType
-            if (config.moduleType === Config.options.moduleType.default && configFile.config.moduleType) {
-                config.moduleType = configFile.config.moduleType
+            if (config.moduleType === Config.options.moduleType.default && configFile.moduleType) {
+                config.moduleType = configFile.moduleType
             }
             // verbose
-            if (config.verbose === Config.options.verbose.default && typeof configFile.config.verbose === 'boolean') {
-                config.verbose = configFile.config.verbose
+            if (config.verbose === Config.options.verbose.default && typeof configFile.verbose === 'boolean') {
+                config.verbose = configFile.verbose
             }
             // ignoreVersionConflicts
             if (
                 config.ignoreVersionConflicts === Config.options.ignoreVersionConflicts.default &&
-                typeof configFile.config.ignoreVersionConflicts === 'boolean'
+                typeof configFile.ignoreVersionConflicts === 'boolean'
             ) {
-                config.ignoreVersionConflicts = configFile.config.ignoreVersionConflicts
+                config.ignoreVersionConflicts = configFile.ignoreVersionConflicts
             }
             // pretty
-            if (config.pretty === Config.options.pretty.default && typeof configFile.config.pretty === 'boolean') {
-                config.pretty = configFile.config.pretty
+            if (config.pretty === Config.options.pretty.default && typeof configFile.pretty === 'boolean') {
+                config.pretty = configFile.pretty
             }
             // print
-            if (config.print === Config.options.print.default && typeof configFile.config.print === 'boolean') {
-                config.print = configFile.config.print
+            if (config.print === Config.options.print.default && typeof configFile.print === 'boolean') {
+                config.print = configFile.print
             }
             // outdir
-            if (config.outdir === Config.options.outdir.default && configFile.config.outdir) {
-                config.outdir = config.print ? null : configFile.config.outdir
+            if (config.outdir === Config.options.outdir.default && configFile.outdir) {
+                config.outdir = config.print ? null : configFile.outdir
             }
             // girDirectories
-            if (config.girDirectories === Config.options.girDirectories.default && configFile.config.girDirectories) {
-                config.girDirectories = configFile.config.girDirectories
+            if (config.girDirectories === Config.options.girDirectories.default && configFile.girDirectories) {
+                config.girDirectories = configFile.girDirectories
             }
             // ignore
             if (
                 (!config.ignore || config.ignore.length <= 0 || isEqual(config.ignore, Config.defaults.ignore)) &&
-                configFile.config.ignore
+                configFile.ignore
             ) {
-                config.ignore = configFile.config.ignore
+                config.ignore = configFile.ignore
             }
             // modules
             if (
                 (config.modules.length <= 0 || isEqual(config.modules, Config.defaults.modules)) &&
-                configFile.config.modules
+                configFile.modules
             ) {
-                config.modules = configFile.config.modules
+                config.modules = configFile.modules
             }
             // useNamespace
             if (
                 config.useNamespace === Config.options.useNamespace.default &&
-                typeof configFile.config.useNamespace === 'boolean'
+                typeof configFile.useNamespace === 'boolean'
             ) {
-                config.useNamespace = configFile.config.useNamespace
+                config.useNamespace = configFile.useNamespace
             }
             // noComments
-            if (
-                config.noComments === Config.options.noComments.default &&
-                typeof configFile.config.noComments === 'boolean'
-            ) {
-                config.noComments = configFile.config.noComments
+            if (config.noComments === Config.options.noComments.default && typeof configFile.noComments === 'boolean') {
+                config.noComments = configFile.noComments
             }
             // noDebugComments
             if (
                 config.noDebugComments === Config.options.noDebugComments.default &&
-                typeof configFile.config.noDebugComments === 'boolean'
+                typeof configFile.noDebugComments === 'boolean'
             ) {
-                config.noDebugComments = configFile.config.noDebugComments
+                config.noDebugComments = configFile.noDebugComments
             }
             // noCheck
-            if (config.noCheck === Config.options.noCheck.default && typeof configFile.config.noCheck === 'boolean') {
-                config.noCheck = configFile.config.noCheck
+            if (config.noCheck === Config.options.noCheck.default && typeof configFile.noCheck === 'boolean') {
+                config.noCheck = configFile.noCheck
             }
             // fixConflicts
             if (
                 config.fixConflicts === Config.options.fixConflicts.default &&
-                typeof configFile.config.fixConflicts === 'boolean'
+                typeof configFile.fixConflicts === 'boolean'
             ) {
-                config.fixConflicts = configFile.config.fixConflicts
+                config.fixConflicts = configFile.fixConflicts
             }
             // noDOMLib
+            if (config.noDOMLib === Config.options.noDOMLib.default && typeof configFile.noDOMLib === 'boolean') {
+                config.noDOMLib = configFile.noDOMLib
+            }
+            // gnomeShellTypes
             if (
-                config.noDOMLib === Config.options.noDOMLib.default &&
-                typeof configFile.config.noDOMLib === 'boolean'
+                config.gnomeShellTypes === Config.options.gnomeShellTypes.default &&
+                typeof configFile.gnomeShellTypes === 'boolean'
             ) {
-                config.noDOMLib = configFile.config.noDOMLib
+                config.gnomeShellTypes = configFile.gnomeShellTypes
             }
         }
 

package/src/template-processor.ts

@@ -3,7 +3,8 @@
  * For example, the signal methods are generated here
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs'
+import { existsSync } from 'fs'
+import { readFile, writeFile, mkdir, readdir } from 'fs/promises'
 import Path from 'path'
 import ejs from 'ejs'
 import { Logger } from './logger.js'
@@ -34,7 +35,7 @@ export class TemplateProcessor {
     }
 
     /**
-     * Loads and renders a template and gets the rendered string back
+     * Loads and renders a template and gets the rendered templates back
      * @param templateFilename
      */
     public async load(templateFilename: string): Promise<string> {
@@ -42,13 +43,25 @@ export class TemplateProcessor {
         return await this.render(fileContent)
     }
 
+    /**
+     * Loads and renders all templates in a directory and gets the rendered templates back
+     * @param templateDirname
+     */
+    public async loadAll(templateDirname: string, fileExtension: string): Promise<{ [path: string]: string }> {
+        const fileContents = await this.readAll(templateDirname, fileExtension)
+        for (const file of Object.keys(fileContents)) {
+            fileContents[file] = await this.render(fileContents[file])
+        }
+        return fileContents
+    }
+
     /**
      * Loads an template, render the template and write the template to the filesystem
      * @param templateFilename
      * @param outputDir
      * @param outputFilename
      * @param append
-     * @return The rendered (and if possible prettified) code string
+     * @return The rendered (and if possible prettified) template string
      */
     public async create(
         templateFilename: string,
@@ -56,34 +69,60 @@ export class TemplateProcessor {
         outputFilename: string,
         append = '',
     ): Promise<string> {
-        const fileContent = await this.load(templateFilename)
-        const renderedCode = await this.render(fileContent)
+        const renderedTpl = await this.load(templateFilename)
         const destPath = getDestPath(this.config.environment, outputDir, outputFilename)
-        const prettifiedCode = this.config.pretty ? this.prettifySource(renderedCode, destPath) : null
-        const code = (prettifiedCode || renderedCode) + append
+        const prettifiedCode = this.config.pretty ? this.prettifySource(renderedTpl, destPath) : null
+        const code = (prettifiedCode || renderedTpl) + append
         await this.write(code, outputDir, outputFilename)
         return code
     }
 
+    /**
+     * Loads all templates with file extension in dir, render the templates and write the template to the filesystem
+     * @param fileExtension
+     * @param templateDirname
+     * @param outputDir
+     * @param outputDirname
+     * @return The rendered (and if possible prettified) templates
+     */
+    public async createAll(
+        fileExtension: string,
+        templateDirname: string,
+        outputDir: string,
+        outputDirname: string,
+        append = '',
+    ) {
+        const renderedTpls = await this.loadAll(templateDirname, fileExtension)
+        const result: { [path: string]: string } = {}
+        for (const filename of Object.keys(renderedTpls)) {
+            const destPath = getDestPath(this.config.environment, outputDir, outputDirname, filename)
+            const prettifiedCode = this.config.pretty ? this.prettifySource(renderedTpls[filename], destPath) : null
+            result[destPath] = (prettifiedCode || renderedTpls[filename]) + append
+            await this.write(result[destPath], outputDir, Path.join(outputDirname, filename))
+        }
+
+        return result
+    }
+
     protected async write(content: string, outputDir: string, outputFilename: string): Promise<string> {
         const destPath = getDestPath(this.config.environment, outputDir, outputFilename)
 
         // write template result file
-        mkdirSync(outputDir, { recursive: true })
-        writeFileSync(destPath, content, { encoding: 'utf8', flag: 'w' })
+        await mkdir(Path.dirname(destPath), { recursive: true })
+        await writeFile(destPath, content, { encoding: 'utf8', flag: 'w' })
 
         return Promise.resolve(destPath)
     }
 
     protected async render(templateString: string, additionalData: Partial<ejs.Options> = {}): Promise<string> {
         try {
-            const renderedCode = ejs.render(templateString, {
+            const renderedTpl = ejs.render(templateString, {
                 async: true,
                 ...this.config,
                 ...this.data,
                 ...additionalData,
             })
-            return Promise.resolve(renderedCode)
+            return Promise.resolve(renderedTpl)
         } catch (error) {
             this.log.error('Error on render', error)
             return ''
@@ -91,8 +130,8 @@ export class TemplateProcessor {
     }
 
     /**
-     * Checks if the template file exists and returns the path if found
-     * Tries first to load the file from the environment-specific template folder and otherwise looks for it in the general template folder
+     * Checks if the template file or directory exists and returns the path if found
+     * Tries first to load the file / directory from the environment-specific template folder and otherwise looks for it in the general template folder
      * @param templateFilename
      */
     public exists(templateFilename: string): string | null {
@@ -133,7 +172,7 @@ export class TemplateProcessor {
         const filename = Path.basename(path)
         this.log.info(`   Prettify ${filename}...`)
         try {
-            const source = readFileSync(Path.resolve('.', path), 'utf8')
+            const source = await readFile(Path.resolve('.', path), 'utf8')
             prettyCode = this.prettifySource(source, path)
         } catch (error) {
             this.log.warn('Error on prettify', error)
@@ -161,10 +200,34 @@ export class TemplateProcessor {
     protected async read(templateFilename: string) {
         const path = this.exists(templateFilename)
         if (path) {
-            return Promise.resolve(readFileSync(path, 'utf8'))
+            return await readFile(path, 'utf8')
         }
         throw new Error(`Template '${templateFilename}' not found'`)
     }
+
+    /**
+     * Reads all template files from a directory and gets the raw strings back
+     * @param templateDirname
+     * @param fileExtension
+     * @return The raw template contents
+     * @throws Error if the template directory does not exist
+     * @throws Error if the template directory is empty
+     */
+    protected async readAll(templateDirname: string, fileExtension: string) {
+        const path = this.exists(templateDirname)
+        if (path) {
+            const files = (await readdir(path)).filter((file) => file.endsWith(fileExtension))
+            if (files.length === 0) {
+                throw new Error(`Template directory '${templateDirname}' is empty'`)
+            }
+            const results: { [path: string]: string } = {}
+            for (const file of files) {
+                results[file] = await readFile(Path.join(path, file), 'utf8')
+            }
+            return results
+        }
+        throw new Error(`Template directory '${templateDirname}' not found'`)
+    }
 }
 
 export default TemplateProcessor