@ts-for-gir/cli 3.0.0-beta.10

package/src/injection/injector.ts

@@ -0,0 +1,184 @@
+import type {
+    GirClassElement,
+    GirRecordElement,
+    GirUnionElement,
+    GirInterfaceElement,
+    GirCallbackElement,
+    GirCallableParamElement,
+    Environment,
+} from '../types/index.js'
+import { Logger } from '../logger.js'
+
+import { classesAll, classesGjs, classesNode, callbacksGjs, callbacksNode, callbacksAll } from './index.js'
+import { GirFactory } from '../gir-factory.js'
+
+/**
+ * Inject additional methods, properties, etc
+ */
+export class Injector {
+    girFactory = new GirFactory()
+    log: Logger
+
+    constructor(private readonly environment: Environment) {
+        this.log = new Logger(environment, true, 'ConflictResolver')
+    }
+
+    /** Inject additional generics, methods, properties, etc to a existing class */
+    toClass(girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement) {
+        if (!girClass._tsData) {
+            return
+        }
+
+        const classes = this.environment === 'gjs' ? [...classesAll, ...classesGjs] : [...classesAll, ...classesNode]
+
+        const toClass = classes.find((cls) => {
+            return (
+                girClass._tsData &&
+                cls.qualifiedName === girClass._tsData.qualifiedName &&
+                cls.versions.includes(girClass._tsData.version)
+            )
+        })
+
+        if (toClass) {
+            if (toClass.staticFunctions) {
+                girClass._tsData.staticFunctions.push(
+                    ...this.girFactory.newGirFunctions(toClass.staticFunctions, girClass._tsData, { isInjected: true }),
+                )
+            }
+            if (toClass.properties) {
+                girClass._tsData.properties.push(
+                    ...this.girFactory.newGirProperties(toClass.properties, { isInjected: true }),
+                )
+            }
+            if (toClass.constructors) {
+                girClass._tsData.constructors.push(
+                    ...this.girFactory.newGirFunctions(toClass.constructors, girClass._tsData, { isInjected: true }),
+                )
+            }
+            if (toClass.methods) {
+                girClass._tsData.methods.push(
+                    ...this.girFactory.newGirFunctions(toClass.methods, girClass._tsData, { isInjected: true }),
+                )
+            }
+            if (toClass.virtualMethods) {
+                girClass._tsData.virtualMethods.push(
+                    ...this.girFactory.newGirFunctions(toClass.virtualMethods, girClass._tsData, { isInjected: true }),
+                )
+            }
+            if (toClass.propertySignalMethods) {
+                for (const propertySignalMethod of toClass.propertySignalMethods) {
+                    propertySignalMethod.isInjected = true
+                    girClass._tsData.propertySignalMethods.push(propertySignalMethod)
+                }
+            }
+
+            if (toClass.generics) {
+                girClass._tsData.generics.push(...this.girFactory.newGenerics(toClass.generics))
+            }
+        }
+
+        return girClass
+    }
+
+    /** Inject additional generics to existing callback interfaces */
+    toCallback(girCallback: GirCallbackElement) {
+        const callbacks =
+            this.environment === 'gjs' ? [...callbacksAll, ...callbacksGjs] : [...callbacksAll, ...callbacksNode]
+
+        if (!girCallback._module || !girCallback._tsData) {
+            return girCallback
+        }
+
+        const toCallback = callbacks.find((injectCallback) => {
+            return (
+                girCallback._module &&
+                girCallback._tsData &&
+                injectCallback.name === girCallback._tsData.name &&
+                girCallback._module.namespace === injectCallback.namespace &&
+                injectCallback.versions.includes(girCallback._module.version)
+            )
+        })
+
+        // if (toCallback?.generics) {
+        //     girCallback._tsData.generics.push(...this.girFactory.newGenerics(toCallback.generics))
+        // }
+
+        // NOTICE: We merge the in parameters here
+        // TODO: Unify injections, merges and overrides
+        if (toCallback?.inParams) {
+            for (let i = 0; i < girCallback._tsData.inParams.length; i++) {
+                const newInParam = toCallback.inParams[i]
+                const oldInParam = girCallback._tsData.inParams[i]
+                if (newInParam && oldInParam && oldInParam._tsData?.name === newInParam.name) {
+                    oldInParam._tsData.type = this.girFactory.newTsTypes(newInParam.type)
+                }
+            }
+        }
+
+        if (toCallback?.tsCallbackInterface) {
+            if (toCallback?.tsCallbackInterface.generics) {
+                girCallback._tsData.tsCallbackInterface?.generics.push(
+                    ...this.girFactory.newGenerics(toCallback.tsCallbackInterface.generics),
+                )
+            }
+        }
+
+        return girCallback
+    }
+
+    toParameterType(girParam: GirCallableParamElement) {
+        const tsTypes = girParam._tsData?.type
+
+        const callbacks =
+            this.environment === 'gjs' ? [...callbacksAll, ...callbacksGjs] : [...callbacksAll, ...callbacksNode]
+
+        if (!girParam._module || !girParam._tsData) {
+            return girParam
+        }
+
+        // Use the the callback generic injections also for the type of the callback parameters
+        if (tsTypes) {
+            for (const tsType of tsTypes) {
+                const toCallback = callbacks.find((injectCallback) => {
+                    return (
+                        girParam._module &&
+                        girParam._tsData &&
+                        // TODO: compare versions
+                        `${injectCallback.namespace}.${injectCallback.name}` === tsType.type
+                    )
+                })
+
+                if (toCallback?.generics) {
+                    const tsFunc = girParam._tsData.parent
+                    const tsClass = tsFunc.parent
+                    for (const generic of toCallback.generics) {
+                        // Currently only used for `Gio.AsyncReadyCallback`
+                        if (generic.value === 'this') {
+                            if (tsFunc.isStatic && tsClass) {
+                                tsType.generics.push({
+                                    ...generic,
+                                    value: `${tsClass.namespace}.${tsClass.name}`,
+                                })
+                            } else if (tsFunc.isGlobal) {
+                                // Add generic parameter to global function
+                                tsFunc.generics.push({
+                                    name: 'Z',
+                                    value: 'unknown',
+                                })
+                                tsType.generics.push({
+                                    value: 'Z',
+                                })
+                            } else {
+                                tsType.generics.push(generic)
+                            }
+                        } else {
+                            tsType.generics.push(generic)
+                        }
+                    }
+                }
+            }
+        }
+
+        return girParam
+    }
+}

package/src/logger.ts

@@ -0,0 +1,134 @@
+/**
+ * A logger that displays information in different colors on the console.
+ * In addition, the environment or the module currently being processed is also included as prepended to the logging string
+ */
+
+import { blue, yellow, yellowBright, green, red, white } from 'colorette'
+import { Environment } from './types/index.js'
+
+export class Logger {
+    constructor(
+        private readonly environment: Environment | '',
+        private readonly verbose: boolean,
+        private readonly moduleName: string,
+    ) {}
+    private static prepend(args: unknown[], prepend: string): unknown[] {
+        if (typeof args[0] === 'string') {
+            args[0] = `${prepend}${args[0]}`
+        }
+        return args
+    }
+    /**
+     * Returns something like '[node][Gda-5.0] Could not find type 'Gda.SqlExpr' for 'expr''
+     * @param args
+     * @param logLevel
+     */
+    private prependInfos(args: unknown[], logLevel?: 'WARN:' | 'ERROR:' | 'INFO:' | 'DEBUG:'): unknown[] {
+        if (logLevel || this.moduleName.length > 0 || this.environment.length > 0) {
+            args = Logger.prepend(args, ' ')
+        }
+        if (logLevel) {
+            if (this.moduleName.length > 0 || this.environment.length > 0) {
+                args = Logger.prepend(args, ' ' + logLevel)
+            } else {
+                args = Logger.prepend(args, logLevel)
+            }
+        }
+        if (this.moduleName.length > 0) {
+            args = Logger.prepend(args, `[${this.moduleName}]`)
+        }
+        if (this.environment.length > 0) {
+            args = Logger.prepend(args, `[${this.environment}]`)
+        }
+
+        return args
+    }
+
+    public log(...args: unknown[]): void {
+        if (!this.verbose) {
+            return
+        }
+        return console.log(...args)
+    }
+    public dir(...args: unknown[]): void {
+        if (!this.verbose) {
+            return
+        }
+        args.forEach((arg) => {
+            console.dir(arg)
+        })
+        return
+    }
+    public info(txt: string | number, ...args: unknown[]): void {
+        if (!this.verbose) {
+            return
+        }
+        return console.info(blue(txt), ...args)
+    }
+    public warn(txt: string | number, ...args: unknown[]): void {
+        if (!this.verbose) {
+            return
+        }
+        args = this.prependInfos([txt], 'WARN:')
+        return console.warn(yellow(txt), ...args)
+    }
+    public debug(txt: string | number, ...args: unknown[]): void {
+        if (!this.verbose) {
+            return
+        }
+        args = this.prependInfos([txt], 'DEBUG:')
+        return console.debug(yellowBright(txt), ...args)
+    }
+    public error(txt: string | number, ...args: unknown[]): void {
+        args = this.prependInfos([txt], 'ERROR:')
+        return this.danger(txt, args)
+    }
+    public success(txt: string | number, ...args: unknown[]): void {
+        if (!this.verbose) {
+            return
+        }
+        this.log(green(txt), ...args)
+    }
+    public danger(txt: string | number, ...args: unknown[]): void {
+        this.log(red(txt), ...args)
+    }
+
+    // Static versions (Here it must be ensured that Verbose is activated)
+    public static log(...args: unknown[]): void {
+        return console.log(...args)
+    }
+    public static dir(...args: unknown[]): void {
+        args.forEach((arg) => {
+            console.dir(arg)
+        })
+        return
+    }
+    public static info(txt: string | number, ...args: unknown[]): void {
+        ;[txt, ...args] = this.prepend([txt, ...args], 'INFO: ') as [string, ...unknown[]]
+        return console.info(blue(txt), ...args)
+    }
+    public static warn(txt: string | number, ...args: unknown[]): void {
+        ;[txt, ...args] = this.prepend([txt, ...args], 'WARN: ') as [string, ...unknown[]]
+        return console.warn(yellow(txt), ...args)
+    }
+    public static debug(txt: string | number, ...args: unknown[]): void {
+        ;[txt, ...args] = this.prepend([txt, ...args], 'DEBUG: ') as [string, ...unknown[]]
+        return console.debug(yellowBright(txt), ...args)
+    }
+    public static error(txt: string | number, ...args: unknown[]): void {
+        ;[txt, ...args] = this.prepend([txt, ...args], 'ERROR: ') as [string, ...unknown[]]
+        return this.danger(txt, args)
+    }
+    public static success(txt: string | number, ...args: unknown[]): void {
+        this.log(green(txt), ...args)
+    }
+    public static danger(txt: string | number, ...args: unknown[]): void {
+        this.log(red(txt), ...args)
+    }
+    public static white(txt: string | number, ...args: unknown[]): void {
+        this.log(white(txt), ...args)
+    }
+    public static yellow(txt: string | number, ...args: unknown[]): void {
+        this.log(yellow(txt), ...args)
+    }
+}

package/src/messages.ts

@@ -0,0 +1,69 @@
+import type { Environment, BuildType } from './types/index.js'
+
+export const NO_TSDATA = (namespace?: string) => {
+    let message = 'You need to set the tsData first!'
+    if (namespace) message = `[${namespace}] ${message}`
+    return message
+}
+
+// Error messages
+
+export const ERROR_NO_MODULES_FOUND = (girDirectories: string[]) => `No module found in ${girDirectories.join(', ')}!
+Please make sure that you have installed the necessary gir files.
+For example with "sudo apt install libgtk-3-dev" for Gtk3 on Ubuntu or "sudo dnf install gtk3-devel" on Fedora.`
+export const ERROR_CONFIG_EXTENSION_UNSUPPORTED =
+    'Only configs with the extension .js and .json are currently supported. Do nothing'
+export const ERROR_NO_MODULE_SPECIFIED = 'Need to specify modules!'
+
+// Warn messages
+
+export const WARN_NO_GIR_FILE_FOUND_FOR_PACKAGE = (packageName: string) =>
+    `No gir file found for '${packageName}', this module will be ignored`
+export const WARN_CONSTANT_ALREADY_EXPORTED = (name: string) => `The constant '${name}' has already been exported`
+export const WARN_NO_NAMESPACE_ON_TYPES = "noNamespace must be 'false' if buildType is 'types'"
+export const WARN_NO_NAMESPACE_ON_ESM = "noNamespace must be 'false' on moduleType 'esm'"
+export const WARN_USE_ESM_FOR_ALIAS = "moduleType must be 'esm' if generateAlias is true!"
+export const WARN_USE_GJS_FOR_ALIAS = "environments must include 'gjs' if generateAlias is true!"
+
+export const WARN_IGNORE_MULTIPLE_CALLBACKS = 'Multiple callbacks are ignored!'
+export const WARN_IGNORE_MULTIPLE_FUNC_DESC = 'Ignore multiline function description!'
+
+export const WARN_DUPLICATE_ENUM_IDENTIFIER = (name: string, renamed: string) =>
+    `Enum has a duplicate identifier '${name}', renamed to '${renamed}'!`
+export const WARN_DUPLICATE_SYMBOL = (symbol: string) => `Duplicate symbol: ${symbol}`
+export const WARN_DUPLICATE_PARAMETER = (paramName: string, namespace?: string) => {
+    let message = `Duplicate parameter name "${paramName}" found!`
+    if (namespace) message = `[${namespace}] ${message}`
+    return message
+}
+
+export const WARN_NOT_FOUND_TYPE = (logName: string) => `Could not find type for "${logName}"`
+export const WARN_NOT_FOUND_PACKAGE_NAME = (namespace: string, implementation: string) =>
+    `Package name for namespace ${namespace} not found! (${implementation})`
+export const WARN_NOT_FOUND_DEPENDENCY_GIR_FILE = (girFilename: string) =>
+    `Dependency gir file not found: '${girFilename}'`
+
+export const WARN_RENAMED_PROPERTY = (originalName: string, newName: string) =>
+    `Property name renamed from '${originalName}' to '${newName}'`
+export const WARN_RENAMED_FUNCTION = (originalName: string, newName: string) =>
+    `Function name renamed from '${originalName}' to '${newName}'`
+export const WARN_RENAMED_CLASS = (originalName: string, newName: string) =>
+    `Class name renamed from '${originalName}' to '${newName}'`
+export const WARN_RENAMED_CONSTANT = (originalName: string, newName: string) =>
+    `Constant name renamed from '${originalName}' to '${newName}'`
+export const WARN_RENAMED_FIELD = (originalName: string, newName: string) =>
+    `Field name renamed from '${originalName}' to '${newName}'`
+export const WARN_RENAMED_ENUM = (originalName: string, newName: string) =>
+    `Enum name renamed from '${originalName}' to '${newName}'`
+export const WARN_RENAMED_PARAMETER = (originalName: string, newName: string) =>
+    `Parameter name renamed from '${originalName}' to '${newName}'`
+
+// Info messages
+
+export const DANGER_HTML_DOC_GENERATOR_NOT_IMPLEMENTED =
+    'The HtmlDocGenerator is currently not implemented. Do nothing...'
+export const START_MODULE = (environment: Environment, buildType?: BuildType) =>
+    `Start to generate .d.ts files for '${environment}' as '${buildType || 'unknown'}'.`
+export const FILE_PARSING_DONE = 'Files parsed, loading types...'
+export const TSDATA_PARSING_DONE = 'Typescript data loaded, generating .d.ts...'
+export const GENERATING_TYPES_DONE = 'Done.'