typedoc 0.23.23 → 0.23.25

package/dist/lib/converter/convert-expression.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertExpression = exports.convertDefaultValue = void 0;
-const ts = require("typescript");
+const typescript_1 = __importDefault(require("typescript"));
 /**
  * Return the default value of the given node.
  *
@@ -20,32 +23,32 @@ function convertDefaultValue(node) {
 exports.convertDefaultValue = convertDefaultValue;
 function convertExpression(expression) {
     switch (expression.kind) {
-        case ts.SyntaxKind.StringLiteral:
-        case ts.SyntaxKind.TrueKeyword:
-        case ts.SyntaxKind.FalseKeyword:
-        case ts.SyntaxKind.NullKeyword:
-        case ts.SyntaxKind.NumericLiteral:
-        case ts.SyntaxKind.PrefixUnaryExpression:
-        case ts.SyntaxKind.Identifier:
+        case typescript_1.default.SyntaxKind.StringLiteral:
+        case typescript_1.default.SyntaxKind.TrueKeyword:
+        case typescript_1.default.SyntaxKind.FalseKeyword:
+        case typescript_1.default.SyntaxKind.NullKeyword:
+        case typescript_1.default.SyntaxKind.NumericLiteral:
+        case typescript_1.default.SyntaxKind.PrefixUnaryExpression:
+        case typescript_1.default.SyntaxKind.Identifier:
             return expression.getText();
     }
-    if (ts.isArrayLiteralExpression(expression) &&
+    if (typescript_1.default.isArrayLiteralExpression(expression) &&
         expression.elements.length === 0) {
         return "[]";
     }
-    if (ts.isObjectLiteralExpression(expression) &&
+    if (typescript_1.default.isObjectLiteralExpression(expression) &&
         expression.properties.length === 0) {
         return "{}";
     }
     // a.b.c.d
-    if (ts.isPropertyAccessExpression(expression)) {
+    if (typescript_1.default.isPropertyAccessExpression(expression)) {
         const parts = [expression.name.getText()];
         let iter = expression.expression;
-        while (ts.isPropertyAccessExpression(iter)) {
+        while (typescript_1.default.isPropertyAccessExpression(iter)) {
             parts.unshift(iter.name.getText());
             iter = iter.expression;
         }
-        if (ts.isIdentifier(iter)) {
+        if (typescript_1.default.isIdentifier(iter)) {
             parts.unshift(iter.text);
             return parts.join(".");
         }

package/dist/lib/converter/converter.d.ts

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import ts from "typescript";
 import type { Application } from "../application";
 import { Comment, CommentDisplayPart, ProjectReflection, Reflection, SomeType } from "../models/index";
 import { Context } from "./context";

package/dist/lib/converter/converter.js

@@ -5,10 +5,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var Converter_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Converter = void 0;
-const ts = require("typescript");
+const typescript_1 = __importDefault(require("typescript"));
 const index_1 = require("../models/index");
 const context_1 = require("./context");
 const components_1 = require("./components");
@@ -356,15 +359,15 @@ function getSymbolForModuleLike(context, node) {
     // "globals" file, but this is uncommon enough that I'm skipping it for now.
     const sourceFile = node.getSourceFile();
     const globalSymbols = context.checker
-        .getSymbolsInScope(node, ts.SymbolFlags.ModuleMember)
+        .getSymbolsInScope(node, typescript_1.default.SymbolFlags.ModuleMember)
         .filter((s) => s.getDeclarations()?.some((d) => d.getSourceFile() === sourceFile));
     // Detect declaration files with declare module "foo" as their only export
     // and lift that up one level as the source file symbol
     if (globalSymbols.length === 1 &&
         globalSymbols[0]
             .getDeclarations()
-            ?.every((declaration) => ts.isModuleDeclaration(declaration) &&
-            ts.isStringLiteral(declaration.name))) {
+            ?.every((declaration) => typescript_1.default.isModuleDeclaration(declaration) &&
+            typescript_1.default.isStringLiteral(declaration.name))) {
         return globalSymbols[0];
     }
 }
@@ -379,15 +382,15 @@ function getExports(context, node, symbol) {
         // members of the export= class and as functions if a class is directly exported.
         result = [exportEq].concat(context.checker
             .getExportsOfModule(symbol)
-            .filter((s) => !(0, enum_1.hasAnyFlag)(s.flags, ts.SymbolFlags.Prototype | ts.SymbolFlags.Value)));
+            .filter((s) => !(0, enum_1.hasAnyFlag)(s.flags, typescript_1.default.SymbolFlags.Prototype | typescript_1.default.SymbolFlags.Value)));
     }
     else if (symbol) {
         result = context.checker
             .getExportsOfModule(symbol)
-            .filter((s) => !(0, enum_1.hasAllFlags)(s.flags, ts.SymbolFlags.Prototype));
+            .filter((s) => !(0, enum_1.hasAllFlags)(s.flags, typescript_1.default.SymbolFlags.Prototype));
         if (result.length === 0) {
-            const globalDecl = node.statements.find((s) => ts.isModuleDeclaration(s) &&
-                s.flags & ts.NodeFlags.GlobalAugmentation);
+            const globalDecl = node.statements.find((s) => typescript_1.default.isModuleDeclaration(s) &&
+                s.flags & typescript_1.default.NodeFlags.GlobalAugmentation);
             if (globalDecl) {
                 const globalSymbol = context.getSymbolAtLocation(globalDecl);
                 if (globalSymbol) {
@@ -402,7 +405,7 @@ function getExports(context, node, symbol) {
         // Global file with no inferred top level symbol, get all symbols declared in this file.
         const sourceFile = node.getSourceFile();
         result = context.checker
-            .getSymbolsInScope(node, ts.SymbolFlags.ModuleMember)
+            .getSymbolsInScope(node, typescript_1.default.SymbolFlags.ModuleMember)
             .filter((s) => s
             .getDeclarations()
             ?.some((d) => d.getSourceFile() === sourceFile));

package/dist/lib/converter/factories/index-signature.d.ts

@@ -1,3 +1,3 @@
-import * as ts from "typescript";
+import ts from "typescript";
 import type { Context } from "../context";
 export declare function convertIndexSignature(context: Context, symbol: ts.Symbol): void;

package/dist/lib/converter/factories/index-signature.js

@@ -1,21 +1,24 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertIndexSignature = void 0;
-const assert = require("assert");
-const ts = require("typescript");
+const assert_1 = __importDefault(require("assert"));
+const typescript_1 = __importDefault(require("typescript"));
 const models_1 = require("../../models");
 const converter_events_1 = require("../converter-events");
 function convertIndexSignature(context, symbol) {
-    assert(context.scope instanceof models_1.DeclarationReflection);
+    (0, assert_1.default)(context.scope instanceof models_1.DeclarationReflection);
     const indexSymbol = symbol.members?.get("__index");
     if (indexSymbol) {
         // Right now TypeDoc models don't have a way to distinguish between string
         // and number index signatures... { [x: string]: 1 | 2; [x: number]: 2 }
         // will be misrepresented.
         const indexDeclaration = indexSymbol.getDeclarations()?.[0];
-        assert(indexDeclaration && ts.isIndexSignatureDeclaration(indexDeclaration));
+        (0, assert_1.default)(indexDeclaration && typescript_1.default.isIndexSignatureDeclaration(indexDeclaration));
         const param = indexDeclaration.parameters[0];
-        assert(param && ts.isParameter(param));
+        (0, assert_1.default)(param && typescript_1.default.isParameter(param));
         const index = new models_1.SignatureReflection("__index", models_1.ReflectionKind.IndexSignature, context.scope);
         index.parameters = [
             new models_1.ParameterReflection(param.name.getText(), models_1.ReflectionKind.Parameter, index),

package/dist/lib/converter/factories/signature.d.ts

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import ts from "typescript";
 import { ParameterReflection, ReflectionKind, SignatureReflection, TypeParameterReflection } from "../../models";
 import type { Context } from "../context";
 export declare function createSignature(context: Context, kind: ReflectionKind.CallSignature | ReflectionKind.ConstructorSignature | ReflectionKind.GetSignature | ReflectionKind.SetSignature, signature: ts.Signature, declaration?: ts.SignatureDeclaration | ts.JSDocSignature): void;

package/dist/lib/converter/factories/signature.js

@@ -1,8 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTypeParamReflection = exports.convertTypeParameterNodes = exports.convertParameterNodes = exports.createSignature = void 0;
-const ts = require("typescript");
-const assert = require("assert");
+const typescript_1 = __importDefault(require("typescript"));
+const assert_1 = __importDefault(require("assert"));
 const models_1 = require("../../models");
 const converter_events_1 = require("../converter-events");
 const convert_expression_1 = require("../convert-expression");
@@ -10,17 +13,23 @@ const reflections_1 = require("../utils/reflections");
 const comments_1 = require("../comments");
 function createSignature(context, kind, signature, declaration) {
     var _a;
-    assert(context.scope instanceof models_1.DeclarationReflection);
+    (0, assert_1.default)(context.scope instanceof models_1.DeclarationReflection);
     declaration || (declaration = signature.getDeclaration());
     const sigRef = new models_1.SignatureReflection(kind == models_1.ReflectionKind.ConstructorSignature
         ? `new ${context.scope.parent.name}`
         : context.scope.name, kind, context.scope);
-    // If we are creating signatures for a variable and the variable has a comment associated with it
-    // then we should prefer that variable's comment over any comment on the signature. The comment plugin
+    // If we are creating signatures for a variable or property and it has a comment associated with it
+    // then we should prefer that comment over any comment on the signature. The comment plugin
     // will copy the comment down if this signature doesn't have one, so don't set one.
+    let parentReflection = context.scope;
+    if (parentReflection.kindOf(models_1.ReflectionKind.TypeLiteral) &&
+        parentReflection.parent instanceof models_1.DeclarationReflection) {
+        parentReflection = parentReflection.parent;
+    }
     if (declaration &&
-        (!context.scope.comment ||
-            !(context.scope.conversionFlags & models_1.ConversionFlags.VariableSource))) {
+        (!parentReflection.comment ||
+            !(parentReflection.conversionFlags &
+                models_1.ConversionFlags.VariableOrPropertySource))) {
         sigRef.comment = (0, comments_1.getSignatureComment)(declaration, context.converter.config, context.logger, context.converter.commentStyle);
     }
     sigRef.typeParameters = convertTypeParameters(context, sigRef, signature.typeParameters);
@@ -36,7 +45,7 @@ function createSignature(context, kind, signature, declaration) {
         sigRef.type = new models_1.IntrinsicType("void");
     }
     else {
-        sigRef.type = context.converter.convertType(context.withScope(sigRef), (declaration?.kind === ts.SyntaxKind.FunctionDeclaration &&
+        sigRef.type = context.converter.convertType(context.withScope(sigRef), (declaration?.kind === typescript_1.default.SyntaxKind.FunctionDeclaration &&
             declaration.type) ||
             signature.getReturnType());
     }
@@ -60,11 +69,11 @@ exports.createSignature = createSignature;
 function convertParameters(context, sigRef, parameters, parameterNodes) {
     return parameters.map((param, i) => {
         const declaration = param.valueDeclaration;
-        assert(!declaration ||
-            ts.isParameter(declaration) ||
-            ts.isJSDocParameterTag(declaration));
+        (0, assert_1.default)(!declaration ||
+            typescript_1.default.isParameter(declaration) ||
+            typescript_1.default.isJSDocParameterTag(declaration));
         const paramRefl = new models_1.ParameterReflection(/__\d+/.test(param.name) ? "__namedParameters" : param.name, models_1.ReflectionKind.Parameter, sigRef);
-        if (declaration && ts.isJSDocParameterTag(declaration)) {
+        if (declaration && typescript_1.default.isJSDocParameterTag(declaration)) {
             paramRefl.comment = (0, comments_1.getJsDocComment)(declaration, context.converter.config, context.logger);
         }
         paramRefl.comment || (paramRefl.comment = (0, comments_1.getComment)(param, paramRefl.kind, context.converter.config, context.logger, context.converter.commentStyle));
@@ -80,9 +89,9 @@ function convertParameters(context, sigRef, parameters, parameterNodes) {
         paramRefl.type = context.converter.convertType(context.withScope(paramRefl), type);
         let isOptional = false;
         if (declaration) {
-            isOptional = ts.isParameter(declaration)
+            isOptional = typescript_1.default.isParameter(declaration)
                 ? !!declaration.questionToken ||
-                    ts
+                    typescript_1.default
                         .getJSDocParameterTags(declaration)
                         .some((tag) => tag.isBracketed)
                 : declaration.isBracketed;
@@ -96,10 +105,10 @@ function convertParameters(context, sigRef, parameters, parameterNodes) {
         // because the method body uses `arguments`... which is always a rest argument
         let isRest = true;
         if (declaration) {
-            isRest = ts.isParameter(declaration)
+            isRest = typescript_1.default.isParameter(declaration)
                 ? !!declaration.dotDotDotToken
                 : !!declaration.typeExpression &&
-                    ts.isJSDocVariadicType(declaration.typeExpression.type);
+                    typescript_1.default.isJSDocVariadicType(declaration.typeExpression.type);
         }
         paramRefl.setFlag(models_1.ReflectionFlag.Rest, isRest);
         return paramRefl;
@@ -110,13 +119,13 @@ function convertParameterNodes(context, sigRef, parameters) {
         const paramRefl = new models_1.ParameterReflection(/__\d+/.test(param.name.getText())
             ? "__namedParameters"
             : param.name.getText(), models_1.ReflectionKind.Parameter, sigRef);
-        if (ts.isJSDocParameterTag(param)) {
+        if (typescript_1.default.isJSDocParameterTag(param)) {
             paramRefl.comment = (0, comments_1.getJsDocComment)(param, context.converter.config, context.logger);
         }
         context.registerReflection(paramRefl, context.getSymbolAtLocation(param));
         context.trigger(converter_events_1.ConverterEvents.CREATE_PARAMETER, paramRefl);
-        paramRefl.type = context.converter.convertType(context.withScope(paramRefl), ts.isParameter(param) ? param.type : param.typeExpression?.type);
-        const isOptional = ts.isParameter(param)
+        paramRefl.type = context.converter.convertType(context.withScope(paramRefl), typescript_1.default.isParameter(param) ? param.type : param.typeExpression?.type);
+        const isOptional = typescript_1.default.isParameter(param)
             ? !!param.questionToken
             : param.isBracketed;
         if (isOptional) {
@@ -124,10 +133,10 @@ function convertParameterNodes(context, sigRef, parameters) {
         }
         paramRefl.defaultValue = (0, convert_expression_1.convertDefaultValue)(param);
         paramRefl.setFlag(models_1.ReflectionFlag.Optional, isOptional);
-        paramRefl.setFlag(models_1.ReflectionFlag.Rest, ts.isParameter(param)
+        paramRefl.setFlag(models_1.ReflectionFlag.Rest, typescript_1.default.isParameter(param)
             ? !!param.dotDotDotToken
             : !!param.typeExpression &&
-                ts.isJSDocVariadicType(param.typeExpression.type));
+                typescript_1.default.isJSDocVariadicType(param.typeExpression.type));
         return paramRefl;
     });
 }
@@ -144,7 +153,7 @@ function convertTypeParameters(context, parent, parameters) {
             : void 0;
         // There's no way to determine directly from a ts.TypeParameter what it's variance modifiers are
         // so unfortunately we have to go back to the node for this...
-        const variance = getVariance(param.getSymbol()?.declarations?.find(ts.isTypeParameterDeclaration)
+        const variance = getVariance(param.getSymbol()?.declarations?.find(typescript_1.default.isTypeParameterDeclaration)
             ?.modifiers);
         const paramRefl = new models_1.TypeParameterReflection(param.symbol.name, constraint, defaultType, parent, variance);
         context.registerReflection(paramRefl, param.getSymbol());
@@ -165,7 +174,7 @@ function createTypeParamReflection(param, context) {
         : void 0;
     const paramRefl = new models_1.TypeParameterReflection(param.name.text, constraint, defaultType, context.scope, getVariance(param.modifiers));
     context.registerReflection(paramRefl, param.symbol);
-    if (ts.isJSDocTemplateTag(param.parent)) {
+    if (typescript_1.default.isJSDocTemplateTag(param.parent)) {
         paramRefl.comment = (0, comments_1.getJsDocComment)(param.parent, context.converter.config, context.logger);
     }
     context.trigger(converter_events_1.ConverterEvents.CREATE_TYPE_PARAMETER, paramRefl, param);
@@ -173,8 +182,8 @@ function createTypeParamReflection(param, context) {
 }
 exports.createTypeParamReflection = createTypeParamReflection;
 function getVariance(modifiers) {
-    const hasIn = modifiers?.some((mod) => mod.kind === ts.SyntaxKind.InKeyword);
-    const hasOut = modifiers?.some((mod) => mod.kind === ts.SyntaxKind.OutKeyword);
+    const hasIn = modifiers?.some((mod) => mod.kind === typescript_1.default.SyntaxKind.InKeyword);
+    const hasOut = modifiers?.some((mod) => mod.kind === typescript_1.default.SyntaxKind.OutKeyword);
     if (hasIn && hasOut) {
         return models_1.VarianceModifier.inOut;
     }
@@ -188,23 +197,23 @@ function getVariance(modifiers) {
 function convertPredicate(predicate, context) {
     let name;
     switch (predicate.kind) {
-        case ts.TypePredicateKind.This:
-        case ts.TypePredicateKind.AssertsThis:
+        case typescript_1.default.TypePredicateKind.This:
+        case typescript_1.default.TypePredicateKind.AssertsThis:
             name = "this";
             break;
-        case ts.TypePredicateKind.Identifier:
-        case ts.TypePredicateKind.AssertsIdentifier:
+        case typescript_1.default.TypePredicateKind.Identifier:
+        case typescript_1.default.TypePredicateKind.AssertsIdentifier:
             name = predicate.parameterName;
             break;
     }
     let asserts;
     switch (predicate.kind) {
-        case ts.TypePredicateKind.This:
-        case ts.TypePredicateKind.Identifier:
+        case typescript_1.default.TypePredicateKind.This:
+        case typescript_1.default.TypePredicateKind.Identifier:
             asserts = false;
             break;
-        case ts.TypePredicateKind.AssertsThis:
-        case ts.TypePredicateKind.AssertsIdentifier:
+        case typescript_1.default.TypePredicateKind.AssertsThis:
+        case typescript_1.default.TypePredicateKind.AssertsIdentifier:
             asserts = true;
             break;
     }

package/dist/lib/converter/jsdoc.d.ts

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import ts from "typescript";
 import type { Context } from "./context";
 export declare function convertJsDocAlias(context: Context, symbol: ts.Symbol, declaration: ts.JSDocTypedefTag | ts.JSDocEnumTag, exportSymbol?: ts.Symbol): void;
 export declare function convertJsDocCallback(context: Context, symbol: ts.Symbol, declaration: ts.JSDocCallbackTag, exportSymbol?: ts.Symbol): void;

package/dist/lib/converter/jsdoc.js

@@ -2,17 +2,20 @@
 // Converter functions for JSDoc defined types
 // @typedef
 // @callback
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertJsDocCallback = exports.convertJsDocAlias = void 0;
 const assert_1 = require("assert");
-const ts = require("typescript");
+const typescript_1 = __importDefault(require("typescript"));
 const models_1 = require("../models");
 const comments_1 = require("./comments");
 const converter_events_1 = require("./converter-events");
 const signature_1 = require("./factories/signature");
 function convertJsDocAlias(context, symbol, declaration, exportSymbol) {
     if (declaration.typeExpression &&
-        ts.isJSDocTypeLiteral(declaration.typeExpression)) {
+        typescript_1.default.isJSDocTypeLiteral(declaration.typeExpression)) {
         convertJsDocInterface(context, declaration, symbol, exportSymbol);
         return;
     }
@@ -71,7 +74,7 @@ function convertJsDocSignature(context, node) {
 }
 function convertTemplateParameters(context, node) {
     (0, assert_1.ok)(context.scope instanceof models_1.DeclarationReflection);
-    context.scope.typeParameters = convertTemplateParameterNodes(context, node.tags?.filter(ts.isJSDocTemplateTag));
+    context.scope.typeParameters = convertTemplateParameterNodes(context, node.tags?.filter(typescript_1.default.isJSDocTemplateTag));
 }
 function convertTemplateParameterNodes(context, nodes) {
     const params = (nodes ?? []).flatMap((tag) => tag.typeParameters);
@@ -79,31 +82,31 @@ function convertTemplateParameterNodes(context, nodes) {
 }
 function getTypedefReExportTarget(context, declaration) {
     const typeExpression = declaration.typeExpression;
-    if (!ts.isJSDocTypedefTag(declaration) ||
+    if (!typescript_1.default.isJSDocTypedefTag(declaration) ||
         !typeExpression ||
-        ts.isJSDocTypeLiteral(typeExpression) ||
-        !ts.isImportTypeNode(typeExpression.type) ||
+        typescript_1.default.isJSDocTypeLiteral(typeExpression) ||
+        !typescript_1.default.isImportTypeNode(typeExpression.type) ||
         !typeExpression.type.qualifier ||
-        !ts.isIdentifier(typeExpression.type.qualifier)) {
+        !typescript_1.default.isIdentifier(typeExpression.type.qualifier)) {
         return;
     }
     const targetSymbol = context.expectSymbolAtLocation(typeExpression.type.qualifier);
     const decl = targetSymbol.declarations?.[0];
     if (!decl ||
-        !(ts.isTypeAliasDeclaration(decl) ||
-            ts.isInterfaceDeclaration(decl) ||
-            ts.isJSDocTypedefTag(decl) ||
-            ts.isJSDocCallbackTag(decl))) {
+        !(typescript_1.default.isTypeAliasDeclaration(decl) ||
+            typescript_1.default.isInterfaceDeclaration(decl) ||
+            typescript_1.default.isJSDocTypedefTag(decl) ||
+            typescript_1.default.isJSDocCallbackTag(decl))) {
         return;
     }
-    const targetParams = ts.getEffectiveTypeParameterDeclarations(decl);
-    const localParams = ts.getEffectiveTypeParameterDeclarations(declaration);
+    const targetParams = typescript_1.default.getEffectiveTypeParameterDeclarations(decl);
+    const localParams = typescript_1.default.getEffectiveTypeParameterDeclarations(declaration);
     const localArgs = typeExpression.type.typeArguments || [];
     // If we have type parameters, ensure they are forwarding parameters with no transformations.
     // This doesn't check constraints since they aren't checked in JSDoc types.
     if (targetParams.length !== localParams.length ||
-        localArgs.some((arg, i) => !ts.isTypeReferenceNode(arg) ||
-            !ts.isIdentifier(arg.typeName) ||
+        localArgs.some((arg, i) => !typescript_1.default.isTypeReferenceNode(arg) ||
+            !typescript_1.default.isIdentifier(arg.typeName) ||
             arg.typeArguments ||
             localParams[i]?.name.text !== arg.typeName.text)) {
         return;

package/dist/lib/converter/plugins/CommentPlugin.d.ts

@@ -61,6 +61,8 @@ export declare class CommentPlugin extends ConverterComponent {
     excludePrivate: boolean;
     excludeProtected: boolean;
     excludeNotDocumented: boolean;
+    private _excludeKinds;
+    private get excludeNotDocumentedKinds();
     /**
      * Create a new CommentPlugin instance.
      */

package/dist/lib/converter/plugins/CommentPlugin.js

@@ -89,6 +89,12 @@ const NEVER_RENDERED = [
  *
  */
 let CommentPlugin = class CommentPlugin extends components_1.ConverterComponent {
+    get excludeNotDocumentedKinds() {
+        this._excludeKinds ?? (this._excludeKinds = this.application.options
+            .getValue("excludeNotDocumentedKinds")
+            .reduce((a, b) => a | models_1.ReflectionKind[b], 0));
+        return this._excludeKinds;
+    }
     /**
      * Create a new CommentPlugin instance.
      */
@@ -99,6 +105,9 @@ let CommentPlugin = class CommentPlugin extends components_1.ConverterComponent
             [converter_1.Converter.EVENT_CREATE_TYPE_PARAMETER]: this.onCreateTypeParameter,
             [converter_1.Converter.EVENT_RESOLVE_BEGIN]: this.onBeginResolve,
             [converter_1.Converter.EVENT_RESOLVE]: this.onResolve,
+            [converter_1.Converter.EVENT_END]: () => {
+                this._excludeKinds = undefined;
+            },
         });
     }
     /**
@@ -335,12 +344,22 @@ let CommentPlugin = class CommentPlugin extends components_1.ConverterComponent
             return true;
         }
         if (!comment) {
+            // We haven't moved comments from the parent for signatures without a direct
+            // comment, so don't exclude those due to not being documented.
+            if (reflection.kindOf(models_1.ReflectionKind.CallSignature |
+                models_1.ReflectionKind.ConstructorSignature) &&
+                reflection.parent?.comment) {
+                return false;
+            }
             if (this.excludeNotDocumented) {
                 // Don't let excludeNotDocumented remove parameters.
                 if (!(reflection instanceof models_1.DeclarationReflection) &&
                     !(reflection instanceof models_1.SignatureReflection)) {
                     return false;
                 }
+                if (!reflection.kindOf(this.excludeNotDocumentedKinds)) {
+                    return false;
+                }
                 // excludeNotDocumented should hide a module only if it has no visible children
                 if (reflection.kindOf(models_1.ReflectionKind.SomeModule)) {
                     if (!reflection.children) {
@@ -348,10 +367,6 @@ let CommentPlugin = class CommentPlugin extends components_1.ConverterComponent
                     }
                     return reflection.children.every((child) => this.isHidden(child));
                 }
-                // enum members should all be included if the parent enum is documented
-                if (reflection.kind === models_1.ReflectionKind.EnumMember) {
-                    return false;
-                }
                 // signature containers should only be hidden if all their signatures are hidden
                 if (reflection.kindOf(models_1.ReflectionKind.SignatureContainer)) {
                     return reflection

package/dist/lib/converter/plugins/ImplementsPlugin.js

@@ -5,9 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImplementsPlugin = void 0;
-const ts = require("typescript");
+const typescript_1 = __importDefault(require("typescript"));
 const index_1 = require("../../models/reflections/index");
 const types_1 = require("../../models/types");
 const array_1 = require("../../utils/array");
@@ -150,7 +153,7 @@ let ImplementsPlugin = class ImplementsPlugin extends components_1.ConverterComp
         }
         const declaration = symbol
             .getDeclarations()
-            ?.find((n) => ts.isClassDeclaration(n) || ts.isInterfaceDeclaration(n));
+            ?.find((n) => typescript_1.default.isClassDeclaration(n) || typescript_1.default.isInterfaceDeclaration(n));
         if (!declaration) {
             return;
         }
@@ -171,7 +174,7 @@ let ImplementsPlugin = class ImplementsPlugin extends components_1.ConverterComp
             return;
         }
         if (reflection.kind === index_1.ReflectionKind.Constructor) {
-            const ctor = info.declaration.members.find(ts.isConstructorDeclaration);
+            const ctor = info.declaration.members.find(typescript_1.default.isConstructorDeclaration);
             constructorInheritance(context, reflection, info.declaration, ctor);
             return;
         }
@@ -188,7 +191,7 @@ let ImplementsPlugin = class ImplementsPlugin extends components_1.ConverterComp
         out: for (const clause of info.declaration.heritageClauses ?? []) {
             // No point checking implemented types for static members, they won't exist.
             if (reflection.flags.isStatic &&
-                clause.token === ts.SyntaxKind.ImplementsKeyword) {
+                clause.token === typescript_1.default.SyntaxKind.ImplementsKeyword) {
                 continue;
             }
             for (const expr of clause.types) {
@@ -202,7 +205,7 @@ let ImplementsPlugin = class ImplementsPlugin extends components_1.ConverterComp
                     createLink(context, reflection, clause, expr, parentProperty, isInherit);
                     // Can't always break because we need to also set `implementationOf` if we
                     // inherit from a base class and also implement an interface.
-                    if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+                    if (clause.token === typescript_1.default.SyntaxKind.ImplementsKeyword) {
                         break out;
                     }
                 }
@@ -215,7 +218,7 @@ ImplementsPlugin = __decorate([
 ], ImplementsPlugin);
 exports.ImplementsPlugin = ImplementsPlugin;
 function constructorInheritance(context, reflection, childDecl, constructorDecl) {
-    const extendsClause = childDecl.heritageClauses?.find((cl) => cl.token === ts.SyntaxKind.ExtendsKeyword);
+    const extendsClause = childDecl.heritageClauses?.find((cl) => cl.token === typescript_1.default.SyntaxKind.ExtendsKeyword);
     if (!extendsClause)
         return;
     const name = `${extendsClause.types[0].getText()}.constructor`;
@@ -247,7 +250,7 @@ function createLink(context, reflection, clause, expr, symbol, isOverwrite) {
     function link(target) {
         if (!target)
             return;
-        if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+        if (clause.token === typescript_1.default.SyntaxKind.ImplementsKeyword) {
             target.implementationOf ?? (target.implementationOf = types_1.ReferenceType.createBrokenReference(name, project));
             return;
         }

package/dist/lib/converter/plugins/PackagePlugin.js

@@ -1,14 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackagePlugin = void 0;
-const Path = require("path");
-const FS = require("fs");
+const Path = __importStar(require("path"));
+const FS = __importStar(require("fs"));
 const components_1 = require("../components");
 const converter_1 = require("../converter");
 const utils_1 = require("../../utils");