@trapi/metadata 1.2.2 → 1.3.0

package/dist/resolver/module.js

@@ -21,46 +21,47 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeNodeResolver = void 0;
+const typescript_1 = require("typescript");
 const ts = __importStar(require("typescript"));
 const decorator_1 = require("../decorator");
 const constants_1 = require("./constants");
 const utils_1 = require("../utils");
 const error_1 = require("./error");
 const extension_1 = require("./extension");
+const sub_1 = require("./sub");
 const type_1 = require("./type");
+const utils_2 = require("./utils");
 const localReferenceTypeCache = {};
 const inProgressTypes = {};
-class TypeNodeResolver {
+class TypeNodeResolver extends sub_1.ResolverBase {
     constructor(typeNode, current, parentNode, context, referencer) {
-        this.attemptToResolveKindToPrimitive = (syntaxKind) => {
-            if (syntaxKind === ts.SyntaxKind.NumberKeyword) {
-                return 'number';
-            }
-            if (syntaxKind === ts.SyntaxKind.StringKeyword) {
-                return 'string';
-            }
-            if (syntaxKind === ts.SyntaxKind.BooleanKeyword) {
-                return 'boolean';
-            }
-            if (syntaxKind === ts.SyntaxKind.VoidKeyword) {
-                return 'void';
-            }
-            return undefined;
-        };
+        super();
         this.typeNode = typeNode;
         this.current = current;
         this.parentNode = parentNode;
         this.context = context || {};
         this.referencer = referencer;
+        this.primitiveResolver = new sub_1.PrimitiveResolver(current.decoratorResolver);
+        this.referenceResolver = new sub_1.ReferenceResolver(current.typeChecker);
     }
     static clearCache() {
         Object.keys(localReferenceTypeCache).forEach((key) => {
@@ -71,7 +72,7 @@ class TypeNodeResolver {
         });
     }
     resolve() {
-        const primitiveType = this.getPrimitiveType(this.typeNode, this.parentNode);
+        const primitiveType = this.primitiveResolver.resolve(this.typeNode, this.parentNode);
         if (primitiveType) {
             return primitiveType;
         }
@@ -81,11 +82,6 @@ class TypeNodeResolver {
                 members: [null],
             };
         }
-        if (this.typeNode.kind === ts.SyntaxKind.UndefinedKeyword) {
-            return {
-                typeName: constants_1.TypeName.UNDEFINED,
-            };
-        }
         if (ts.isArrayTypeNode(this.typeNode)) {
             return {
                 typeName: constants_1.TypeName.ARRAY,
@@ -177,7 +173,7 @@ class TypeNodeResolver {
             const properties = type
                 .getProperties()
                 // Ignore methods, getter, setter and @ignored props
-                .filter((property) => isIgnored(property) === false)
+                .filter((property) => !isIgnored(property))
                 // Transform to property
                 .map((property) => {
                 const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, this.typeNode);
@@ -190,7 +186,7 @@ class TypeNodeResolver {
                 }
                 // Resolve default value, required and typeNode
                 let required = false;
-                const typeNode = this.current.typeChecker.typeToTypeNode(propertyType, undefined, ts.NodeBuilderFlags.NoTruncation);
+                const typeNode = (0, utils_2.toTypeNodeOrFail)(this.current.typeChecker, propertyType, undefined, ts.NodeBuilderFlags.NoTruncation);
                 if (mappedTypeNode.questionToken && mappedTypeNode.questionToken.kind === ts.SyntaxKind.MinusToken) {
                     required = true;
                 }
@@ -216,32 +212,38 @@ class TypeNodeResolver {
             ts.isTypeReferenceNode(this.referencer)) {
             const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer);
             if (type.aliasSymbol) {
-                let declaration = type.aliasSymbol.declarations[0];
-                if (declaration.name) {
+                let [declaration] = type.aliasSymbol.declarations;
+                if (declaration && declaration.name) {
                     declaration = this.getModelTypeDeclaration(declaration.name);
                 }
                 const name = TypeNodeResolver.getRefTypeName(this.referencer.getText());
                 return this.handleCachingAndCircularReferences(name, () => {
-                    if (ts.isTypeAliasDeclaration(declaration)) {
-                        // Note: I don't understand why typescript lose type for `this.referencer` (from above with isTypeReferenceNode())
-                        return this.getTypeAliasReference(declaration, this.current.typeChecker.typeToString(type), this.referencer);
-                    }
-                    if (ts.isEnumDeclaration(declaration)) {
-                        return this.getEnumerateType(declaration.name);
+                    if (declaration) {
+                        if (ts.isTypeAliasDeclaration(declaration)) {
+                            // Note: I don't understand why typescript lose type for `this.referencer`
+                            // (from above with isTypeReferenceNode())
+                            return this.getTypeAliasReference(declaration, this.current.typeChecker.typeToString(type), this.referencer);
+                        }
+                        if (ts.isEnumDeclaration(declaration)) {
+                            return this.getEnumerateType(declaration.name);
+                        }
                     }
                     throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. We found an aliasSymbol and it's declaration was of kind ${declaration.kind}`, this.typeNode);
                 });
             }
             if (type.isClassOrInterface()) {
-                let declaration = type.symbol.declarations[0];
-                if (declaration.name) {
+                let [declaration] = type.symbol.declarations;
+                if (declaration && declaration.name) {
                     declaration = this.getModelTypeDeclaration(declaration.name);
                 }
+                if (!declaration) {
+                    throw new error_1.ResolverError('Couldn\'t get declaration for type symbol', this.typeNode);
+                }
                 const name = TypeNodeResolver.getRefTypeName(this.referencer.getText());
                 return this.handleCachingAndCircularReferences(name, () => this.getModelReference(declaration, this.current.typeChecker.typeToString(type)));
             }
             try {
-                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
+                return new TypeNodeResolver((0, utils_2.toTypeNodeOrFail)(this.current.typeChecker, type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
             }
             catch {
                 throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. The flags on the result of the ConditionalType was ${type.flags}`, this.typeNode);
@@ -251,7 +253,7 @@ class TypeNodeResolver {
             if (this.typeNode.operator === ts.SyntaxKind.KeyOfKeyword) {
                 const type = this.current.typeChecker.getTypeFromTypeNode(this.typeNode);
                 try {
-                    return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
+                    return new TypeNodeResolver((0, utils_2.toTypeNodeOrFail)(this.current.typeChecker, type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
                 }
                 catch (err) {
                     const indexedTypeName = this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.type));
@@ -271,11 +273,12 @@ class TypeNodeResolver {
             if (type === undefined) {
                 throw new error_1.ResolverError(`Could not determine ${numberIndexType ? 'number' : 'string'} index on ${this.current.typeChecker.typeToString(objectType)}`, this.typeNode);
             }
-            return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
+            return new TypeNodeResolver((0, utils_2.toTypeNodeOrFail)(this.current.typeChecker, type, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
         }
         if (ts.isIndexedAccessTypeNode(this.typeNode) &&
             ts.isLiteralTypeNode(this.typeNode.indexType) &&
-            (ts.isStringLiteral(this.typeNode.indexType.literal) || ts.isNumericLiteral(this.typeNode.indexType.literal))) {
+            (ts.isStringLiteral(this.typeNode.indexType.literal) ||
+                ts.isNumericLiteral(this.typeNode.indexType.literal))) {
             const hasType = (node) => node !== undefined &&
                 Object.prototype.hasOwnProperty.call(node, 'type');
             const symbol = this.current.typeChecker.getPropertyOfType(this.current.typeChecker.getTypeFromTypeNode(this.typeNode.objectType), this.typeNode.indexType.literal.text);
@@ -287,10 +290,10 @@ class TypeNodeResolver {
             }
             const declaration = this.current.typeChecker.getTypeOfSymbolAtLocation(symbol, this.typeNode.objectType);
             try {
-                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(declaration, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
+                return new TypeNodeResolver((0, utils_2.toTypeNodeOrFail)(this.current.typeChecker, declaration, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
             }
             catch {
-                throw new error_1.ResolverError(`Could not determine the keys on ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.current.typeChecker.typeToTypeNode(declaration, undefined, undefined)))}`, this.typeNode);
+                throw new error_1.ResolverError(`Could not determine the keys on ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode((0, utils_2.toTypeNodeOrFail)(this.current.typeChecker, declaration, undefined, undefined)))}`, this.typeNode);
             }
         }
         if (this.typeNode.kind === ts.SyntaxKind.TemplateLiteralType) {
@@ -312,7 +315,8 @@ class TypeNodeResolver {
         const typeReference = this.typeNode;
         if (typeReference.typeName.kind === ts.SyntaxKind.Identifier) {
             // Special Utility Type
-            if (typeReference.typeName.text === 'Record') {
+            if (typeReference.typeName.text === 'Record' &&
+                typeReference.typeArguments) {
                 return {
                     additionalProperties: new TypeNodeResolver(typeReference.typeArguments[1], this.current, this.parentNode, this.context).resolve(),
                     typeName: constants_1.TypeName.NESTED_OBJECT_LITERAL,
@@ -455,85 +459,6 @@ class TypeNodeResolver {
         }
         return value;
     }
-    getPrimitiveType(typeNode, parentNode) {
-        if (!typeNode) {
-            return {
-                typeName: constants_1.TypeName.VOID,
-            };
-        }
-        const resolvedType = this.attemptToResolveKindToPrimitive(typeNode.kind);
-        if (typeof resolvedType === 'undefined') {
-            return undefined;
-        }
-        if (resolvedType === 'number') {
-            if (!parentNode) {
-                return { typeName: constants_1.TypeName.DOUBLE };
-            }
-            const lookupTags = [
-                'isInt',
-                'isLong',
-                'isFloat',
-                'isDouble',
-            ];
-            const tags = (0, utils_1.getJSDocTagNames)(parentNode)
-                .filter((name) => lookupTags.some((m) => m.toLowerCase() === name.toLowerCase()))
-                .map((name) => name.toLowerCase());
-            const decoratorIds = [
-                decorator_1.DecoratorID.IS_INT,
-                decorator_1.DecoratorID.IS_LONG,
-                decorator_1.DecoratorID.IS_FLOAT,
-                decorator_1.DecoratorID.IS_DOUBLE,
-            ];
-            let decoratorID;
-            for (let i = 0; i < decoratorIds.length; i++) {
-                const decorator = this.current.decoratorResolver.match(decoratorIds[i], parentNode);
-                if (decorator) {
-                    decoratorID = decoratorIds[i];
-                    break;
-                }
-            }
-            if (!decoratorID && tags.length === 0) {
-                return { typeName: constants_1.TypeName.DOUBLE };
-            }
-            switch (decoratorID || tags[0]) {
-                case decorator_1.DecoratorID.IS_INT:
-                case 'isint':
-                    return { typeName: constants_1.TypeName.INTEGER };
-                case decorator_1.DecoratorID.IS_LONG:
-                case 'islong':
-                    return { typeName: constants_1.TypeName.LONG };
-                case decorator_1.DecoratorID.IS_FLOAT:
-                case 'isfloat':
-                    return { typeName: constants_1.TypeName.FLOAT };
-                case decorator_1.DecoratorID.IS_DOUBLE:
-                case 'isdouble':
-                    return { typeName: constants_1.TypeName.DOUBLE };
-                default:
-                    return { typeName: constants_1.TypeName.DOUBLE };
-            }
-        }
-        else if (resolvedType === 'string') {
-            return {
-                typeName: constants_1.TypeName.STRING,
-            };
-        }
-        else if (resolvedType === 'boolean') {
-            return {
-                typeName: constants_1.TypeName.BOOLEAN,
-            };
-        }
-        else if (resolvedType === 'void') {
-            return {
-                typeName: constants_1.TypeName.VOID,
-            };
-        }
-        else {
-            // todo: should not occur
-            return {
-                typeName: resolvedType,
-            };
-        }
-    }
     getDateType(parentNode) {
         if (!parentNode) {
             return { typeName: constants_1.TypeName.DATETIME };
@@ -595,7 +520,7 @@ class TypeNodeResolver {
                 if (ts.isLiteralTypeNode(arg)) {
                     return `'${String(TypeNodeResolver.getLiteralValue(arg))}'`;
                 }
-                const resolvedType = this.attemptToResolveKindToPrimitive(arg.kind);
+                const resolvedType = this.primitiveResolver.resolveSyntaxKind(arg.kind);
                 if (typeof resolvedType === 'undefined') {
                     return 'any';
                 }
@@ -610,16 +535,21 @@ class TypeNodeResolver {
         let utilityTypeOptions;
         if (utilityType) {
             const { typeArguments } = type.parent;
-            if (ts.isTypeReferenceNode(typeArguments[0])) {
-                type = typeArguments[0].typeName;
-            }
-            else if (ts.isExpressionWithTypeArguments(typeArguments[0])) {
-                type = typeArguments[0].expression;
+            if (typeArguments) {
+                if (ts.isTypeReferenceNode(typeArguments[0])) {
+                    type = typeArguments[0].typeName;
+                }
+                else if (ts.isExpressionWithTypeArguments(typeArguments[0])) {
+                    type = typeArguments[0].expression;
+                }
+                else {
+                    throw new error_1.ResolverError('Can\'t resolve Reference type.');
+                }
+                utilityTypeOptions = TypeNodeResolver.getUtilityTypeOptions(typeArguments);
             }
             else {
-                throw new error_1.ResolverError('Can\'t resolve Reference type.');
+                throw new error_1.ResolverError('Can\'t resolve type arguments of utility type.');
             }
-            utilityTypeOptions = TypeNodeResolver.getUtilityTypeOptions(typeArguments);
         }
         else {
             this.typeArgumentsToContext(node, type, this.context);
@@ -629,35 +559,30 @@ class TypeNodeResolver {
             if (existingType) {
                 return existingType;
             }
-            const refEnumType = this.getEnumerateType(type);
-            if (refEnumType) {
-                localReferenceTypeCache[name] = refEnumType;
-                return refEnumType;
-            }
             if (inProgressTypes[name]) {
                 return this.createCircularDependencyResolver(name);
             }
             inProgressTypes[name] = true;
-            const declaration = this.getModelTypeDeclaration(type);
-            let referenceType;
-            if (ts.isTypeAliasDeclaration(declaration)) {
-                referenceType = this.getTypeAliasReference(declaration, name, node, utilityType, utilityTypeOptions);
-                localReferenceTypeCache[name] = referenceType;
-                return referenceType;
-            }
-            if (ts.isEnumMember(declaration)) {
-                referenceType = {
-                    typeName: constants_1.TypeName.REF_ENUM,
-                    refName: TypeNodeResolver.getRefTypeName(name, utilityType),
-                    members: [this.current.typeChecker.getConstantValue(declaration)],
-                    memberNames: [declaration.name.getText()],
-                    deprecated: (0, utils_1.hasJSDocTag)(declaration, utils_1.JSDocTagName.DEPRECATED),
-                };
-                localReferenceTypeCache[name] = referenceType;
-                return referenceType;
+            const refName = TypeNodeResolver.getRefTypeName(name, utilityType);
+            const declarations = this.getModelTypeDeclarations(type);
+            const referenceTypes = [];
+            for (let i = 0; i < declarations.length; i++) {
+                const declaration = declarations[i];
+                if (ts.isTypeAliasDeclaration(declaration)) {
+                    referenceTypes.push(this.getTypeAliasReference(declaration, name, node, utilityType, utilityTypeOptions));
+                }
+                else if ((0, typescript_1.isEnumDeclaration)(declaration)) {
+                    referenceTypes.push(this.referenceResolver.transformEnum(declaration, refName));
+                }
+                else if ((0, typescript_1.isEnumMember)(declaration)) {
+                    referenceTypes.push(this.referenceResolver.transformEnumMember(declaration, refName));
+                }
+                else {
+                    // todo: dont cast handle property-signature
+                    referenceTypes.push(this.getModelReference(declaration, name, utilityType, utilityTypeOptions));
+                }
             }
-            // todo: dont cast handle property-signature
-            referenceType = this.getModelReference(declaration, name, utilityType, utilityTypeOptions);
+            const referenceType = this.referenceResolver.merge(referenceTypes);
             localReferenceTypeCache[name] = referenceType;
             return referenceType;
         }
@@ -710,8 +635,13 @@ class TypeNodeResolver {
             let nodeType = toJSON.valueDeclaration.type;
             if (!nodeType) {
                 const signature = this.current.typeChecker.getSignatureFromDeclaration(toJSON.valueDeclaration);
-                const implicitType = this.current.typeChecker.getReturnTypeOfSignature(signature);
-                nodeType = this.current.typeChecker.typeToTypeNode(implicitType, undefined, ts.NodeBuilderFlags.NoTruncation);
+                if (signature) {
+                    const implicitType = this.current.typeChecker.getReturnTypeOfSignature(signature);
+                    nodeType = this.current.typeChecker.typeToTypeNode(implicitType, undefined, ts.NodeBuilderFlags.NoTruncation);
+                }
+                else {
+                    throw new error_1.ResolverError('Can\'t get signature from toJson value declaration', modelType);
+                }
             }
             return {
                 refName: `${TypeNodeResolver.getRefTypeName(name, utilityType)}Alias`,
@@ -816,11 +746,46 @@ class TypeNodeResolver {
                 return false;
         }
     }
+    getModelTypeDeclarations(type) {
+        let typeName = type.kind === ts.SyntaxKind.Identifier ? type.text : type.right.text;
+        let symbol = this.getSymbolAtLocation(type);
+        if (!symbol && type.kind === ts.SyntaxKind.QualifiedName) {
+            const fullEnumSymbol = this.getSymbolAtLocation(type.left);
+            symbol = fullEnumSymbol.exports?.get(typeName);
+        }
+        if (!symbol) {
+            throw new error_1.ResolverError(`No symbol found for referenced type ${typeName}.`);
+        }
+        const declarations = symbol.getDeclarations();
+        if (!declarations || declarations.length === 0) {
+            throw new error_1.ResolverError(`No declarations found for referenced type ${typeName}.`);
+        }
+        if (symbol.escapedName !== typeName && symbol.escapedName !== 'default') {
+            typeName = symbol.escapedName;
+        }
+        let modelTypes = declarations.filter((node) => {
+            if (!TypeNodeResolver.nodeIsUsable(node) || !this.current.isExportedNode(node)) {
+                return false;
+            }
+            const modelTypeDeclaration = node;
+            return modelTypeDeclaration.name?.text === typeName;
+        });
+        if (!modelTypes.length) {
+            throw new error_1.ResolverError(`No matching model found for referenced type ${typeName}. If ${typeName} comes from a dependency, please create an interface in your own code that has the same structure. The compiler can not utilize interfaces from external dependencies.`);
+        }
+        if (modelTypes.length > 1) {
+            // remove types that are from typescript e.g. 'Account'
+            modelTypes = modelTypes.filter((modelType) => modelType.getSourceFile()
+                .fileName.replace(/\\/g, '/').toLowerCase().indexOf('node_modules/typescript') <= -1);
+            modelTypes = TypeNodeResolver.getDesignatedModels(modelTypes, typeName);
+        }
+        return modelTypes;
+    }
     getModelTypeDeclaration(type) {
         let typeName = type.kind === ts.SyntaxKind.Identifier ? type.text : type.right.text;
         const symbol = this.getSymbolAtLocation(type);
         const declarations = symbol.getDeclarations();
-        if (declarations.length === 0) {
+        if (!declarations || declarations.length === 0) {
             throw new error_1.ResolverError(`No models found for referenced type ${typeName}.`);
         }
         if (symbol.escapedName !== typeName && symbol.escapedName !== 'default') {
@@ -862,7 +827,8 @@ class TypeNodeResolver {
         const isIgnored = (e) => (0, utils_1.hasJSDocTag)(e, utils_1.JSDocTagName.IGNORE);
         // Interface model
         if (ts.isInterfaceDeclaration(node)) {
-            return node.members.filter((member) => !isIgnored(member) &&
+            return node.members
+                .filter((member) => !isIgnored(member) &&
                 ts.isPropertySignature(member)).map((member) => this.propertyFromSignature(member, overrideToken));
         }
         // Class model
@@ -1031,60 +997,8 @@ class TypeNodeResolver {
         });
         return properties;
     }
-    hasPublicModifier(node) {
-        if (!ts.canHaveModifiers(node)) {
-            return true;
-        }
-        const modifiers = ts.getModifiers(node);
-        if (!modifiers) {
-            return true;
-        }
-        return modifiers.every((modifier) => modifier.kind !== ts.SyntaxKind.ProtectedKeyword && modifier.kind !== ts.SyntaxKind.PrivateKeyword);
-    }
-    hasStaticModifier(node) {
-        if (!ts.canHaveModifiers(node)) {
-            return false;
-        }
-        const modifiers = ts.getModifiers(node);
-        return modifiers && modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword);
-    }
-    isAccessibleParameter(node) {
-        // No modifiers
-        if (!ts.canHaveModifiers(node)) {
-            return false;
-        }
-        const modifiers = ts.getModifiers(node);
-        if (!modifiers) {
-            return false;
-        }
-        // public || public readonly
-        if (modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.PublicKeyword)) {
-            return true;
-        }
-        // readonly, not private readonly, not public readonly
-        const isReadonly = modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword);
-        const isProtectedOrPrivate = modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ProtectedKeyword ||
-            modifier.kind === ts.SyntaxKind.PrivateKeyword);
-        return isReadonly && !isProtectedOrPrivate;
-    }
     getNodeDescription(node) {
-        const symbol = this.current.typeChecker.getSymbolAtLocation(node.name);
-        if (!symbol) {
-            return undefined;
-        }
-        /**
-         * TODO: Workaround for what seems like a bug in the compiler
-         * Warrants more investigation and possibly a PR against typescript
-         */
-        if (node.kind === ts.SyntaxKind.Parameter) {
-            // TypeScript won't parse jsdoc if the flag is 4, i.e. 'Property'
-            symbol.flags = 0;
-        }
-        const comments = symbol.getDocumentationComment(this.current.typeChecker);
-        if (comments.length) {
-            return ts.displayPartsToString(comments);
-        }
-        return undefined;
+        return (0, utils_2.getNodeDescription)(node, this.current.typeChecker);
     }
     static getNodeFormat(node) {
         return (0, utils_1.getJSDocTagComment)(node, utils_1.JSDocTagName.FORMAT);