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

package/lib/type-definition-generator.js

@@ -1,996 +0,0 @@
-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 {
-    config;
-    log;
-    constructor(config) {
-        this.config = config;
-        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
-     */
-    generateModuleDependenciesImport(namespace, packageName, asExternType = false) {
-        const def = [];
-        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;
-    }
-    generateExport(type, name, definition, 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}`;
-    }
-    generateProperty(tsProp, onlyStatic, namespace, indentCount = 0) {
-        if (!tsProp) {
-            throw new Error('[generateProperty] Not all required properties set!');
-        }
-        const desc = [];
-        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;
-    }
-    generateProperties(tsProps, onlyStatic, namespace, comment, indentCount = 0) {
-        const def = [];
-        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;
-    }
-    generateVariableCallbackType(tsType, namespace) {
-        // 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;
-    }
-    generateVariable(tsVar, namespace, 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}`;
-    }
-    generateTypes(tsTypes, namespace) {
-        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;
-    }
-    generateGenericValues(tsType, namespace) {
-        // 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;
-    }
-    generateType(tsType, namespace) {
-        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
-     */
-    generateClassPropertySignals(girClass, namespace, indentCount = 1) {
-        const def = [];
-        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;
-    }
-    generateInParameters(inParams, instanceParameters, namespace) {
-        const inParamsDef = [];
-        // 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;
-    }
-    generateSignals(girSignals, girClass, namespace, indentCount = 0) {
-        const def = [];
-        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
-     */
-    addTSDocCommentLines(lines, indentCount = 0) {
-        const def = [];
-        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
-     */
-    addGirDocComment(tsDoc, indentCount = 0, overwriteDoc) {
-        const desc = [];
-        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
-     */
-    addInfoComment(comment, indentCount = 0) {
-        const def = [];
-        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
-     */
-    addInlineInfoComment(comment, indentCount = 0) {
-        const def = [];
-        if (this.config.noDebugComments) {
-            return def;
-        }
-        const indent = generateIndent(indentCount);
-        if (comment) {
-            def.push(`${indent}/* ${comment} */`);
-        }
-        return def;
-    }
-    mergeDescs(descs, comment, indentCount = 1) {
-        const def = [];
-        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;
-    }
-    generateParameter(tsParam, namespace) {
-        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
-     */
-    generateGenericParameters(tsGenerics, isOut = false) {
-        const desc = [];
-        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(', ')}>`;
-    }
-    generateOutParameterReturn(girParam, namespace) {
-        const desc = [];
-        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;
-    }
-    generateFunctionReturn(tsFunction, namespace) {
-        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 = [];
-            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;
-    }
-    generateFunction(tsFunction, 
-    /** If true only generate static functions otherwise generate only non static functions */
-    onlyStatic, namespace, indentCount = 1, overloads = true) {
-        const def = [];
-        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 = 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;
-    }
-    generateFunctions(tsFunctions, onlyStatic, namespace, indentCount = 1, comment) {
-        const def = [];
-        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;
-    }
-    generateCallbackInterface(tsCallback, namespace, indentCount = 0, classModuleName) {
-        const def = [];
-        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 = 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;
-    }
-    generateCallbackInterfaces(tsCallbacks, namespace, indentCount = 0, classModuleName, comment) {
-        const def = [];
-        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;
-    }
-    generateEnumeration(girEnum, indentCount = 0) {
-        const desc = [];
-        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;
-    }
-    generateEnumerationMember(tsMember, indentCount = 1) {
-        const desc = [];
-        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;
-    }
-    generateConstant(tsConst, namespace, indentCount = 0) {
-        const desc = [];
-        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;
-    }
-    generateAlias(girAlias, namespace, indentCount = 0) {
-        const desc = [];
-        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;
-    }
-    generateConstructPropsInterface(girClass, namespace, indentCount = 0) {
-        const def = [];
-        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), false, namespace, `Own constructor properties of ${girClass._module.packageName}.${girClass._fullSymName}`, indentCount + 1));
-            def.push(`${indent}}`, '');
-        }
-        // END BODY
-        return def;
-    }
-    generateClassFields(girClass, onlyStatic, namespace, indentCount = 1) {
-        const def = [];
-        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), onlyStatic, namespace, `Own fields of ${girClass._module.packageName}.${girClass._fullSymName}`, indentCount));
-        return def;
-    }
-    generateClassProperties(girClass, onlyStatic, namespace, indentCount = 1) {
-        const def = [];
-        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), 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;
-    }
-    generateClassMethods(girClass, onlyStatic, namespace, indentCount = 1) {
-        const def = [];
-        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), 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;
-    }
-    generateClassConstructors(girClass, namespace, indentCount = 1) {
-        const def = [];
-        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), true, namespace, indentCount));
-        // _init method
-        def.push(...this.generateFunctions(girClass._tsData.constructors
-            .map((girFunc) => girFunc._tsData)
-            .filter((tsFunc) => !!tsFunc), false, namespace, indentCount));
-        // Pseudo constructors
-        def.push(...this.generateFunctions(girClass._tsData.staticFunctions
-            .map((girFunc) => girFunc._tsData)
-            .filter((tsFunc) => !!tsFunc), 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
-     */
-    generateClassVirtualMethods(girClass, namespace, indentCount = 1) {
-        const def = [];
-        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), false, namespace, indentCount, `Own virtual methods of ${girClass._module.packageName}.${girClass._fullSymName}`));
-        return def;
-    }
-    generateClassSignalInterfaces(girClass, namespace, indentCount = 0) {
-        const def = [];
-        if (!girClass._tsData) {
-            throw new Error(NO_TSDATA('generateClassSignalInterface'));
-        }
-        const tsSignals = girClass._tsData.signals
-            .map((signal) => signal._tsData)
-            .filter((signal) => !!signal);
-        def.push(...this.generateCallbackInterfaces(tsSignals, namespace, indentCount, girClass._tsData.name, 'Signal callback interfaces'));
-        return def;
-    }
-    generateClassSignals(girClass, namespace) {
-        const def = [];
-        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;
-    }
-    generateClassModules(girClass, namespace, indentCount = 0) {
-        const def = [];
-        const bodyDef = [];
-        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
-     */
-    generateImplementationInterface(girClass, namespace) {
-        const def = [];
-        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
-     */
-    generateClass(girClass, namespace) {
-        const def = [];
-        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;
-    }
-    async exportModuleJS(moduleTemplateProcessor, girModule) {
-        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);
-        }
-    }
-    async exportModuleTS(moduleTemplateProcessor, girModule) {
-        const template = 'module.d.ts';
-        const out = [];
-        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);
-        }
-    }
-    async exportModule(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);
-        }
-    }
-    async exportGjs(girModules, 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);
-        }
-    }
-    async exportNodeGtk(girModules, 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');
-        }
-    }
-    async start(girModules, girModulesGrouped, 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);
-        }
-    }
-}
-//# sourceMappingURL=type-definition-generator.js.map