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

package/src/type-definition-generator.ts

@@ -0,0 +1,1467 @@
+import type {
+    GenerateConfig,
+    InheritanceTable,
+    GirClassElement,
+    GirCallableParamElement,
+    GirSignalElement,
+    GirEnumElement,
+    GirAliasElement,
+    GirInterfaceElement,
+    GirUnionElement,
+    GirModulesGrouped,
+    GirRecordElement,
+    GirBitfieldElement,
+    GirInstanceParameter,
+    TsGenericParameter,
+    TsType,
+    TsDoc,
+    TsFunction,
+    TsCallback,
+    TsSignal,
+    TsMember,
+    TsVar,
+    TsProperty,
+    TsParameter,
+} from './types/index.js'
+import { Generator } from './generator.js'
+import type { GirModule } from './gir-module.js'
+import TemplateProcessor from './template-processor.js'
+import { Logger } from './logger.js'
+import {
+    generateIndent,
+    removeNamespace,
+    removeClassModule,
+    girElementIsIntrospectable,
+    typeIsOptional,
+} from './utils.js'
+import {
+    NO_TSDATA,
+    WARN_NOT_FOUND_DEPENDENCY_GIR_FILE,
+    WARN_IGNORE_MULTIPLE_CALLBACKS,
+    WARN_IGNORE_MULTIPLE_FUNC_DESC,
+} from './messages.js'
+
+export default class TypeDefinitionGenerator implements Generator {
+    protected log: Logger
+    constructor(protected readonly config: GenerateConfig) {
+        this.log = new Logger(config.environment, config.verbose, TypeDefinitionGenerator.name)
+    }
+
+    /**
+     *
+     * @param namespace E.g. 'Gtk'
+     * @param packageName E.g. 'Gtk-3.0'
+     * @param asExternType Currently only used for node type imports
+     */
+    private generateModuleDependenciesImport(namespace: string, packageName: string, asExternType = false): string[] {
+        const def: string[] = []
+        const sas = !this.config.noNamespace && packageName !== 'Gjs' ? '' : '* as '
+        if (this.config.buildType === 'lib') {
+            def.push(`import type ${sas}${namespace} from './${packageName}.js';`)
+        } else if (this.config.buildType === 'types') {
+            if (asExternType) {
+                // def.push(`/// <reference types="${packageName}" />`)
+                def.push(`import ${namespace} from "${packageName}.js"`)
+            } else {
+                def.push(`/// <reference path="${packageName}.d.ts" />`)
+                def.push(`import type ${sas}${namespace} from './${packageName}.js';`)
+            }
+        }
+        return def
+    }
+
+    private generateExport(type: string, name: string, definition: string, indentCount = 0) {
+        const exp = !this.config.noNamespace || this.config.buildType === 'types' ? '' : 'export '
+        const indent = generateIndent(indentCount)
+        if (!definition.startsWith(':')) {
+            definition = ' ' + definition
+        }
+        return `${indent}${exp}${type} ${name}${definition}`
+    }
+
+    private generateProperty(tsProp: TsProperty, onlyStatic: boolean, namespace: string, indentCount = 0) {
+        if (!tsProp) {
+            throw new Error('[generateProperty] Not all required properties set!')
+        }
+
+        const desc: string[] = []
+        const isStatic = tsProp.isStatic
+
+        if ((isStatic && !onlyStatic) || (!isStatic && onlyStatic)) {
+            return desc
+        }
+
+        if (!tsProp.hasUnresolvedConflict) {
+            desc.push(...this.addGirDocComment(tsProp.doc, indentCount))
+        }
+
+        const indent = generateIndent(indentCount)
+        const varDesc = this.generateVariable(tsProp, namespace, 0, false)
+        const staticStr = isStatic ? 'static ' : ''
+        const readonly = tsProp.readonly ? 'readonly ' : ''
+
+        // temporary solution, will be solved differently later
+        const commentOut = tsProp.hasUnresolvedConflict ? '// Has conflict: ' : ''
+
+        desc.push(`${indent}${commentOut}${staticStr}${readonly}${varDesc}`)
+        return desc
+    }
+
+    private generateProperties(
+        tsProps: TsProperty[],
+        onlyStatic: boolean,
+        namespace: string,
+        comment: string,
+        indentCount = 0,
+    ) {
+        const def: string[] = []
+        for (const tsProp of tsProps) {
+            def.push(...this.generateProperty(tsProp, onlyStatic, namespace, indentCount))
+        }
+
+        if (def.length > 0) {
+            def.unshift(...this.addInfoComment(comment, indentCount))
+        }
+
+        return def
+    }
+
+    private generateVariableCallbackType(tsType: TsType, namespace: string) {
+        // The type of a callback is a functions definition
+
+        let typeStr = 'any'
+
+        const { callbacks } = tsType
+
+        if (!callbacks.length) return typeStr
+
+        if (callbacks.length > 1) {
+            this.log.warn(WARN_IGNORE_MULTIPLE_CALLBACKS)
+        }
+
+        const girCallback = callbacks[0]
+
+        if (!girCallback._tsData) {
+            throw new Error(NO_TSDATA('generateVariableCallbackType'))
+        }
+
+        const funcDesc = this.generateFunction(girCallback._tsData, false, namespace, 0)
+
+        if (girCallback._tsData && funcDesc?.length) {
+            if (funcDesc.length > 1) {
+                this.log.warn(WARN_IGNORE_MULTIPLE_FUNC_DESC)
+            }
+            typeStr = funcDesc[0]
+        }
+
+        return typeStr
+    }
+
+    private generateVariable(tsVar: TsProperty | TsVar, namespace: string, indentCount = 0, allowCommentOut = true) {
+        const indent = generateIndent(indentCount)
+        const name = tsVar.name
+        const optional = typeIsOptional(tsVar.type)
+
+        if (!name) {
+            throw new Error('[generateVariable] "name" not set!')
+        }
+
+        const affix = optional ? '?' : ''
+        const typeStr = this.generateTypes(tsVar.type, namespace)
+
+        // temporary solution, will be solved differently later
+        const commentOut = allowCommentOut && tsVar.hasUnresolvedConflict ? '// Has conflict: ' : ''
+
+        return `${indent}${commentOut}${name}${affix}: ${typeStr}`
+    }
+
+    private generateTypes(tsTypes: TsType[], namespace: string) {
+        let def = ''
+        for (const tsType of tsTypes) {
+            const separator = tsType.leftSeparator || '|'
+            const typeStr = this.generateType(tsType, namespace)
+            if (!def) {
+                def = typeStr
+            } else {
+                def += ` ${separator} ${typeStr}`
+            }
+        }
+        return def
+    }
+
+    private generateGenericValues(tsType: TsType, namespace: string) {
+        // We just use the generic values here
+        const genericValues = tsType.generics.map((g) => removeNamespace(g.value || '', namespace)).filter((g) => !!g)
+        const genericStr = tsType.generics.length ? `<${genericValues.join(', ')}>` : ''
+        return genericStr
+    }
+
+    private generateType(tsType: TsType, namespace: string) {
+        let typeName = removeNamespace(tsType.type, namespace)
+
+        if (tsType.callbacks.length) {
+            typeName = this.generateVariableCallbackType(tsType, namespace)
+        }
+
+        if (!typeName) {
+            throw new Error('[generateVariable] "typeName" not set!')
+        }
+
+        let prefix = tsType.isArray ? '[]' : ''
+        prefix += tsType.nullable ? ' | null' : ''
+
+        // We just use the generic values here
+        const genericStr = this.generateGenericValues(tsType, namespace)
+
+        return `${typeName}${genericStr}${prefix}`
+    }
+
+    /**
+     * Generates signals from all properties of a base class
+     * TODO: Build new `GirSignalElement`s in `gir-module.ts` instead of generate the strings directly
+     * @param girClass
+     * @param namespace
+     * @param indentCount
+     * @returns
+     */
+    private generateClassPropertySignals(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        namespace: string,
+        indentCount = 1,
+    ) {
+        const def: string[] = []
+
+        if (!girClass._tsData || !girClass._fullSymName || !girClass._module) {
+            throw new Error(NO_TSDATA('generateClassPropertySignals'))
+        }
+
+        if (girClass._tsData?.isDerivedFromGObject) {
+            if (girClass._tsData.propertySignalMethods.length > 0) {
+                def.push(
+                    ...this.addInfoComment(
+                        `Class property signals of ${girClass._module?.packageName}.${girClass._fullSymName}`,
+                        indentCount,
+                    ),
+                )
+                for (const tsSignalMethod of girClass._tsData.propertySignalMethods) {
+                    if (!tsSignalMethod) {
+                        continue
+                    }
+                    def.push(...this.generateFunction(tsSignalMethod, false, namespace, indentCount))
+                }
+            }
+        }
+        return def
+    }
+
+    private generateInParameters(
+        inParams: GirCallableParamElement[],
+        instanceParameters: GirInstanceParameter[],
+        namespace: string,
+    ) {
+        const inParamsDef: string[] = []
+
+        // TODO: Should use of a constructor, and even of an instance, be discouraged?
+        for (const instanceParameter of instanceParameters) {
+            if (instanceParameter._tsData) {
+                let { structFor } = instanceParameter._tsData
+                const { name } = instanceParameter._tsData
+                const gobject = namespace === 'GObject' || namespace === 'GLib' ? '' : 'GObject.'
+
+                structFor = removeNamespace(structFor, namespace)
+
+                const returnTypes = [structFor, 'Function', `${gobject}GType`]
+                inParamsDef.push(`${name}: ${returnTypes.join(' | ')}`)
+            }
+        }
+
+        for (const inParam of inParams) {
+            if (inParam._tsData) inParamsDef.push(...this.generateParameter(inParam._tsData, namespace))
+        }
+
+        return inParamsDef
+    }
+
+    private generateSignals(
+        girSignals: GirSignalElement[],
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        namespace: string,
+        indentCount = 0,
+    ) {
+        const def: string[] = []
+
+        for (const girSignal of girSignals) {
+            if (girSignal._tsData?.tsMethods?.length) {
+                for (const tsSignalMethod of girSignal._tsData?.tsMethods) {
+                    if (!tsSignalMethod) {
+                        continue
+                    }
+                    def.push(...this.generateFunction(tsSignalMethod, false, namespace, indentCount))
+                }
+            }
+        }
+        return def
+    }
+
+    /**
+     * Adds documentation comments
+     * @see https://github.com/microsoft/tsdoc
+     * @param lines
+     * @param indentCount
+     */
+    private addTSDocCommentLines(lines: string[], indentCount = 0): string[] {
+        const def: string[] = []
+        const indent = generateIndent(indentCount)
+        def.push(`${indent}/**`)
+        for (const line of lines) {
+            def.push(`${indent} * ${line}`)
+        }
+        def.push(`${indent} */`)
+        return def
+    }
+
+    /**
+     * Adds the documentation as comments
+     * @see https://github.com/microsoft/tsdoc
+     * @param girDoc
+     * @param indentCount
+     * @param overwriteDoc
+     * @returns
+     */
+    private addGirDocComment(tsDoc: TsDoc | undefined, indentCount = 0, overwriteDoc?: Partial<TsDoc>) {
+        const desc: string[] = []
+        const indent = generateIndent(indentCount)
+        if (this.config.noComments) {
+            return desc
+        }
+
+        const text = overwriteDoc?.text || tsDoc?.text
+        const tags = overwriteDoc?.tags || tsDoc?.tags || []
+
+        if (text) {
+            desc.push(`${indent}/**`)
+
+            if (text) {
+                const lines = text.split('\n')
+                if (lines.length) {
+                    for (const line of lines) {
+                        desc.push(`${indent} * ${line}`)
+                    }
+                }
+            }
+
+            for (const tag of tags) {
+                if (tag.paramName) {
+                    desc.push(`${indent} * @${tag.tagName} ${tag.paramName} ${tag.text}`)
+                } else {
+                    desc.push(`${indent} * @${tag.tagName} ${tag.text}`)
+                }
+            }
+            desc.push(`${indent} */`)
+        }
+        return desc
+    }
+
+    /**
+     * Adds an info comment, is used for debugging the generated types
+     * @param comment
+     * @param indentCount
+     * @returns
+     */
+    private addInfoComment(comment?: string, indentCount = 0) {
+        const def: string[] = []
+        if (this.config.noDebugComments) {
+            return def
+        }
+        const indent = generateIndent(indentCount)
+        if (comment) {
+            def.push('')
+            def.push(`${indent}// ${comment}`)
+            def.push('')
+        }
+        return def
+    }
+
+    /**
+     * Adds an inline info comment, is used for debugging the generated types
+     * @param comment
+     * @param indentCount
+     * @returns
+     */
+    private addInlineInfoComment(comment?: string, indentCount = 0) {
+        const def: string[] = []
+        if (this.config.noDebugComments) {
+            return def
+        }
+        const indent = generateIndent(indentCount)
+        if (comment) {
+            def.push(`${indent}/* ${comment} */`)
+        }
+        return def
+    }
+
+    private mergeDescs(descs: string[], comment?: string, indentCount = 1) {
+        const def: string[] = []
+        const indent = generateIndent(indentCount)
+
+        for (const desc of descs) {
+            def.push(`${indent}${desc}`)
+        }
+
+        if (def.length > 0) {
+            def.unshift(...this.addInfoComment(comment, indentCount))
+        }
+
+        return def
+    }
+
+    private generateParameter(tsParam: TsParameter, namespace: string) {
+        if (typeof tsParam?.name !== 'string') {
+            throw new Error(NO_TSDATA('generateParameter'))
+        }
+
+        const types = tsParam.type
+        const name = tsParam.name
+        const typeStr = this.generateTypes(types, namespace)
+        const optional = typeIsOptional(types) && !tsParam.isRest
+        const affix = optional ? '?' : ''
+        const prefix = tsParam.isRest ? '...' : ''
+
+        return [`${prefix}${name}${affix}: ${typeStr}`]
+    }
+
+    /**
+     *
+     * @param tsGenerics
+     * @param isOut If this generic parameters are out do only generate the type parameter names
+     * @returns
+     */
+    private generateGenericParameters(tsGenerics?: TsGenericParameter[], isOut = false) {
+        const desc: string[] = []
+        if (!tsGenerics?.length) {
+            return ''
+        }
+
+        for (const tsGeneric of tsGenerics) {
+            if (!tsGeneric.name) {
+                continue
+            }
+            let genericStr = `${tsGeneric.name}`
+            if (!isOut && tsGeneric.extends) {
+                genericStr += ` extends ${tsGeneric.extends}`
+            }
+            if (!isOut && tsGeneric.value) {
+                genericStr += ` = ${tsGeneric.value}`
+            }
+            desc.push(genericStr)
+        }
+
+        return `<${desc.join(', ')}>`
+    }
+
+    private generateOutParameterReturn(girParam: GirCallableParamElement, namespace: string) {
+        const desc: string[] = []
+
+        if (!girParam._tsData) {
+            this.log.warn(NO_TSDATA('generateOutParameterReturn'))
+            return desc
+        }
+
+        const { name } = girParam._tsData
+        const typeStr = this.generateTypes(girParam._tsData.type, namespace)
+
+        desc.push(`/* ${name} */ ${typeStr}`)
+        return desc
+    }
+
+    private generateFunctionReturn(tsFunction: TsFunction | TsCallback | TsSignal, namespace: string) {
+        if (tsFunction.name === 'constructor') {
+            return ''
+        }
+
+        const overrideReturnType = tsFunction.overrideReturnType
+        const outParams = tsFunction.outParams
+        const retTypeIsVoid = tsFunction.retTypeIsVoid
+        const isPromise = tsFunction.isPromise || false
+        const typeStr = this.generateTypes(tsFunction.returnTypes, namespace)
+
+        let desc = typeStr
+
+        if (overrideReturnType) {
+            desc = removeNamespace(overrideReturnType, namespace)
+        }
+        // TODO: Transform the outParams to `tsFunction.returnTypes` to move this logic to `gir-module.ts`
+        else if (outParams.length + (retTypeIsVoid ? 0 : 1) > 1) {
+            const outParamsDesc: string[] = []
+
+            if (!retTypeIsVoid) {
+                outParamsDesc.push(`/* returnType */ ${typeStr}`)
+            }
+
+            for (const outParam of outParams) {
+                outParamsDesc.push(...this.generateOutParameterReturn(outParam, namespace))
+            }
+
+            desc = outParamsDesc.join(', ')
+            desc = `[ ${desc} ]`
+        } else if (outParams.length === 1 && retTypeIsVoid) {
+            desc = this.generateOutParameterReturn(outParams[0], namespace).join(' ')
+        }
+
+        if (isPromise) {
+            desc = `globalThis.Promise<${desc}>`
+        }
+
+        return desc
+    }
+
+    private generateFunction(
+        tsFunction: TsFunction | TsCallback | TsSignal | undefined,
+        /** If true only generate static functions otherwise generate only non static functions */
+        onlyStatic: boolean,
+        namespace: string,
+        indentCount = 1,
+        overloads = true,
+    ) {
+        const def: string[] = []
+        const indent = generateIndent(indentCount)
+
+        if (!tsFunction) {
+            this.log.warn(NO_TSDATA('generateFunction'))
+            return def
+        }
+
+        let { name } = tsFunction
+        const { isStatic } = tsFunction
+
+        const { isArrowType, isGlobal, inParams, instanceParameters } = tsFunction
+
+        if ((isStatic && !onlyStatic) || (!isStatic && onlyStatic)) {
+            return def
+        }
+
+        if (tsFunction.doc && !tsFunction.hasUnresolvedConflict)
+            def.push(...this.addGirDocComment(tsFunction.doc, indentCount))
+
+        const staticStr = isStatic && tsFunction.name !== 'constructor' ? 'static ' : ''
+
+        const globalStr = isGlobal ? 'function ' : ''
+        const genericStr = this.generateGenericParameters(tsFunction.generics)
+
+        // temporary solution, will be solved differently later
+        const commentOut = tsFunction.hasUnresolvedConflict ? '// Has conflict: ' : ''
+
+        let exportStr = ''
+        // `tsType === 'function'` are a global methods which can be exported
+        if (isGlobal) {
+            exportStr = !this.config.noNamespace || this.config.buildType === 'types' ? '' : 'export '
+        }
+
+        const returnType = this.generateFunctionReturn(tsFunction, namespace)
+
+        let retSep = ''
+        if (returnType) {
+            if (isArrowType) {
+                name = ''
+                retSep = ' =>'
+            } else {
+                retSep = ':'
+            }
+        }
+
+        const inParamsDef: string[] = this.generateInParameters(inParams, instanceParameters, namespace)
+
+        def.push(
+            `${indent}${commentOut}${exportStr}${staticStr}${globalStr}${name}${genericStr}(${inParamsDef.join(
+                ', ',
+            )})${retSep} ${returnType}`,
+        )
+
+        // Add overloaded methods
+        if (overloads && tsFunction.overloads.length > 0) {
+            def.push(...this.addInfoComment(`Overloads of ${name}`, indentCount))
+            for (const func of tsFunction.overloads) {
+                def.push(...this.generateFunction(func, onlyStatic, namespace, indentCount, false))
+            }
+        }
+
+        return def
+    }
+
+    private generateFunctions(
+        tsFunctions: TsFunction[],
+        onlyStatic: boolean,
+        namespace: string,
+        indentCount = 1,
+        comment?: string,
+    ) {
+        const def: string[] = []
+
+        for (const girFunction of tsFunctions) {
+            def.push(...this.generateFunction(girFunction, onlyStatic, namespace, indentCount))
+        }
+
+        if (def.length > 0) {
+            def.unshift(...this.addInfoComment(comment, indentCount))
+        }
+
+        return def
+    }
+
+    private generateCallbackInterface(
+        tsCallback: TsCallback | TsSignal,
+        namespace: string,
+        indentCount = 0,
+        classModuleName?: string,
+    ) {
+        const def: string[] = []
+
+        if (!tsCallback?.tsCallbackInterface) {
+            this.log.warn(NO_TSDATA('generateCallbackInterface'))
+            return def
+        }
+
+        def.push(...this.addGirDocComment(tsCallback.doc, indentCount, tsCallback.tsCallbackInterface.overwriteDoc))
+
+        const indent = generateIndent(indentCount)
+        const indentBody = generateIndent(indentCount + 1)
+        const { inParams, instanceParameters } = tsCallback
+        const returnTypeStr = this.generateTypes(tsCallback.returnTypes, namespace)
+
+        // Get name, remove namespace and remove module class name prefix
+        let { name } = tsCallback.tsCallbackInterface
+        const { generics } = tsCallback.tsCallbackInterface
+        name = removeNamespace(name, namespace)
+        if (classModuleName) name = removeClassModule(name, classModuleName)
+        const genericParameters = this.generateGenericParameters(generics)
+
+        const inParamsDef: string[] = this.generateInParameters(inParams, instanceParameters, namespace)
+
+        const interfaceHead = `${name}${genericParameters}`
+
+        def.push(this.generateExport('interface', `${interfaceHead}`, '{', indentCount))
+        def.push(`${indentBody}(${inParamsDef.join(', ')}): ${returnTypeStr}`)
+        def.push(indent + '}')
+
+        return def
+    }
+
+    private generateCallbackInterfaces(
+        tsCallbacks: Array<TsCallback | TsSignal>,
+        namespace: string,
+        indentCount = 0,
+        classModuleName: string,
+        comment?: string,
+    ) {
+        const def: string[] = []
+
+        for (const tsCallback of tsCallbacks) {
+            def.push(...this.generateCallbackInterface(tsCallback, namespace, indentCount, classModuleName), '')
+        }
+
+        if (def.length > 0) {
+            def.unshift(...this.addInfoComment(comment, indentCount))
+        }
+
+        return def
+    }
+
+    private generateEnumeration(girEnum: GirEnumElement | GirBitfieldElement, indentCount = 0) {
+        const desc: string[] = []
+
+        if (!girElementIsIntrospectable(girEnum)) {
+            return desc
+        }
+
+        if (!girEnum._tsData) {
+            this.log.warn(NO_TSDATA('generateEnumeration'))
+            return desc
+        }
+
+        desc.push(...this.addGirDocComment(girEnum._tsData.doc, indentCount))
+
+        const { name } = girEnum._tsData
+        desc.push(this.generateExport('enum', name, '{', indentCount))
+        if (girEnum.member) {
+            for (const girEnumMember of girEnum.member) {
+                if (!girEnumMember._tsData) continue
+                desc.push(...this.generateEnumerationMember(girEnumMember._tsData, indentCount + 1))
+            }
+        }
+        desc.push('}')
+        return desc
+    }
+
+    private generateEnumerationMember(tsMember: TsMember, indentCount = 1) {
+        const desc: string[] = []
+
+        if (!tsMember) {
+            this.log.warn(NO_TSDATA('generateEnumerationMember'))
+            return desc
+        }
+
+        desc.push(...this.addGirDocComment(tsMember.doc, indentCount))
+
+        const indent = generateIndent(indentCount)
+        desc.push(`${indent}${tsMember.name},`)
+        return desc
+    }
+
+    private generateConstant(tsConst: TsVar, namespace: string, indentCount = 0) {
+        const desc: string[] = []
+
+        if (!tsConst.hasUnresolvedConflict) {
+            desc.push(...this.addGirDocComment(tsConst.doc, indentCount))
+        }
+
+        const indent = generateIndent(indentCount)
+        const exp = !this.config.noNamespace || this.config.buildType === 'types' ? '' : 'export '
+        const varDesc = this.generateVariable(tsConst, namespace, 0)
+        desc.push(`${indent}${exp}const ${varDesc}`)
+        return desc
+    }
+
+    private generateAlias(girAlias: GirAliasElement, namespace: string, indentCount = 0) {
+        const desc: string[] = []
+
+        if (!girElementIsIntrospectable(girAlias)) {
+            return ''
+        }
+
+        if (!girAlias._tsData) {
+            this.log.warn(NO_TSDATA('generateAlias'))
+            return desc
+        }
+        const indent = generateIndent(indentCount)
+
+        const exp = !this.config.noNamespace || this.config.buildType === 'types' ? '' : 'export '
+        const type = removeNamespace(girAlias._tsData.type, namespace)
+
+        desc.push(`${indent}${exp}type ${girAlias._tsData.name} = ${type}`)
+        return desc
+    }
+
+    private generateConstructPropsInterface(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        namespace: string,
+        indentCount = 0,
+    ) {
+        const def: string[] = []
+
+        if (!girClass._tsData || !girClass._fullSymName || !girClass._module) {
+            throw new Error(NO_TSDATA('generateConstructPropsInterface'))
+        }
+
+        if (!girClass._tsData.isDerivedFromGObject) {
+            return def
+        }
+
+        const indent = generateIndent(indentCount)
+        const exp = !this.config.noNamespace || this.config.buildType === 'types' ? '' : 'export '
+        let ext = ''
+
+        if (girClass._tsData.inheritConstructPropInterfaceNames.length) {
+            const constructPropInterfaceNames = girClass._tsData.inheritConstructPropInterfaceNames.map((n) =>
+                removeNamespace(n, namespace),
+            )
+            ext = `extends ${constructPropInterfaceNames.join(', ')} `
+        }
+
+        // Remove namespace and class module name
+        const constructPropInterfaceName = removeClassModule(
+            removeNamespace(girClass._tsData.constructPropInterfaceName, namespace),
+            girClass._tsData.name,
+        )
+
+        def.push(...this.addInfoComment('Constructor properties interface', indentCount))
+
+        // START BODY
+        {
+            def.push(`${indent}${exp}interface ${constructPropInterfaceName} ${ext}{`)
+            def.push(
+                ...this.generateProperties(
+                    girClass._tsData.constructProps.map((cp) => cp._tsData).filter((cp) => !!cp) as TsProperty[],
+                    false,
+                    namespace,
+                    `Own constructor properties of ${girClass._module.packageName}.${girClass._fullSymName}`,
+                    indentCount + 1,
+                ),
+            )
+            def.push(`${indent}}`, '')
+        }
+        // END BODY
+
+        return def
+    }
+
+    private generateClassFields(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        onlyStatic: boolean,
+        namespace: string,
+        indentCount = 1,
+    ) {
+        const def: string[] = []
+        if (!girClass._tsData || !girClass._fullSymName || !girClass._module) {
+            throw new Error(NO_TSDATA('generateClassFields'))
+        }
+
+        def.push(
+            ...this.generateProperties(
+                girClass._tsData.fields.map((f) => f._tsData).filter((f) => !!f) as TsProperty[],
+                onlyStatic,
+                namespace,
+                `Own fields of ${girClass._module.packageName}.${girClass._fullSymName}`,
+                indentCount,
+            ),
+        )
+
+        return def
+    }
+
+    private generateClassProperties(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        onlyStatic: boolean,
+        namespace: string,
+        indentCount = 1,
+    ) {
+        const def: string[] = []
+
+        if (!girClass._tsData || !girClass._fullSymName || !girClass._module) {
+            throw new Error(NO_TSDATA('generateClassProperties'))
+        }
+
+        def.push(
+            ...this.generateProperties(
+                girClass._tsData.properties.map((p) => p._tsData).filter((p) => !!p) as TsProperty[],
+                onlyStatic,
+                namespace,
+                `Own properties of ${girClass._module.packageName}.${girClass._fullSymName}`,
+                indentCount,
+            ),
+        )
+
+        def.push(
+            ...this.generateProperties(
+                girClass._tsData.conflictProperties,
+                onlyStatic,
+                namespace,
+                `Conflicting properties`,
+                indentCount,
+            ),
+        )
+
+        return def
+    }
+
+    private generateClassMethods(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        onlyStatic: boolean,
+        namespace: string,
+        indentCount = 1,
+    ) {
+        const def: string[] = []
+        if (!girClass._tsData || !girClass._fullSymName || !girClass._module) {
+            throw new Error(NO_TSDATA('generateClassMethods'))
+        }
+
+        def.push(
+            ...this.generateFunctions(
+                girClass._tsData.methods.map((girFunc) => girFunc._tsData).filter((tsFunc) => !!tsFunc) as TsFunction[],
+                onlyStatic,
+                namespace,
+                indentCount,
+                `Owm ${onlyStatic ? 'static ' : ''}methods of ${girClass._module.packageName}.${girClass._fullSymName}`,
+            ),
+        )
+
+        def.push(
+            ...this.generateFunctions(
+                girClass._tsData.conflictMethods,
+                onlyStatic,
+                namespace,
+                indentCount,
+                `Conflicting ${onlyStatic ? 'static ' : ''}methods`,
+            ),
+        )
+
+        return def
+    }
+
+    private generateClassConstructors(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        namespace: string,
+        indentCount = 1,
+    ) {
+        const def: string[] = []
+        if (!girClass._tsData || !girClass._fullSymName || !girClass._module) {
+            throw new Error(NO_TSDATA('generateClassConstructors'))
+        }
+
+        // Constructors
+        def.push(
+            ...this.generateFunctions(
+                girClass._tsData.constructors
+                    .map((girFunc) => girFunc._tsData)
+                    .filter((tsFunc) => !!tsFunc) as TsFunction[],
+                true,
+                namespace,
+                indentCount,
+            ),
+        )
+        // _init method
+        def.push(
+            ...this.generateFunctions(
+                girClass._tsData.constructors
+                    .map((girFunc) => girFunc._tsData)
+                    .filter((tsFunc) => !!tsFunc) as TsFunction[],
+                false,
+                namespace,
+                indentCount,
+            ),
+        )
+        // Pseudo constructors
+        def.push(
+            ...this.generateFunctions(
+                girClass._tsData.staticFunctions
+                    .map((girFunc) => girFunc._tsData)
+                    .filter((tsFunc) => !!tsFunc) as TsFunction[],
+                true,
+                namespace,
+                indentCount,
+            ),
+        )
+
+        if (def.length) {
+            def.unshift(
+                ...this.addInfoComment(
+                    `Constructors of ${girClass._module.packageName}.${girClass._fullSymName}`,
+                    indentCount,
+                ),
+            )
+        }
+
+        return def
+    }
+
+    /**
+     * Instance methods, vfunc_ prefix
+     * @param girClass
+     */
+    private generateClassVirtualMethods(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        namespace: string,
+        indentCount = 1,
+    ) {
+        const def: string[] = []
+        if (!girClass._tsData || !girClass._fullSymName || !girClass._module) {
+            throw new Error(NO_TSDATA('generateClassVirtualMethods'))
+        }
+
+        def.push(
+            ...this.generateFunctions(
+                girClass._tsData.virtualMethods
+                    .map((girFunc) => girFunc._tsData)
+                    .filter((tsFunc) => !!tsFunc) as TsFunction[],
+                false,
+                namespace,
+                indentCount,
+                `Own virtual methods of ${girClass._module.packageName}.${girClass._fullSymName}`,
+            ),
+        )
+
+        return def
+    }
+
+    private generateClassSignalInterfaces(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        namespace: string,
+        indentCount = 0,
+    ) {
+        const def: string[] = []
+        if (!girClass._tsData) {
+            throw new Error(NO_TSDATA('generateClassSignalInterface'))
+        }
+
+        const tsSignals = girClass._tsData.signals
+            .map((signal) => signal._tsData)
+            .filter((signal) => !!signal) as TsSignal[]
+
+        def.push(
+            ...this.generateCallbackInterfaces(
+                tsSignals,
+                namespace,
+                indentCount,
+                girClass._tsData.name,
+                'Signal callback interfaces',
+            ),
+        )
+
+        return def
+    }
+
+    private generateClassSignals(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        namespace: string,
+    ) {
+        const def: string[] = []
+        if (!girClass._tsData || !girClass._fullSymName || !girClass._module) {
+            throw new Error(NO_TSDATA('generateClassSignals'))
+        }
+
+        const signalDescs = this.generateSignals(girClass._tsData.signals, girClass, namespace, 0)
+
+        def.push(
+            ...this.mergeDescs(
+                signalDescs,
+                `Own signals of ${girClass._module.packageName}.${girClass._fullSymName}`,
+                1,
+            ),
+        )
+
+        return def
+    }
+
+    private generateClassModules(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        namespace: string,
+        indentCount = 0,
+    ) {
+        const def: string[] = []
+        const bodyDef: string[] = []
+        if (!girClass._tsData) return def
+        const indent = generateIndent(indentCount)
+
+        const exp = !this.config.noNamespace || this.config.buildType === 'types' ? '' : 'export '
+
+        // Signal interfaces
+        bodyDef.push(...this.generateClassSignalInterfaces(girClass, namespace, indentCount + 1))
+
+        // Properties interface for construction
+        bodyDef.push(...this.generateConstructPropsInterface(girClass, namespace, indentCount + 1))
+
+        if (!bodyDef.length) {
+            return []
+        }
+
+        // START BODY
+        {
+            def.push(`${indent}${exp}module ${girClass._tsData.name} {`)
+
+            // Properties interface for construction
+            def.push(...bodyDef)
+
+            def.push(`${indent}}`, '')
+        }
+        // END BODY
+
+        return def
+    }
+
+    /**
+     * In Typescript, interfaces and classes can have the same name,
+     * so we use this to generate interfaces with the same name to implement multiple inheritance
+     * @param girClass
+     * @param namespace
+     */
+    private generateImplementationInterface(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        namespace: string,
+    ) {
+        const def: string[] = []
+
+        if (!girClass._tsData) return def
+
+        const genericParameters = this.generateGenericParameters(girClass._tsData.generics)
+        const implementationNames = girClass._tsData.parents
+            .filter((implementation) => implementation.type !== 'parent')
+            .map((implementation) => implementation.localParentName)
+        const ext = implementationNames.length ? ` extends ${implementationNames.join(', ')}` : ''
+        const interfaceHead = `${girClass._tsData.name}${genericParameters}${ext}`
+
+        // START INTERFACE
+        {
+            def.push(this.generateExport('interface', interfaceHead, '{'))
+
+            // START BODY
+            {
+                // Properties
+                def.push(...this.generateClassProperties(girClass, false, namespace))
+
+                // Fields
+                def.push(...this.generateClassFields(girClass, false, namespace))
+
+                // Methods
+                def.push(...this.generateClassMethods(girClass, false, namespace))
+
+                // Virtual methods
+                def.push(...this.generateClassVirtualMethods(girClass, namespace))
+
+                // Signals
+                def.push(...this.generateClassSignals(girClass, namespace))
+
+                // TODO: Generate `GirSignalElement`s instead of generate the signal definition strings directly
+                def.push(...this.generateClassPropertySignals(girClass, namespace))
+            }
+            // END BODY
+
+            // END INTERFACE
+            def.push('}')
+            def.push('')
+        }
+
+        return def
+    }
+
+    /**
+     * Represents a record, GObject class or interface as a Typescript class
+     * @param girClass
+     * @param namespace
+     */
+    private generateClass(
+        girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement,
+        namespace: string,
+    ) {
+        const def: string[] = []
+
+        if (!girClass._tsData) return def
+
+        def.push(...this.generateClassModules(girClass, namespace))
+
+        def.push(...this.generateImplementationInterface(girClass, namespace))
+
+        def.push(...this.addGirDocComment(girClass._tsData.doc, 0))
+
+        const genericParameters = this.generateGenericParameters(girClass._tsData.generics)
+        const parentName = girClass._tsData.parents.find((parent) => parent.type === 'parent')?.localParentName
+        const ext = parentName ? ` extends ${parentName}` : ''
+        const classHead = `${girClass._tsData.name}${genericParameters}${ext}`
+
+        // START CLASS
+        {
+            if (girClass._tsData.isAbstract) {
+                def.push(this.generateExport('abstract class', classHead, '{'))
+            } else {
+                def.push(this.generateExport('class', classHead, '{'))
+            }
+
+            // START BODY
+            {
+                // Static Properties
+                def.push(...this.generateClassProperties(girClass, true, namespace))
+
+                // Static Fields
+                def.push(...this.generateClassFields(girClass, true, namespace))
+
+                // Constructors
+                def.push(...this.generateClassConstructors(girClass, namespace))
+
+                // Static Methods
+                def.push(...this.generateClassMethods(girClass, true, namespace))
+            }
+            // END BODY
+
+            // END CLASS
+            def.push('}')
+            def.push('')
+        }
+
+        return def
+    }
+
+    private async exportModuleJS(moduleTemplateProcessor: TemplateProcessor, girModule: GirModule): Promise<void> {
+        const template = 'module.js'
+        if (this.config.outdir) {
+            await moduleTemplateProcessor.create(template, this.config.outdir, `${girModule.packageName}.js`)
+        } else {
+            const moduleContent = moduleTemplateProcessor.load(template)
+            this.log.log(moduleContent)
+        }
+    }
+
+    private async exportModuleTS(moduleTemplateProcessor: TemplateProcessor, girModule: GirModule): Promise<void> {
+        const template = 'module.d.ts'
+        const out: string[] = []
+
+        out.push(...this.addTSDocCommentLines([girModule.packageName]))
+
+        out.push('')
+
+        // Module dependencies as type references or imports
+        if (this.config.environment === 'gjs') {
+            out.push(...this.generateModuleDependenciesImport('Gjs', 'Gjs', false))
+        }
+
+        for (const dependency of girModule.transitiveDependencies) {
+            // Don't reference yourself as a dependency
+            if (girModule.packageName !== dependency.packageName) {
+                if (dependency.exists) {
+                    out.push(
+                        ...this.generateModuleDependenciesImport(dependency.namespace, dependency.packageName, false),
+                    )
+                } else {
+                    out.push(`// WARN: Dependency not found: '${dependency.packageName}'`)
+                    this.log.warn(WARN_NOT_FOUND_DEPENDENCY_GIR_FILE(dependency.filename))
+                }
+            }
+        }
+
+        // START Namespace
+        {
+            if (this.config.buildType === 'types') {
+                out.push('')
+                out.push(`declare namespace ${girModule.namespace} {`)
+            } else if (!this.config.noNamespace) {
+                out.push('')
+                out.push(`export namespace ${girModule.namespace} {`)
+            }
+
+            // Newline
+            out.push('')
+
+            if (girModule.ns.enumeration)
+                for (const girEnum of girModule.ns.enumeration) out.push(...this.generateEnumeration(girEnum))
+
+            if (girModule.ns.bitfield)
+                for (const girBitfield of girModule.ns.bitfield) out.push(...this.generateEnumeration(girBitfield))
+
+            if (girModule.ns.constant)
+                for (const girConst of girModule.ns.constant) {
+                    if (!girConst._tsData) continue
+                    out.push(...this.generateConstant(girConst._tsData, girModule.namespace, 0))
+                }
+
+            if (girModule.ns.function)
+                for (const girFunc of girModule.ns.function) {
+                    if (!girFunc._tsData) {
+                        // this.log.warn(NO_TSDATA('exportModuleTS functions'))
+                        continue
+                    }
+                    out.push(...this.generateFunction(girFunc._tsData, false, girModule.namespace, 0))
+                }
+
+            if (girModule.ns.callback)
+                for (const girCallback of girModule.ns.callback) {
+                    if (!girCallback._tsData) continue
+                    out.push(...this.generateCallbackInterface(girCallback._tsData, girModule.namespace))
+                }
+
+            if (girModule.ns.interface)
+                for (const girIface of girModule.ns.interface)
+                    if (girIface._module) {
+                        out.push(...this.generateClass(girIface, girIface._module.namespace))
+                    }
+
+            // Extra interfaces if a template with the module name  (e.g. '../templates/GObject-2.0.d.ts') is found
+            // E.g. used for GObject-2.0 to help define GObject classes in js;
+            // these aren't part of gi.
+            if (moduleTemplateProcessor.exists(`${girModule.packageName}.d.ts`)) {
+                const templatePatches = await moduleTemplateProcessor.load(`${girModule.packageName}.d.ts`)
+                out.push(templatePatches)
+            }
+
+            if (girModule.ns.class)
+                for (const gitClass of girModule.ns.class)
+                    if (gitClass._module) {
+                        out.push(...this.generateClass(gitClass, gitClass._module.namespace))
+                    }
+
+            if (girModule.ns.record)
+                for (const girRecord of girModule.ns.record)
+                    if (girRecord._module) {
+                        out.push(...this.generateClass(girRecord, girRecord._module.namespace))
+                    }
+
+            if (girModule.ns.union)
+                for (const girUnion of girModule.ns.union)
+                    if (girUnion._module) {
+                        out.push(...this.generateClass(girUnion, girUnion._module.namespace))
+                    }
+
+            if (girModule.ns.alias)
+                // GType is not a number in GJS
+                for (const girAlias of girModule.ns.alias)
+                    if (girModule.packageName !== 'GObject-2.0' || girAlias.$.name !== 'Type')
+                        out.push(...this.generateAlias(girAlias, girModule.namespace, 1))
+
+            if (this.config.environment === 'gjs') {
+                // Properties added to every GIRepositoryNamespace
+                // https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L186-190
+                out.push(
+                    ...this.generateConstant(
+                        {
+                            doc: {
+                                text: 'Name of the imported GIR library',
+                                tags: [
+                                    {
+                                        text: 'https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188',
+                                        tagName: 'see',
+                                        paramName: '',
+                                    },
+                                ],
+                            },
+                            name: '__name__',
+                            type: [
+                                {
+                                    type: 'string',
+                                    optional: false,
+                                    nullable: false,
+                                    callbacks: [],
+                                    generics: [],
+                                    isArray: false,
+                                    isFunction: false,
+                                    isCallback: false,
+                                },
+                            ],
+                            isInjected: false,
+                            tsTypeName: 'constant',
+                            girTypeName: 'constant',
+                        },
+                        girModule.namespace,
+                        0,
+                    ),
+                    ...this.generateConstant(
+                        {
+                            doc: {
+                                text: 'Version of the imported GIR library',
+                                tags: [
+                                    {
+                                        text: 'https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189',
+                                        tagName: 'see',
+                                        paramName: '',
+                                    },
+                                ],
+                            },
+                            name: '__version__',
+                            type: [
+                                {
+                                    type: 'string',
+                                    optional: false,
+                                    nullable: false,
+                                    callbacks: [],
+                                    generics: [],
+                                    isArray: false,
+                                    isFunction: false,
+                                    isCallback: false,
+                                },
+                            ],
+                            isInjected: false,
+                            tsTypeName: 'constant',
+                            girTypeName: 'constant',
+                        },
+                        girModule.namespace,
+                        0,
+                    ),
+                )
+            }
+        }
+        // END Namespace
+        if (!this.config.noNamespace) {
+            out.push(`}`)
+        }
+
+        if (!this.config.noNamespace) {
+            out.push(`export default ${girModule.namespace};`)
+        }
+
+        const outResult = out.join('\n') // End of file
+
+        if (this.config.outdir) {
+            await moduleTemplateProcessor.create(
+                template,
+                this.config.outdir,
+                `${girModule.packageName}.d.ts`,
+                outResult,
+            )
+        } else {
+            const moduleContent = await moduleTemplateProcessor.load(template)
+            this.log.log(moduleContent + '\n' + outResult)
+        }
+    }
+
+    private async exportModule(girModule: GirModule) {
+        const moduleTemplateProcessor = new TemplateProcessor(
+            {
+                name: girModule.namespace,
+                namespace: girModule.namespace,
+                version: girModule.version,
+                importName: girModule.importName,
+            },
+            girModule.packageName,
+            this.config,
+        )
+
+        await this.exportModuleTS(moduleTemplateProcessor, girModule)
+
+        if (this.config.buildType === 'lib') {
+            await this.exportModuleJS(moduleTemplateProcessor, girModule)
+        }
+    }
+
+    private async exportGjs(girModules: GirModule[], girModulesGrouped: GirModulesGrouped[]) {
+        if (!this.config.outdir) return
+
+        const templateProcessor = new TemplateProcessor(
+            { girModules: girModules, girModulesGrouped, typeDir: this.config.outdir + '/Gjs' },
+            'gjs',
+            this.config,
+        )
+
+        // Types
+        await templateProcessor.create('Gjs.d.ts', this.config.outdir, 'Gjs.d.ts')
+        await templateProcessor.create('index.d.ts', this.config.outdir, 'index.d.ts')
+        if (this.config.gnomeShellTypes) {
+            await templateProcessor.create('GnomeShell.d.ts', this.config.outdir, 'GnomeShell.d.ts')
+            await templateProcessor.createAll('.d.ts', 'misc', this.config.outdir, 'misc')
+            await templateProcessor.createAll('.d.ts', 'ui', this.config.outdir, 'ui')
+            await templateProcessor.createAll('.d.ts', 'ui/components', this.config.outdir, 'ui/components')
+        }
+
+        // Lib
+        if (this.config.buildType === 'lib') {
+            await templateProcessor.create('Gjs.js', this.config.outdir, 'Gjs.js')
+            await templateProcessor.create('index.js', this.config.outdir, 'index.js')
+            if (this.config.gnomeShellTypes) {
+                await templateProcessor.create('GnomeShell.js', this.config.outdir, 'GnomeShell.js')
+                await templateProcessor.createAll('.js', 'misc', this.config.outdir, 'misc')
+                await templateProcessor.createAll('.js', 'ui', this.config.outdir, 'ui')
+                await templateProcessor.createAll('.js', 'ui/components', this.config.outdir, 'ui/components')
+            }
+        }
+
+        // Alias
+        if (this.config.generateAlias) {
+            await templateProcessor.create('tsconfig.alias.json', './', 'tsconfig.alias.json', '', false)
+        }
+    }
+
+    private async exportNodeGtk(girModules: GirModule[], girModulesGrouped: GirModulesGrouped[]) {
+        if (!this.config.outdir) return
+
+        const templateProcessor = new TemplateProcessor({ girModules, girModulesGrouped }, 'node', this.config)
+
+        await templateProcessor.create('index.d.ts', this.config.outdir, 'index.d.ts')
+        if (this.config.buildType === 'lib') {
+            await templateProcessor.create('index.js', this.config.outdir, 'index.js')
+        }
+    }
+
+    public async start(
+        girModules: GirModule[],
+        girModulesGrouped?: GirModulesGrouped[],
+        inheritanceTable?: InheritanceTable,
+    ) {
+        for (const girModule of girModules) {
+            await this.exportModule(girModule)
+        }
+
+        if (this.config.environment === 'node' && girModulesGrouped) {
+            // node-gtk internal stuff
+            await this.exportNodeGtk(girModules, girModulesGrouped)
+        }
+
+        if (this.config.environment === 'gjs' && girModulesGrouped && inheritanceTable) {
+            // GJS internal stuff
+            await this.exportGjs(girModules, girModulesGrouped)
+        }
+    }
+}