@microsoft/type2docfx 1.3.2-dev.1210049.0 → 2.0.0

package/dist/converters/base.js

@@ -1,149 +1,181 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractConverter = void 0;
-var idResolver_1 = require("../idResolver");
-var linkConvertHelper_1 = require("../helpers/linkConvertHelper");
-var AbstractConverter = /** @class */ (function () {
-    function AbstractConverter(references) {
+const idResolver_1 = require("../idResolver");
+const linkConvertHelper_1 = require("../helpers/linkConvertHelper");
+const error_1 = require("../common/error");
+class AbstractConverter {
+    constructor(references) {
         this.references = references;
     }
-    AbstractConverter.prototype.convert = function (node, context) {
-        var _this = this;
+    convert(node, context) {
         var models = this.generate(node, context) || [];
-        models.forEach(function (model, i) {
-            model.summary = linkConvertHelper_1.convertLinkToGfm(model.summary);
+        models.forEach((model, i) => {
             model.package = context.PackageName;
-            if (node.comment || (node.signatures && node.signatures.length && node.signatures[i].comment)) {
-                _this.setCustomModuleName(model, node.comment);
-                var comment = node.comment ? node.comment : node.signatures[i].comment;
-                _this.setDeprecated(model, comment);
-                _this.setPreviewState(model, comment);
-                _this.setRemarks(model, comment);
-                _this.setInherits(model, comment);
+            let signatureComment = undefined;
+            if (node.signatures && node.signatures.length) {
+                signatureComment = node.signatures[i].comment;
+            }
+            const anonymousComment = this.extractCommentForAnonymousFunction(node.type);
+            if (node.comment || signatureComment || anonymousComment) {
+                this.setCustomModuleName(model, node.comment);
+                const comment = node.comment || signatureComment || anonymousComment;
+                this.setDeprecated(model, comment);
+                this.setPreviewState(model, comment);
+                this.setRemarks(model, comment);
+                this.setInherits(model, comment);
             }
         });
         return models;
-    };
-    AbstractConverter.prototype.setDeprecated = function (model, comment) {
-        var deprecated = this.extractTextFromComment('deprecated', comment);
+    }
+    setDeprecated(model, comment) {
+        const deprecated = this.extractTextFromComment('@deprecated', comment);
         if (deprecated != null) {
             model.deprecated = {
-                content: linkConvertHelper_1.convertLinkToGfm(deprecated)
+                content: deprecated
             };
         }
-    };
-    AbstractConverter.prototype.setPreviewState = function (model, comment) {
-        if (comment && comment.tags) {
-            for (var _i = 0, _a = comment.tags; _i < _a.length; _i++) {
-                var tag = _a[_i];
-                if (tag.tag === 'alpha') {
-                    model.previewState = 'alpha';
-                    break; // select 'alpha' if both 'alpha' and 'beta' tags are present. 
-                }
-                else if (tag.tag === 'beta') {
-                    model.previewState = 'beta';
-                }
-            }
+    }
+    setPreviewState(model, comment) {
+        const existBetaTag = this.extractModifierFromComment('@beta', comment);
+        const existAlphaTag = this.extractModifierFromComment('@alpha', comment);
+        if (existBetaTag) {
+            model.previewState = 'beta';
         }
-    };
-    AbstractConverter.prototype.setRemarks = function (model, comment) {
-        var remarks = this.extractTextFromComment('remarks', comment);
+        if (existAlphaTag) {
+            model.previewState = 'alpha';
+        }
+    }
+    setRemarks(model, comment) {
+        const remarks = this.extractTextFromComment('@remarks', comment);
         if (remarks != null) {
-            model.remarks = linkConvertHelper_1.convertLinkToGfm(remarks);
+            model.remarks = remarks;
         }
-    };
-    AbstractConverter.prototype.setCustomModuleName = function (model, comment) {
-        var customModuleName = this.extractTextFromComment('module', comment);
+    }
+    setCustomModuleName(model, comment) {
+        const customModuleName = this.extractTextFromComment('@module', comment);
         if (customModuleName) {
             model.module = customModuleName;
         }
-    };
-    AbstractConverter.prototype.setInherits = function (model, comment) {
-        var inherits = this.extractTextFromComment('inherits', comment);
+    }
+    setInherits(model, comment) {
+        const inherits = this.extractTextFromComment('@inherits', comment);
         if (inherits != null) {
-            var tokens = linkConvertHelper_1.getTextAndLink(inherits);
+            const tokens = (0, linkConvertHelper_1.getTextAndLink)(inherits);
             if (tokens.length === 2) {
-                model.extends = {
-                    name: tokens[0],
-                    href: tokens[1]
-                };
+                model.extends = [{
+                        name: tokens[0],
+                        href: tokens[1]
+                    }];
             }
         }
-    };
-    AbstractConverter.prototype.extractTextFromComment = function (infoName, comment) {
-        if (comment && comment.tags) {
-            for (var _i = 0, _a = comment.tags; _i < _a.length; _i++) {
-                var tag = _a[_i];
-                if (tag.tag === infoName) {
-                    return tag.text.trim();
-                }
+    }
+    extractModifierFromComment(infoName, comment) {
+        if (comment && comment.modifierTags) {
+            if (comment.modifierTags.includes(infoName)) {
+                return true;
             }
         }
-        return null;
-    };
-    AbstractConverter.prototype.getGenericType = function (typeParameters) {
+        return false;
+    }
+    extractTextFromComment(infoName, comment) {
+        if (!comment) {
+            return null;
+        }
+        if (!comment.blockTags) {
+            return null;
+        }
+        const tag = comment.blockTags.find(item => {
+            return item.tag === infoName;
+        });
+        if (!tag) {
+            return null;
+        }
+        return this.combineDisplayParts(tag.content);
+    }
+    getGenericType(typeParameters) {
         if (typeParameters && typeParameters.length) {
-            var typeArgumentsList = typeParameters.map(function (item) {
+            let typeArgumentsList = typeParameters.map(item => {
                 return item.name;
             }).join(', ');
             return '<' + typeArgumentsList + '>';
         }
         return '';
-    };
-    AbstractConverter.prototype.findDescriptionInComment = function (comment) {
+    }
+    extractCommentForAnonymousFunction(type) {
+        // when is a anonymous function, commont should be extract from this method
+        if (type && type.type === 'reflection' && type.declaration) {
+            const signatures = type.declaration.signatures;
+            if (signatures && signatures.length) {
+                return signatures[0].comment;
+            }
+        }
+        return undefined;
+    }
+    findDescriptionInAnonymousFunction(type) {
+        /**
+         * comment for below anonymous  function
+         * () => void
+         */
+        const comment = this.extractCommentForAnonymousFunction(type);
+        if (comment) {
+            return this.findDescriptionInComment(comment);
+        }
+        return '';
+    }
+    findDescriptionInComment(comment) {
         if (!comment) {
             return '';
         }
-        var descText = this.parseDescTextFromComment(comment);
-        var tagText = this.extractTagsTextFromComment(comment);
-        return "" + descText + tagText;
-    };
-    AbstractConverter.prototype.parseDescTextFromComment = function (comment) {
-        if (comment.tags) {
-            var text_1 = null;
-            comment.tags.forEach(function (tag) {
-                if (tag.tag === 'classdesc'
-                    || tag.tag === 'description'
-                    || tag.tag === 'exemptedapi'
-                    || tag.tag === 'property') {
-                    text_1 = tag.text.trim();
+        const descText = this.parseDescTextFromComment(comment);
+        const tagText = this.extractTagsTextFromComment(comment);
+        return `${descText}${tagText}`;
+    }
+    parseDescTextFromComment(comment) {
+        if (comment.blockTags) {
+            let text = null;
+            comment.blockTags.forEach(tag => {
+                if (tag.tag === '@classdesc'
+                    || tag.tag === '@description'
+                    || tag.tag === '@exemptedapi'
+                    || tag.tag === '@property') {
+                    text = this.combineDisplayParts(tag.content);
                     return;
                 }
             });
-            if (text_1) {
-                return text_1.trim();
+            if (text) {
+                return text.trim();
             }
         }
-        if (comment.shortText && comment.text) {
-            return comment.shortText + "\n" + comment.text;
-        }
-        if (comment.text) {
-            return comment.text.trim();
-        }
-        if (comment.shortText) {
-            return comment.shortText.trim();
-        }
-        return '';
-    };
-    AbstractConverter.prototype.extractTagsTextFromComment = function (comment) {
-        if (comment && comment.tags) {
-            return comment.tags.map(function (tag) {
-                if (tag.tag === 'see') {
-                    return "\n\nSee " + tag.text.trim();
+        return this.combineDisplayParts(comment.summary);
+    }
+    extractTagsTextFromComment(comment) {
+        if (comment && comment.blockTags) {
+            return comment.blockTags.map(tag => {
+                if (tag.tag === '@see') {
+                    const content = this.combineDisplayParts(tag.content);
+                    if (content === '') {
+                        return '';
+                    }
+                    if (content.startsWith("- ")) {
+                        // becuase combineDisplayParts will trim content, if there exist typedoc added hyphen, the prefix space will be removed, so added back
+                        const preBlankContent = ` ${content}`;
+                        // typedoc will merge all @see tag, so just replace the " - " to See to make it looks like old typedoc
+                        return `\n\n${preBlankContent.replace(/ - /g, "See ")}`;
+                    }
+                    return `\n\nSee ${content}`;
+                }
+                else if (tag.tag === '@example') {
+                    return `\n\n**Example**\n\n${this.combineDisplayParts(tag.content)}\n\n`;
                 }
-                else if (tag.tag === 'example') {
-                    return "\n\n**Example**\n\n" + tag.text.trim() + "\n\n";
+                else if (tag.tag === '@member') {
+                    const content = this.combineDisplayParts(tag.content);
+                    const match = content.match(/\[.*?\] (.*)/);
+                    let result = '';
+                    if (match) {
+                        result += `${match[1].trim()}`;
+                    }
+                    return result;
                 }
                 else {
                     return '';
@@ -151,10 +183,9 @@ var AbstractConverter = /** @class */ (function () {
             }).join('');
         }
         return '';
-    };
-    AbstractConverter.prototype.extractType = function (type) {
-        var _this = this;
-        var result = [];
+    }
+    extractType(type) {
+        let result = [];
         if (type === undefined) {
             return result;
         }
@@ -167,8 +198,8 @@ var AbstractConverter = /** @class */ (function () {
             else {
                 result.push({
                     unionType: {
-                        types: type.types.map(function (t) {
-                            var childType = _this.extractType(t)[0];
+                        types: type.types.map(t => {
+                            let childType = this.extractType(t)[0];
                             childType.parentType = type.type;
                             return childType;
                         })
@@ -177,43 +208,89 @@ var AbstractConverter = /** @class */ (function () {
             }
         }
         else if (type.type === 'array') {
-            var newType = this.extractType(type.elementType);
+            let newType = this.extractType(type.elementType);
             result.push({
-                arrayType: __assign(__assign({}, newType[0]), { parentType: type.type })
+                arrayType: {
+                    ...newType[0],
+                    parentType: type.type
+                }
+            });
+        }
+        else if (type.type === 'conditional') {
+            result.push({
+                conditionalType: {
+                    checkType: this.extractType(type.checkType)[0],
+                    extendsType: this.extractType(type.extendsType)[0],
+                    trueType: this.extractType(type.trueType)[0],
+                    falseType: this.extractType(type.falseType)[0]
+                }
             });
         }
         else if (type.type === 'intersection' && type.types.length) {
             result.push({
                 intersectionType: {
-                    types: type.types.map(function (t) {
-                        var childType = _this.extractType(t)[0];
+                    types: type.types.map(t => {
+                        let childType = this.extractType(t)[0];
                         childType.parentType = type.type;
                         return childType;
                     })
                 }
             });
         }
+        else if (type.type === 'typeOperator') {
+            result.push({
+                operatorType: {
+                    operator: type.operator,
+                    target: this.extractType(type.target)[0]
+                }
+            });
+        }
+        else if (type.type === 'query') {
+            /**
+             * Represents a type that is constructed by querying the type of a reflection.
+             * ```ts
+             * const x = 1
+             * type Z = typeof x // query on reflection for x
+             * ```
+             */
+            result.push({
+                queryType: this.extractType(type.queryType)[0]
+            });
+        }
+        else if (type.type === 'indexedAccess') {
+            /**
+             * Represents an indexed access type.
+             * ```ts
+             * type X = A[keyof A]
+             * ```
+             */
+            result.push({
+                indexedAccessType: {
+                    indexType: this.extractType(type.indexType)[0],
+                    objectType: this.extractType(type.objectType)[0],
+                }
+            });
+        }
         else if (type.type === 'reflection' && type.declaration) {
             if (type.declaration.indexSignature) {
-                var signatures = type.declaration.indexSignature;
-                signatures.forEach(function (signature) {
-                    result.push({
-                        reflectedType: {
-                            key: {
-                                typeName: signature.parameters[0].type.name,
-                                typeId: signature.parameters[0].type.id
-                            },
-                            value: {
-                                typeName: signature.type.name,
-                                typeId: signature.type.id
-                            }
+                const signature = type.declaration.indexSignature;
+                result.push({
+                    reflectedType: {
+                        name: signature.parameters[0].name ?? 'key',
+                        key: {
+                            typeName: signature.parameters[0].type.name,
+                            typeId: signature.parameters[0].type.id
+                        },
+                        value: {
+                            typeName: signature.type.name,
+                            typeId: signature.type.id
                         }
-                    });
+                    }
                 });
             }
             else if (type.declaration.signatures && type.declaration.signatures.length) {
                 result.push({
-                    typeName: this.generateCallFunction('', this.fillParameters(type.declaration.signatures[0].parameters)) + " => " + idResolver_1.typeToString(this.extractType(type.declaration.signatures[0].type)[0])
+                    typeName: `${this.generateCallFunction('', this.fillParameters(type.declaration.signatures[0].parameters))} => ${(0, idResolver_1.typeToString)(this.extractType(type.declaration.signatures[0].type)[0])}`
                 });
             }
             else if (type.declaration.children && type.declaration.children.length) {
@@ -223,7 +300,7 @@ var AbstractConverter = /** @class */ (function () {
             }
             else {
                 result.push({
-                    typeName: 'Object'
+                    typeName: '{}'
                 });
             }
         }
@@ -234,26 +311,30 @@ var AbstractConverter = /** @class */ (function () {
                         typeName: type.name,
                         typeId: type.id
                     },
-                    inner: type.typeArguments.map(function (t) { return _this.extractType(t)[0]; })
+                    inner: type.typeArguments.map(t => this.extractType(t)[0])
                 }
             });
         }
         else if (type.type === 'tuple' && type.elements && type.elements.length) {
             result.push({
                 tupleType: {
-                    types: type.elements.map(function (t) { return _this.extractType(t)[0]; })
+                    types: type.elements.map(t => this.extractType(t)[0])
                 }
             });
         }
-        else if (type.name) {
+        else if (type.type === 'literal') {
+            let typeName = `${type.value}`;
+            if (typeof type.value === "string") {
+                typeName = `"${type.value}"`;
+            }
             result.push({
-                typeName: type.name,
-                typeId: type.id
+                typeName: typeName
             });
         }
-        else if (type.value) {
+        else if (type.name) {
             result.push({
-                typeName: "\"" + type.value + "\""
+                typeName: type.name,
+                typeId: type.id
             });
         }
         else {
@@ -262,48 +343,93 @@ var AbstractConverter = /** @class */ (function () {
             });
         }
         return result;
-    };
-    AbstractConverter.prototype.hasCommonPrefix = function (types) {
+    }
+    hasCommonPrefix(types) {
         if (types && types.length > 1 && types[0].name) {
             if (types[0].name.indexOf('.') < 0) {
                 return false;
             }
-            var prefix_1 = types[0].name.split('.')[0];
-            return types.find(function (t) { return !t.name || t.name.split('.')[0] !== prefix_1; }) === undefined;
+            const prefix = types[0].name.split('.')[0];
+            return types.find(t => !t.name || t.name.split('.')[0] !== prefix) === undefined;
         }
         return false;
-    };
-    AbstractConverter.prototype.generateCallFunction = function (prefix, parameters, typeParameters) {
+    }
+    generateCallFunction(prefix, parameters, typeParameters) {
         if (parameters) {
-            return "" + prefix + this.getGenericType(typeParameters) + "(" + parameters.map(function (p) { return "" + p.id + (p.optional ? '?' : '') + ": " + (idResolver_1.typeToString(p.type[0])); }).join(', ') + ")";
+            return `${prefix}${this.getGenericType(typeParameters)}(${parameters.map(p => `${p.id}${p.optional ? '?' : ''}: ${((0, idResolver_1.typeToString)(p.type[0]))}`).join(', ')})`;
         }
         return '';
-    };
-    AbstractConverter.prototype.fillParameters = function (parameters) {
-        var _this = this;
+    }
+    fillParameters(parameters) {
         if (parameters) {
-            return parameters.map(function (p) {
-                var description = '';
+            return parameters.map(p => {
+                let description = '';
                 if (p.comment) {
-                    description = (p.comment.shortText && p.comment.shortText !== '') ? p.comment.shortText : p.comment.text;
+                    description = this.combineDisplayParts(p.comment.summary);
                 }
                 return {
                     id: p.name,
-                    type: _this.extractType(p.type),
-                    description: linkConvertHelper_1.convertLinkToGfm(description),
+                    type: this.extractType(p.type),
+                    description: description,
                     optional: Boolean(p.flags && p.flags.isOptional)
                 };
             });
         }
         return [];
-    };
-    AbstractConverter.prototype.extractReturnComment = function (comment) {
-        if (comment == null || comment.returns == null) {
+    }
+    extractReturnComment(comment) {
+        const returnComment = this.extractTextFromComment('@returns', comment);
+        if (!returnComment) {
             return '';
         }
-        return linkConvertHelper_1.convertLinkToGfm(comment.returns.trim());
-    };
-    AbstractConverter.prototype.extractInformationFromSignature = function (method, node, signatureIndex) {
+        return returnComment;
+    }
+    combineDisplayParts(parts) {
+        let result = "";
+        for (const item of parts || []) {
+            switch (item.kind) {
+                case "text":
+                case "code":
+                    result += item.text;
+                    break;
+                case "inline-tag":
+                    switch (item.tag) {
+                        case "@label":
+                        case "@inheritdoc": // Shouldn't happen
+                            // ignore these content
+                            break;
+                        case "@linkcode":
+                            result += `{${item.tag}`;
+                            if (item.target && typeof item.target !== 'string') {
+                                result += ` ${item.target}`;
+                            }
+                            else {
+                                result += ` ${item.text}`;
+                            }
+                            result += '}';
+                            break;
+                        case "@link":
+                        case "@linkplain":
+                            result += `{${item.tag}`;
+                            if (item.target && item.target !== item.text) {
+                                result += ` ${item.target}`;
+                            }
+                            result += ` ${item.text}}`;
+                            break;
+                        default:
+                            // Hmm... probably want to be able to render these somehow, so custom inline tags can be given
+                            // special rendering rules. Future capability. For now, just render their text.
+                            result += `{${item.tag} ${item.text}}`;
+                            break;
+                    }
+                    break;
+                default:
+                    (0, error_1.assertNever)(item);
+            }
+        }
+        return result.trim().replace(/\r/g, "");
+    }
+    extractInformationFromSignature(method, node, signatureIndex) {
         if (node.signatures[signatureIndex].comment) {
             method.summary = this.findDescriptionInComment(node.signatures[signatureIndex].comment);
         }
@@ -320,16 +446,16 @@ var AbstractConverter = /** @class */ (function () {
         if (node.signatures[signatureIndex].comment && node.signatures[signatureIndex].comment.tags) {
             exceptions = node.signatures[signatureIndex].comment.tags.filter(tag => tag.tag === 'throws');
         }
-    
+
         if (exceptions && exceptions.length) {
             method.exceptions = exceptions.map(e => extractException(e));
         }
         */
         if (node.kindString === 'Method' || node.kindString === 'Function') {
-            var typeParameter = node.signatures[signatureIndex].typeParameter;
-            var functionBody = this.generateCallFunction(method.name, method.syntax.parameters, typeParameter);
-            var returnBody = (method.syntax.return && method.syntax.return.type.length > 0) ? ": " + idResolver_1.typeToString(method.syntax.return.type[0]) : '';
-            method.syntax.content = (node.flags && node.flags.isStatic ? 'static ' : '') + "function " + functionBody + returnBody;
+            const typeParameter = node.signatures[signatureIndex].typeParameter;
+            const functionBody = this.generateCallFunction(method.name, method.syntax.parameters, typeParameter);
+            const returnBody = (method.syntax.return && method.syntax.return.type.length > 0) ? `: ${(0, idResolver_1.typeToString)(method.syntax.return.type[0])}` : '';
+            method.syntax.content = `${node.flags && node.flags.isStatic ? 'static ' : ''}function ${functionBody}${returnBody}`;
             method.type = node.kindString.toLowerCase();
             if (node.inheritedFrom) {
                 method.inherited = true;
@@ -338,69 +464,68 @@ var AbstractConverter = /** @class */ (function () {
         }
         else {
             method.name = method.uid.split('.').reverse()[1];
-            var functionBody = this.generateCallFunction(method.name, method.syntax.parameters);
-            method.syntax.content = "new " + functionBody;
+            const functionBody = this.generateCallFunction(method.name, method.syntax.parameters);
+            method.syntax.content = `new ${functionBody}`;
             method.type = 'constructor';
         }
-    };
-    AbstractConverter.prototype.composeMethodNameFromSignature = function (method, typeParameters) {
-        var parameterType = method.syntax.parameters.map(function (p) {
-            return idResolver_1.typeToString(p.type[0]);
+    }
+    composeMethodNameFromSignature(method, typeParameters) {
+        const parameterType = method.syntax.parameters.map(p => {
+            return (0, idResolver_1.typeToString)(p.type[0]);
         }).join(', ');
         return method.name + this.getGenericType(typeParameters) + '(' + parameterType + ')';
-    };
-    AbstractConverter.prototype.parseTypeArgumentsForTypeAlias = function (node) {
-        var typeParameter;
-        if (node.typeParameter) {
-            typeParameter = node.typeParameter;
+    }
+    parseTypeArgumentsForTypeAlias(node) {
+        let typeParameter;
+        if (node.typeParameters) {
+            typeParameter = node.typeParameters;
         }
         else if (node.typeArguments) {
             typeParameter = node.typeArguments;
         }
         return this.getGenericType(typeParameter);
-    };
-    AbstractConverter.prototype.parseTypeDeclarationForTypeAlias = function (typeInfo) {
-        return idResolver_1.typeToString(this.extractType(typeInfo)[0]);
-    };
-    AbstractConverter.prototype.parseFunctionType = function (typeInfo) {
-        var typeResult = this.extractType(typeInfo);
-        var content = '';
+    }
+    parseTypeDeclarationForTypeAlias(typeInfo) {
+        return (0, idResolver_1.typeToString)(this.extractType(typeInfo)[0]);
+    }
+    parseFunctionType(typeInfo) {
+        let typeResult = this.extractType(typeInfo);
+        let content = '';
         if (typeResult.length) {
             content = typeResult[0].typeName;
         }
         return content;
-    };
-    AbstractConverter.prototype.parseUserDefinedType = function (typeInfo) {
-        var _this = this;
+    }
+    parseUserDefinedType(typeInfo) {
         if (!typeInfo.declaration || !typeInfo.declaration.children) {
             return '';
         }
-        var content = typeInfo.declaration.children.map(function (child) {
-            var type = '';
-            var isOptional = child.flags && child.flags.isOptional ? '?' : '';
-            if (child.kindString === 'Variable') {
-                type = "" + child.name + isOptional + ": " + idResolver_1.typeToString(_this.extractType(child.type)[0]);
+        let content = typeInfo.declaration.children.map(child => {
+            let type = '';
+            let isOptional = child.flags && child.flags.isOptional;
+            let typePostFix = isOptional ? '?' : '';
+            if (child.kindString === 'Variable' || child.kindString === 'Property') {
+                type = `${child.name}${typePostFix}: ` + (0, idResolver_1.typeToString)(this.extractType(child.type)[0]);
             }
-            else if (child.kindString === 'Function') {
-                type = _this.generateCallFunction("" + child.name + isOptional, _this.fillParameters(child.signatures[0].parameters)) + " => " + idResolver_1.typeToString(_this.extractType(child.signatures[0].type)[0]);
+            else if (child.kindString === 'Function' || child.kindString === 'Method') {
+                type = `${this.generateCallFunction(`${child.name}${typePostFix}`, this.fillParameters(child.signatures[0].parameters))} => ${(0, idResolver_1.typeToString)(this.extractType(child.signatures[0].type)[0])}`;
             }
             return type;
         }).join(', ');
         content = '{ ' + content + ' }';
         return content;
-    };
-    AbstractConverter.prototype.generateInheritanceDescription = function (inheritedFrom) {
+    }
+    generateInheritanceDescription(inheritedFrom) {
         if (inheritedFrom) {
             if (inheritedFrom.id) {
-                return "<b>Inherited From</b> [" + inheritedFrom.name + "](xref:" + inheritedFrom.name + ")";
+                return `<b>Inherited From</b> [${inheritedFrom.name}](xref:${inheritedFrom.name})`;
             }
             else {
-                return "<b>Inherited From</b> " + inheritedFrom.name;
+                return `<b>Inherited From</b> ${inheritedFrom.name}`;
             }
         }
         return null;
-    };
-    return AbstractConverter;
-}());
+    }
+}
 exports.AbstractConverter = AbstractConverter;
 //# sourceMappingURL=base.js.map