@ts-for-gir/cli 3.0.0-beta.9 → 3.0.1

package/src/module-loader.ts

@@ -4,10 +4,22 @@
 
 import inquirer, { ListQuestion, Answers } from 'inquirer'
 import glob from 'tiny-glob'
-import Path from 'path'
+import { basename } from 'path'
 import { readFile } from 'fs/promises'
 import { bold } from 'colorette'
 import * as xml2js from 'xml2js'
+import {
+    DependencyManager,
+    ResolveType,
+    GirModule,
+    Logger,
+    splitModuleName,
+    union,
+    isIterable,
+    WARN_NO_GIR_FILE_FOUND_FOR_PACKAGE,
+} from '@ts-for-gir/lib'
+import { Config } from './config.js'
+
 import type {
     GirModulesGroupedMap,
     ParsedGir,
@@ -17,21 +29,14 @@ import type {
     DependencyMap,
     Dependency,
     AnswerVersion,
-} from './types/index.js'
-import { ResolveType } from './types/index.js'
-import { GirModule } from './gir-module.js'
-import { Config } from './config.js'
-import { Logger } from './logger.js'
-import { DependencyManager } from './dependency-manager.js'
-import { splitModuleName, union, isIterable } from './utils.js'
-import { WARN_NO_GIR_FILE_FOUND_FOR_PACKAGE } from './messages.js'
+} from '@ts-for-gir/lib'
 
 export class ModuleLoader {
     log: Logger
     dependencyManager: DependencyManager
     /** Transitive module dependencies */
     modDependencyMap: DependencyMap = {}
-    constructor(private readonly config: GenerateConfig) {
+    constructor(protected readonly config: GenerateConfig) {
         this.log = new Logger('', config.verbose, 'ModuleLoader')
         this.dependencyManager = DependencyManager.getInstance(config)
     }
@@ -41,7 +46,7 @@ export class ModuleLoader {
      * E.g. Gtk-3.0 and Gtk-4.0 will be grouped
      * @param girFiles
      */
-    private groupGirFiles(resolveGirModules: Set<GirModuleResolvedBy> | GirModuleResolvedBy[]): GirModulesGroupedMap {
+    protected groupGirFiles(resolveGirModules: Set<GirModuleResolvedBy> | GirModuleResolvedBy[]): GirModulesGroupedMap {
         const girModulesGrouped: GirModulesGroupedMap = {}
 
         for (const resolveGirModule of resolveGirModules) {
@@ -68,7 +73,7 @@ export class ModuleLoader {
      * @param girModulesGrouped
      * @param selected Users selected module packageName
      */
-    private sortVersionsByAnswer(
+    protected sortVersionsByAnswer(
         girModulesGrouped: GirModulesGrouped,
         selected: string[],
     ): { keep: Set<GirModuleResolvedBy>; ignore: string[] } {
@@ -102,7 +107,10 @@ export class ModuleLoader {
         }
     }
 
-    private generateContinueQuestion(message = `do you want to continue?`, choices = ['Yes', 'Go back']): ListQuestion {
+    protected generateContinueQuestion(
+        message = `do you want to continue?`,
+        choices = ['Yes', 'Go back'],
+    ): ListQuestion {
         const question: ListQuestion = {
             name: 'continue',
             message,
@@ -112,7 +120,7 @@ export class ModuleLoader {
         return question
     }
 
-    private generateIgnoreDepsQuestion(
+    protected generateIgnoreDepsQuestion(
         message = `Do you want to ignore them too?`,
         choices = ['Yes', 'No', 'Go back'],
     ): ListQuestion {
@@ -125,7 +133,7 @@ export class ModuleLoader {
         return question
     }
 
-    private async askIgnoreDepsPrompt(
+    protected async askIgnoreDepsPrompt(
         deps: GirModuleResolvedBy[] | Set<GirModuleResolvedBy>,
     ): Promise<'Yes' | 'No' | 'Go back'> {
         let question: ListQuestion<Answers> | null = null
@@ -152,7 +160,7 @@ export class ModuleLoader {
      * @param girModuleGrouped
      * @param message
      */
-    private generateModuleVersionQuestion(girModuleGrouped: GirModulesGrouped, message?: string): ListQuestion {
+    protected generateModuleVersionQuestion(girModuleGrouped: GirModulesGrouped, message?: string): ListQuestion {
         message = message || `Multiple versions of '${girModuleGrouped.namespace}' found, which one do you want to use?`
         const choices = ['All', ...girModuleGrouped.modules.map((module) => module.packageName)]
         const question: ListQuestion = {
@@ -169,7 +177,7 @@ export class ModuleLoader {
      * @param girModulesGroupedMap
      * @param packageName
      */
-    private findPackageNamesDependOnPackage(
+    protected findPackageNamesDependOnPackage(
         girModulesGroupedMap: GirModulesGroupedMap,
         packageName: string,
     ): GirModuleResolvedBy[] {
@@ -194,7 +202,7 @@ export class ModuleLoader {
      * @param girModulesGroupedMap
      * @param packageName
      */
-    private findPackageNamesDependOnPackages(
+    protected findPackageNamesDependOnPackages(
         girModulesGroupedMap: GirModulesGroupedMap,
         packageNames: string[],
     ): GirModuleResolvedBy[] {
@@ -205,7 +213,7 @@ export class ModuleLoader {
         return girModules
     }
 
-    private async askForVersionsPrompt(girModulesGrouped: GirModulesGrouped): Promise<AnswerVersion> {
+    protected async askForVersionsPrompt(girModulesGrouped: GirModulesGrouped): Promise<AnswerVersion> {
         const question = this.generateModuleVersionQuestion(girModulesGrouped)
         const choices = question.choices as string[]
         if (!choices) {
@@ -236,7 +244,7 @@ export class ModuleLoader {
      * Ignores also modules that depend on a module that should be ignored
      * @param resolveFirModules
      */
-    private async askForEachConflictVersionsPrompt(
+    protected async askForEachConflictVersionsPrompt(
         girModulesGroupedMap: GirModulesGroupedMap,
         ignore: string[],
     ): Promise<{ keep: Set<GirModuleResolvedBy>; ignore: string[] }> {
@@ -306,7 +314,7 @@ export class ModuleLoader {
      * Asks via cli prompt if the user wants to add the ignored modules to his config file
      * @param ignoredModules
      */
-    private async askAddToIgnoreToConfigPrompt(ignoredModules: string[] | Set<string>): Promise<void> {
+    protected async askAddToIgnoreToConfigPrompt(ignoredModules: string[] | Set<string>): Promise<void> {
         const questions = [
             {
                 name: 'addToIgnore',
@@ -332,7 +340,7 @@ export class ModuleLoader {
      * @param packageName
      * @param result
      */
-    private traverseDependencies(packageName: string, result: { [name: string]: Dependency } = {}): void {
+    protected traverseDependencies(packageName: string, result: { [name: string]: Dependency } = {}): void {
         const deps = this.modDependencyMap[packageName]
         if (isIterable(deps)) {
             for (const dep of deps) {
@@ -348,7 +356,7 @@ export class ModuleLoader {
      * should be called for each girModule so that the modDependencyMap is complete
      * @param girModule
      */
-    private extendDependencyMapByGirModule(girModule: GirModule): void {
+    protected extendDependencyMapByGirModule(girModule: GirModule): void {
         this.modDependencyMap[girModule.packageName] = girModule.dependencies
     }
 
@@ -357,7 +365,7 @@ export class ModuleLoader {
      * is required so that all dependencies can be found internally when generating the dependency imports for the module .d.ts file
      * @param girModules
      */
-    private setTraverseDependenciesForModules(girModules: GirModuleResolvedBy[]): void {
+    protected setTraverseDependenciesForModules(girModules: GirModuleResolvedBy[]): void {
         for (const girModule of girModules) {
             const result: { [name: string]: Dependency } = {}
             this.traverseDependencies(girModule.packageName, result)
@@ -371,7 +379,7 @@ export class ModuleLoader {
      * @param fillName
      * @param config
      */
-    private async loadAndCreateGirModule(dependency: Dependency): Promise<GirModule | null> {
+    protected async loadAndCreateGirModule(dependency: Dependency): Promise<GirModule | null> {
         if (!dependency.exists || dependency.path === null) {
             return null
         }
@@ -390,7 +398,7 @@ export class ModuleLoader {
      * @param girModules Array of girModules
      * @param packageNames Full name like 'Gtk-3.0' you are looking for
      */
-    private findGirModuleByFullNames(
+    protected findGirModuleByFullNames(
         girModules: (GirModuleResolvedBy | GirModule)[],
         packageNames: string[],
     ): Array<GirModuleResolvedBy | GirModule> {
@@ -402,7 +410,7 @@ export class ModuleLoader {
      * @param girModules
      * @param packageName
      */
-    private existsGirModules(girModules: (GirModuleResolvedBy | GirModule)[], packageName: string): boolean {
+    protected existsGirModules(girModules: (GirModuleResolvedBy | GirModule)[], packageName: string): boolean {
         const foundModule = this.findGirModuleByFullNames(girModules, [packageName])
         return foundModule.length > 0
     }
@@ -416,7 +424,7 @@ export class ModuleLoader {
      * @param ignoreDependencies
      * @returns
      */
-    private async loadGirModules(
+    protected async loadGirModules(
         dependencies: Dependency[],
         ignoreDependencies: string[] = [],
         girModules: GirModuleResolvedBy[] = [],
@@ -494,7 +502,7 @@ export class ModuleLoader {
      * @param modules
      * @param ignore
      */
-    private async findPackageNames(modules: string[], ignore: string[] = []): Promise<Set<string>> {
+    protected async findPackageNames(modules: string[], ignore: string[] = []): Promise<Set<string>> {
         const foundModules = new Set<string>()
 
         for (let i = 0; i < modules.length; i++) {
@@ -509,7 +517,7 @@ export class ModuleLoader {
                     }
                 }
 
-                let globModules = files.map((file) => Path.basename(file, '.gir'))
+                let globModules = files.map((file) => basename(file, '.gir'))
                 // Filter out the ignored modules
                 globModules = globModules.filter((mod) => {
                     const isIgnored = ignore.includes(mod)
@@ -524,7 +532,7 @@ export class ModuleLoader {
         return foundModules
     }
 
-    private packageNamesToDependencies(packageNames: Set<string>): Dependency[] {
+    protected packageNamesToDependencies(packageNames: Set<string>): Dependency[] {
         return Array.from(packageNames).map((packageName) => {
             const { namespace, version } = splitModuleName(packageName)
             return this.dependencyManager.get(namespace, version)

package/src/utils.ts

@@ -1,399 +1,6 @@
-/* eslint-disable @typescript-eslint/unbound-method */
-import lodash from 'lodash'
-import Path from 'path'
-import fs from 'fs'
+import { join, dirname, resolve } from 'path'
+import { existsSync } from 'fs'
 import { getTsconfig, TsConfigJsonResolved } from 'get-tsconfig'
-import { fileURLToPath } from 'url'
-import { Environment, GirInfoAttrs, TsType, FileInfo } from './types/index.js'
-import { inspect } from 'util'
-import { Logger } from './logger.js'
-
-import { COMMENT_REG_EXP, PARAM_REG_EXP, OPT_PARAM_REG_EXP } from './constants.js'
-
-export { inspect }
-
-/**
- * Performs a deep comparison between two values to determine if they are
- * equivalent.
- *
- * **Note:** This method supports comparing arrays, array buffers, booleans,
- * date objects, error objects, maps, numbers, `Object` objects, regexes,
- * sets, strings, symbols, and typed arrays. `Object` objects are compared
- * by their own, not inherited, enumerable properties. Functions and DOM
- * nodes are **not** supported.
- *
- * @category Lang
- * @param value The value to compare.
- * @param other The other value to compare.
- * @returns Returns `true` if the values are equivalent, else `false`.
- * @example
- *
- * var object = { 'user': 'fred' };
- * var other = { 'user': 'fred' };
- *
- * _.isEqual(object, other);
- * // => true
- *
- * object === other;
- * // => false
- */
-export const isEqual = lodash.isEqual
-
-/**
- * Creates an array of values by running each element in collection through iteratee. The iteratee is
- * invoked with three arguments: (value, index|key, collection).
- *
- * Many lodash methods are guarded to work as iteratees for methods like _.every, _.filter, _.map, _.mapValues,
- * _.reject, and _.some.
- *
- * The guarded methods are:
- * ary, callback, chunk, clone, create, curry, curryRight, drop, dropRight, every, fill, flatten, invert, max,
- * min, parseInt, slice, sortBy, take, takeRight, template, trim, trimLeft, trimRight, trunc, random, range,
- * sample, some, sum, uniq, and words
- *
- * @param collection The collection to iterate over.
- * @param iteratee The function invoked per iteration.
- * @return Returns the new mapped array.
- */
-export const map = lodash.map
-
-/**
- * Iterates over elements of collection, returning the first element predicate returns truthy for.
- * The predicate is invoked with three arguments: (value, index|key, collection).
- *
- * @param collection The collection to search.
- * @param predicate The function invoked per iteration.
- * @param fromIndex The index to search from.
- * @return Returns the matched element, else undefined.
- */
-export const find = lodash.find
-
-/**
- * Recursively merges own and inherited enumerable properties of source
- * objects into the destination object, skipping source properties that resolve
- * to `undefined`. Array and plain object properties are merged recursively.
- * Other objects and value types are overridden by assignment. Source objects
- * are applied from left to right. Subsequent sources overwrite property
- * assignments of previous sources.
- *
- * **Note:** This method mutates `object`.
- *
- * @category Object
- * @param object The destination object.
- * @param [sources] The source objects.
- * @returns Returns `object`.
- * @example
- *
- * var users = {
- *   'data': [{ 'user': 'barney' }, { 'user': 'fred' }]
- * };
- *
- * var ages = {
- *   'data': [{ 'age': 36 }, { 'age': 40 }]
- * };
- *
- * _.merge(users, ages);
- * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }
- */
-export const merge = lodash.merge
-
-/**
- * Creates a shallow clone of value.
- *
- * Note: This method is loosely based on the structured clone algorithm and supports cloning arrays,
- * array buffers, booleans, date objects, maps, numbers, Object objects, regex's, sets, strings, symbols,
- * and typed arrays. The own enumerable properties of arguments objects are cloned as plain objects. An empty
- * object is returned for not cloneable values such as error objects, functions, DOM nodes, and WeakMaps.
- *
- * @param value The value to clone.
- * @return Returns the cloned value.
- */
-export const clone = lodash.clone
-
-/**
- * This method is like clone except that it recursively clones value.
- *
- * @param value The value to recursively clone.
- * @return Returns the deep cloned value.
- */
-export const cloneDeep = lodash.cloneDeep
-
-/**
- * Split a package name into namespace and version
- */
-export const splitModuleName = (packageName: string): { packageName: string; namespace: string; version: string } => {
-    // There are modules that use multiple hyphens like 'GUPnP-DLNA-1.0'
-    const splits = packageName.split('-')
-    const version = splits.splice(-1, 1)[0]
-    const namespace = splits.join('')
-    return {
-        packageName,
-        namespace,
-        version,
-    }
-}
-
-/** Remove namespace prefix */
-export const removeNamespace = (type: string, namespace: string) => {
-    if (type.startsWith(namespace + '.')) {
-        type = type.substring(namespace.length + 1)
-    }
-    return type
-}
-
-/** Remove class module name prefix */
-export const removeClassModule = removeNamespace
-
-/**
- * Add namespace prefix
- */
-export const addNamespace = (type: string, namespace: string) => {
-    if (!type.startsWith(namespace + '.')) {
-        type = namespace + '.' + type
-    }
-    return type
-}
-
-/**
- * Checking whether some variable is iterable
- * @see https://stackoverflow.com/a/32538867
- * @param obj Variable to check for iterable
- * @returns Whether the variable is iterable or not
- */
-export const isIterable = (obj: unknown[]): boolean => {
-    return obj != null && typeof obj[Symbol.iterator] === 'function'
-}
-
-/**
- * Checking whether a string is numeric
- * @param str The string to check
- * @returns Whether the string is numeric or not
- */
-export const isNumeric = (str: string): boolean => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return !isNaN((str as any) - parseFloat(str))
-}
-
-/**
- * Get the first character of a string
- * @param str The string to get the first character from
- * @returns The first character
- */
-export const getFirstChar = (str: string): string => {
-    return str.charAt(0)
-}
-
-/**
- * Get the last character of a string
- * @param str The string to get the last character from
- * @returns The last character
- */
-export const getLastChar = (str: string): string => {
-    return str.charAt(str.length - 1)
-}
-
-/**
- * Check if the first character of a string is numeric
- * @param str The string to check
- * @returns Whether the first character is numeric or not
- */
-export const isFirstCharNumeric = (str: string): boolean => {
-    return isNumeric(getFirstChar(str))
-}
-
-/**
- * Convert a string to camelCase
- * @param str The string to convert
- * @returns The converted string
- */
-export const camelCase = (str: string): string => {
-    return str
-        .replace(/\s(.)|(\s|-|_|\.)(.)/g, (a) => {
-            return a.toUpperCase()
-        })
-        .replace(/(\s|-|_|\.)/g, '')
-}
-
-/**
- * Convert a string to lowerCamelCase
- * @param str The string to convert
- * @returns The converted string
- */
-export const lowerCamelCase = (str: string): string => {
-    str = camelCase(str)
-    str = getFirstChar(str).toLowerCase() + str.slice(1)
-    return str
-}
-
-/**
- * Convert a string to UpperCamelCase
- * @param str The string to convert
- * @returns The converted string
- */
-export const upperCamelCase = (str: string): string => {
-    str = camelCase(str)
-    str = getFirstChar(str).toUpperCase() + str.slice(1)
-    return str
-}
-
-/**
- * Find a file in a list of directories
- * @param dirs The directories to search in
- * @param filename The filename to search for
- * @returns The file info
- */
-export const findFileInDirs = (dirs: string[], filename: string): FileInfo => {
-    const FileInfo: FileInfo = {
-        path: null,
-        filename,
-        exists: false,
-    }
-    for (const dir of dirs) {
-        const filePath = Path.join(dir, filename)
-        FileInfo.exists = fs.existsSync(filePath)
-        if (FileInfo.exists) {
-            FileInfo.path = filePath
-            return FileInfo
-        }
-    }
-
-    return FileInfo
-}
-
-/**
- * Union (a ∪ b): create a set that contains the elements of both set a and set b.
- * See https://2ality.com/2015/01/es6-set-operations.html#union
- * @param target
- * @param source
- */
-export const union = <T>(target: Set<T> | T[], source: Set<T> | T[]): Set<T> => {
-    return (target = new Set<T>([...target, ...source]))
-}
-
-export const stripParamNames = (func: string, ignoreTail = false): string => {
-    const g = func
-    func = func.replace(COMMENT_REG_EXP, '')
-    const lb = func.split('(', 2)
-    if (lb.length < 2) Logger.error(`Bad function definition ${g}`)
-    const rb = lb[1].split(')')
-    const tail = ignoreTail ? '' : rb[rb.length - 1]
-    let params = rb.slice(0, rb.length - 1).join(')')
-    params = params.replace(PARAM_REG_EXP, ':')
-    params = params.replace(OPT_PARAM_REG_EXP, '?:')
-    return `${lb[0]}(${params})${tail}`
-}
-
-/**
- * Check if a line is a comment line
- * @param line The line to check
- * @returns Whether the line is a comment line or not
- */
-export const isCommentLine = (line: string) => {
-    const lineTrim = line.trim()
-    return lineTrim.startsWith('//') || (lineTrim.startsWith('/*') && lineTrim.endsWith('*/'))
-}
-
-/**
- * Add indents to a string
- * @param indents The number of indents
- * @param spaceForIndent The number of spaces for each indent
- * @returns The indented string
- */
-export const generateIndent = (indents = 1, spaceForIndent = 4): string => {
-    return ' '.repeat(indents * spaceForIndent)
-}
-
-// Get __filename on ESM
-export const __filename = fileURLToPath(import.meta.url)
-// Get __dirname on ESM
-export const __dirname = Path.dirname(__filename)
-
-/**
- * Get the output or input directory of the environment
- * @param environment The environment to get the directory for
- * @param baseDir The base directory
- * @returns The path to the directory
- */
-export const getEnvironmentDir = (environment: Environment, baseDir: string): string => {
-    if (!baseDir.endsWith(environment))
-        if (environment === 'gjs' && !baseDir.endsWith('/Gjs')) {
-            return Path.join(baseDir, 'Gjs')
-        }
-    if (environment === 'node' && !baseDir.endsWith('/node-gtk')) {
-        return Path.join(baseDir, 'node-gtk')
-    }
-    return baseDir
-}
-
-/**
- * Get the destination path for the environment
- * @param environment The environment to get the destination path for
- * @param outputDir The output directory
- * @param parts The path parts
- * @returns The destination path
- */
-export const getDestPath = (environment: Environment, outputDir: string, ...parts: string[]) => {
-    const outputEnvDir = getEnvironmentDir(environment, outputDir)
-    const destPath = Path.join(outputEnvDir, ...parts)
-    return destPath
-}
-
-/**
- * Convert a GirBoolean to a boolean
- * @param boolStr The GirBoolean string
- * @param defaultVal The default value
- * @returns The boolean value
- */
-export const girBool = (boolStr: string | undefined, defaultVal = false): boolean => {
-    if (boolStr) {
-        if (parseInt(boolStr) === 0) return false
-        return true
-    }
-    return defaultVal
-}
-
-/**
- * Returns `true` if the definitions in `d1` and `d2` have equivalent signatures
- * @param d1
- * @param d2
- */
-export const signaturesMatch = (d1: string, d2: string) => {
-    if (isCommentLine(d1) || isCommentLine(d2)) return false
-    return stripParamNames(d1) == stripParamNames(d2)
-}
-
-/**
- * GirElements contains an attribute `introspectable`, which is a GirBoolean.
- * If this is attribute is falsy the element is not introspectable,
- * this means doesn't exist in the bindings, due in general to missing information in the annotations in the original C code
- */
-export const girElementIsIntrospectable = (girElement?: { $: GirInfoAttrs & { name: string } }, name?: string) => {
-    if (!girElement) {
-        return false
-    }
-    name = name || girElement?.$?.name
-    if (!name) {
-        return false
-    }
-    // Handle introspectable only if the attribute is also present...
-    if (girElement.$.hasOwnProperty('introspectable') && girElement.$.introspectable !== undefined) {
-        return girBool(girElement.$.introspectable, true)
-    }
-    // ...otherwise we assume that it is introspectable
-    return true
-}
-
-/**
- * Check if a type is optional
- * @param types The types to check
- * @returns Whether the type is optional or not
- */
-export const typeIsOptional = (types: TsType[]) => {
-    for (const type of types) {
-        if (type.optional) return true
-    }
-    return false
-}
 
 /**
  * Get a typescript or javascript config by path
@@ -418,15 +25,15 @@ export const getTsJsConfigByPath = (path: string) => {
 export function readTsJsConfig(path: string) {
     let config: null | false | TsConfigJsonResolved = null
     let lastPath = ''
-    let currentPath = Path.resolve(path)
+    let currentPath = resolve(path)
     while (!config && currentPath !== lastPath) {
-        const tsConfigPath = Path.join(currentPath, 'tsconfig.json')
-        const jsConfigPath = Path.join(currentPath, 'jsconfig.json')
+        const tsConfigPath = join(currentPath, 'tsconfig.json')
+        const jsConfigPath = join(currentPath, 'jsconfig.json')
         config =
-            (fs.existsSync(tsConfigPath) && getTsJsConfigByPath(tsConfigPath)) ||
-            (fs.existsSync(jsConfigPath) && getTsJsConfigByPath(jsConfigPath))
+            (existsSync(tsConfigPath) && getTsJsConfigByPath(tsConfigPath)) ||
+            (existsSync(jsConfigPath) && getTsJsConfigByPath(jsConfigPath))
         lastPath = currentPath
-        currentPath = Path.dirname(currentPath)
+        currentPath = dirname(currentPath)
     }
 
     return config || null