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

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 fs from 'fs'
+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,20 +29,16 @@ 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 { splitModuleName, union, isIterable, map, findFileInDirs } 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)
     }
 
     /**
@@ -38,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) {
@@ -65,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[] } {
@@ -99,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,
@@ -109,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 {
@@ -122,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
@@ -149,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 = {
@@ -166,7 +177,7 @@ export class ModuleLoader {
      * @param girModulesGroupedMap
      * @param packageName
      */
-    private findModulesDependOnPackage(
+    protected findPackageNamesDependOnPackage(
         girModulesGroupedMap: GirModulesGroupedMap,
         packageName: string,
     ): GirModuleResolvedBy[] {
@@ -177,7 +188,7 @@ export class ModuleLoader {
                     continue
                 }
                 for (const dep of girModuleResolvedBy.module.dependencies) {
-                    if (dep === packageName && !girModules.includes(girModuleResolvedBy)) {
+                    if (dep.packageName === packageName && !girModules.includes(girModuleResolvedBy)) {
                         girModules.push(girModuleResolvedBy)
                     }
                 }
@@ -191,18 +202,18 @@ export class ModuleLoader {
      * @param girModulesGroupedMap
      * @param packageName
      */
-    private findModulesDependOnPackages(
+    protected findPackageNamesDependOnPackages(
         girModulesGroupedMap: GirModulesGroupedMap,
         packageNames: string[],
     ): GirModuleResolvedBy[] {
         let girModules: GirModuleResolvedBy[] = []
         for (const packageName of packageNames) {
-            girModules = girModules.concat(this.findModulesDependOnPackage(girModulesGroupedMap, packageName))
+            girModules = girModules.concat(this.findPackageNamesDependOnPackage(girModulesGroupedMap, packageName))
         }
         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) {
@@ -233,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[] }> {
@@ -260,7 +271,10 @@ export class ModuleLoader {
                 while (goBack) {
                     versionAnswer = await this.askForVersionsPrompt(girModulesGrouped)
                     // Check modules that depend on the unchosen modules
-                    wouldIgnoreDeps = this.findModulesDependOnPackages(girModulesGroupedMap, versionAnswer.unselected)
+                    wouldIgnoreDeps = this.findPackageNamesDependOnPackages(
+                        girModulesGroupedMap,
+                        versionAnswer.unselected,
+                    )
                     // Do not check dependencies that have already been ignored
                     wouldIgnoreDeps = wouldIgnoreDeps.filter((dep) => !ignore.includes(dep.packageName))
                     ignoreDepsAnswer = await this.askIgnoreDepsPrompt(wouldIgnoreDeps)
@@ -298,9 +312,9 @@ export class ModuleLoader {
 
     /**
      * Asks via cli prompt if the user wants to add the ignored modules to his config file
-     * @param ignore
+     * @param ignoredModules
      */
-    private async askAddToIgnoreToConfigPrompt(ignore: string[] | Set<string>): Promise<void> {
+    protected async askAddToIgnoreToConfigPrompt(ignoredModules: string[] | Set<string>): Promise<void> {
         const questions = [
             {
                 name: 'addToIgnore',
@@ -315,7 +329,7 @@ export class ModuleLoader {
 
         if (answer.addToIgnore === 'Yes') {
             await Config.addToConfig({
-                ignore: Array.from(ignore),
+                ignore: Array.from(ignoredModules),
             })
             this.log.log(`Add ignored modules to '${Config.configFilePath}'`)
         }
@@ -326,12 +340,12 @@ export class ModuleLoader {
      * @param packageName
      * @param result
      */
-    private traverseDependencies(packageName: string, result: { [name: string]: 1 } = {}): void {
+    protected traverseDependencies(packageName: string, result: { [name: string]: Dependency } = {}): void {
         const deps = this.modDependencyMap[packageName]
         if (isIterable(deps)) {
             for (const dep of deps) {
                 if (result[dep.packageName]) continue
-                result[dep.packageName] = 1
+                result[dep.packageName] = dep
                 this.traverseDependencies(dep.packageName, result)
             }
         }
@@ -342,18 +356,8 @@ export class ModuleLoader {
      * should be called for each girModule so that the modDependencyMap is complete
      * @param girModule
      */
-    private extendDependencyMapByGirModule(girModule: GirModule): void {
-        this.modDependencyMap[girModule.packageName || '-'] = map(
-            girModule.dependencies || [],
-            (packageName: string): Dependency => {
-                const { namespace, version } = splitModuleName(packageName)
-                return {
-                    namespace,
-                    version,
-                    packageName,
-                }
-            },
-        )
+    protected extendDependencyMapByGirModule(girModule: GirModule): void {
+        this.modDependencyMap[girModule.packageName] = girModule.dependencies
     }
 
     /**
@@ -361,11 +365,11 @@ 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]: 1 } = {}
+            const result: { [name: string]: Dependency } = {}
             this.traverseDependencies(girModule.packageName, result)
-            girModule.module.transitiveDependencies = Object.keys(result)
+            girModule.module.transitiveDependencies = Object.values(result)
         }
     }
 
@@ -375,14 +379,13 @@ export class ModuleLoader {
      * @param fillName
      * @param config
      */
-    private async loadAndCreateGirModule(packageName: string): Promise<GirModule | null> {
-        const file = findFileInDirs(this.config.girDirectories, packageName + '.gir')
-        if (!file.exists || file.path === null) {
+    protected async loadAndCreateGirModule(dependency: Dependency): Promise<GirModule | null> {
+        if (!dependency.exists || dependency.path === null) {
             return null
         }
 
-        this.log.log(`Parsing ${file.path}...`)
-        const fileContents = fs.readFileSync(file.path, 'utf8')
+        this.log.log(`Parsing ${dependency.path}...`)
+        const fileContents = await readFile(dependency.path, 'utf8')
         const result = (await xml2js.parseStringPromise(fileContents)) as ParsedGir
         const girModule = new GirModule(result, this.config)
         // Figure out transitive module dependencies
@@ -395,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> {
@@ -407,41 +410,42 @@ export class ModuleLoader {
      * @param girModules
      * @param packageName
      */
-    private existsGirModules(girModules: (GirModuleResolvedBy | GirModule)[], packageNames: string[]): boolean {
-        const foundModule = this.findGirModuleByFullNames(girModules, packageNames)
+    protected existsGirModules(girModules: (GirModuleResolvedBy | GirModule)[], packageName: string): boolean {
+        const foundModule = this.findGirModuleByFullNames(girModules, [packageName])
         return foundModule.length > 0
     }
 
     /**
      *  Reads the gir xml module files and creates an object of GirModule for each module
-     * @param girModulesToRead
+     * @param dependencies
      * @param girModules
      * @param resolvedBy
      * @param failedGirModules
      * @param ignoreDependencies
      * @returns
      */
-    private async loadGirModules(
-        girModulesToRead: string[] | Set<string>,
+    protected async loadGirModules(
+        dependencies: Dependency[],
         ignoreDependencies: string[] = [],
         girModules: GirModuleResolvedBy[] = [],
         resolvedBy = ResolveType.BY_HAND,
         failedGirModules = new Set<string>(),
     ): Promise<{ loaded: GirModuleResolvedBy[]; failed: Set<string> }> {
-        // A copy is needed here because we are changing the array for the while loop
-        const girToLoad = Array.from(girModulesToRead)
         let newModuleFound = false
 
-        while (girToLoad.length > 0) {
-            const packageName = girToLoad.shift() || 'unknown'
-            if (!packageName) throw new Error(`Module name '${packageName} 'not found!`)
+        // Clone array
+        dependencies = [...dependencies]
+
+        while (dependencies.length > 0) {
+            const dependency = dependencies.shift()
+            if (!dependency?.packageName) continue
             // If module has not already been loaded
-            if (!this.existsGirModules(girModules, [packageName])) {
-                const girModule = await this.loadAndCreateGirModule(packageName)
+            if (!this.existsGirModules(girModules, dependency.packageName)) {
+                const girModule = await this.loadAndCreateGirModule(dependency)
                 if (!girModule) {
-                    if (!failedGirModules.has(packageName)) {
-                        this.log.warn(WARN_NO_GIR_FILE_FOUND_FOR_PACKAGE(packageName))
-                        failedGirModules.add(packageName)
+                    if (!failedGirModules.has(dependency.packageName)) {
+                        this.log.warn(WARN_NO_GIR_FILE_FOUND_FOR_PACKAGE(dependency.packageName))
+                        failedGirModules.add(dependency.packageName)
                     }
                 } else if (girModule && girModule.packageName) {
                     const addModule = {
@@ -471,9 +475,9 @@ export class ModuleLoader {
             const transitiveDependencies = girModule.module.transitiveDependencies
             if (transitiveDependencies.length > 0) {
                 for (const transitiveDependency of transitiveDependencies) {
-                    if (ignoreDependencies.includes(transitiveDependency)) {
+                    if (ignoreDependencies.includes(transitiveDependency.packageName)) {
                         this.log.warn(
-                            `Load dependency "${transitiveDependency}" which is in the ignore list, if this should really be ignored also ignore "${girModule.packageName}"`,
+                            `Load dependency "${transitiveDependency.packageName}" which is in the ignore list, if this should really be ignored also ignore "${girModule.packageName}"`,
                         )
                     }
                 }
@@ -498,7 +502,7 @@ export class ModuleLoader {
      * @param modules
      * @param ignore
      */
-    private async findModules(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++) {
@@ -513,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)
@@ -528,18 +532,26 @@ export class ModuleLoader {
         return foundModules
     }
 
+    protected packageNamesToDependencies(packageNames: Set<string>): Dependency[] {
+        return Array.from(packageNames).map((packageName) => {
+            const { namespace, version } = splitModuleName(packageName)
+            return this.dependencyManager.get(namespace, version)
+        })
+    }
+
     /**
-     * Loads all found modules and sorts out those that the user does not want to use including their dependencies
+     * Loads all found `packageNames` and sorts out those that the user does not want to use including their dependencies
      * @param girDirectories
-     * @param modules
+     * @param packageNames
      */
     public async getModulesResolved(
-        modules: string[],
+        packageNames: string[],
         ignore: string[] = [],
         doNotAskForVersionOnConflict = true,
     ): Promise<{ keep: GirModuleResolvedBy[]; grouped: GirModulesGroupedMap; ignore: string[]; failed: Set<string> }> {
-        const foundGirModules = await this.findModules(modules, ignore)
-        const { loaded, failed } = await this.loadGirModules(foundGirModules, ignore)
+        const foundPackageNames = await this.findPackageNames(packageNames, ignore)
+        const dependencies = this.packageNamesToDependencies(foundPackageNames)
+        const { loaded, failed } = await this.loadGirModules(dependencies, ignore)
         let keep: GirModuleResolvedBy[] = []
         if (doNotAskForVersionOnConflict) {
             keep = loaded
@@ -563,8 +575,9 @@ export class ModuleLoader {
         modules: string[],
         ignore: string[] = [],
     ): Promise<{ grouped: GirModulesGroupedMap; loaded: GirModuleResolvedBy[]; failed: string[] }> {
-        const foundGirModules = await this.findModules(modules, ignore)
-        const { loaded, failed } = await this.loadGirModules(foundGirModules, ignore)
+        const foundPackageNames = await this.findPackageNames(modules, ignore)
+        const dependencies = this.packageNamesToDependencies(foundPackageNames)
+        const { loaded, failed } = await this.loadGirModules(dependencies, ignore)
         const grouped = this.groupGirFiles(loaded)
         return { grouped, loaded, failed: Array.from(failed) }
     }

package/src/utils.ts

@@ -1,223 +1,13 @@
-/* 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 } 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 }
-
-export const isEqual = lodash.isEqual
-
-export const map = lodash.map
-
-export const find = lodash.find
-
-export const merge = lodash.merge
-
-export const clone = lodash.clone
-
-export const cloneDeep = lodash.cloneDeep
-
-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
-
-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
+ * Get a typescript or javascript config by path
+ * @param path The path to search for a tsconfig.json or jsconfig.json file
+ * @returns The config or null if not found
  */
-export const isIterable = (obj: unknown[]): boolean => {
-    return obj != null && typeof obj[Symbol.iterator] === 'function'
-}
-
-export const isNumeric = (str: string): boolean => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return !isNaN((str as any) - parseFloat(str))
-}
-
-export const getFirstChar = (str: string): string => {
-    return str.charAt(0)
-}
-
-export const getLastChar = (str: string): string => {
-    return str.charAt(str.length - 1)
-}
-
-export const isFirstCharNumeric = (str: string): boolean => {
-    return isNumeric(getFirstChar(str))
-}
-
-export const camelCase = (str: string): string => {
-    return str
-        .replace(/\s(.)|(\s|-|_|\.)(.)/g, (a) => {
-            return a.toUpperCase()
-        })
-        .replace(/(\s|-|_|\.)/g, '')
-}
-
-export const lowerCamelCase = (str: string): string => {
-    str = camelCase(str)
-    str = getFirstChar(str).toLowerCase() + str.slice(1)
-    return str
-}
-
-export const upperCamelCase = (str: string): string => {
-    str = camelCase(str)
-    str = getFirstChar(str).toUpperCase() + str.slice(1)
-    return str
-}
-
-export const findFileInDirs = (dirs: string[], filename: string): { path: string | null; exists: boolean } => {
-    let exists = false
-    for (const dir of dirs) {
-        const filePath = Path.join(dir, filename)
-        exists = fs.existsSync(filePath)
-        if (exists) {
-            return {
-                path: filePath,
-                exists,
-            }
-        }
-    }
-    return {
-        path: null,
-        exists,
-    }
-}
-
-/**
- * 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}`
-}
-
-export const isCommentLine = (line: string) => {
-    const lineTrim = line.trim()
-    return lineTrim.startsWith('//') || (lineTrim.startsWith('/*') && lineTrim.endsWith('*/'))
-}
-
-export const generateIndent = (indents = 1, spaceForIndent = 4): string => {
-    return ' '.repeat(indents * spaceForIndent)
-}
-
-// Get __dirname on ESM
-export const __filename = fileURLToPath(import.meta.url)
-export const __dirname = Path.dirname(__filename)
-
-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
-}
-
-export const getDestPath = (environment: Environment, outputDir: string, ...parts: string[]) => {
-    const outputEnvDir = getEnvironmentDir(environment, outputDir)
-    const destPath = Path.join(outputEnvDir, ...parts)
-    return destPath
-}
-
-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
-}
-
-export const typeIsOptional = (types: TsType[]) => {
-    for (const type of types) {
-        if (type.optional) return true
-    }
-    return false
-}
-
-function convertTsJsConfigToObject(path: string) {
+export const getTsJsConfigByPath = (path: string) => {
     try {
         const config = getTsconfig(path)?.config
         if (config) return config
@@ -235,15 +25,15 @@ function convertTsJsConfigToObject(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) && convertTsJsConfigToObject(tsConfigPath)) ||
-            (fs.existsSync(jsConfigPath) && convertTsJsConfigToObject(jsConfigPath))
+            (existsSync(tsConfigPath) && getTsJsConfigByPath(tsConfigPath)) ||
+            (existsSync(jsConfigPath) && getTsJsConfigByPath(jsConfigPath))
         lastPath = currentPath
-        currentPath = Path.dirname(currentPath)
+        currentPath = dirname(currentPath)
     }
 
     return config || null