typedoc 0.28.15 → 0.28.17

package/dist/lib/converter/comments/declarationReferenceResolver.js

@@ -13,6 +13,9 @@ export function resolveDeclarationReference(reflection, ref) {
     if (ref.moduleSource) {
         high = reflection.project.children?.filter((c) => c.kindOf(ReflectionKind.SomeModule) &&
             c.name === ref.moduleSource) || [];
+        if (!high.length && reflection.project.packageName === ref.moduleSource) {
+            high.push(reflection.project);
+        }
     }
     else if (ref.resolutionStart === "global") {
         high.push(reflection.project);

package/dist/lib/converter/comments/discovery.js

@@ -23,6 +23,8 @@ const variablePropertyKinds = [
 // Comments from @typedef and @callback tags are handled specially by
 // the JSDoc converter because we only want part of the comment when
 // getting them.
+// This also does NOT include kinds which should be checked after the
+// first kind/kinds have been checked for a comment.
 const wantedKinds = {
     [ReflectionKind.Project]: [
         ts.SyntaxKind.SourceFile,
@@ -38,24 +40,12 @@ const wantedKinds = {
         ts.SyntaxKind.BindingElement,
         ts.SyntaxKind.ExportSpecifier,
         ts.SyntaxKind.NamespaceExport,
-        // @namespace support
-        ts.SyntaxKind.VariableDeclaration,
-        ts.SyntaxKind.BindingElement,
-        ts.SyntaxKind.ExportAssignment,
-        ts.SyntaxKind.PropertyAccessExpression,
-        ts.SyntaxKind.PropertyDeclaration,
-        ts.SyntaxKind.PropertyAssignment,
-        ts.SyntaxKind.ShorthandPropertyAssignment,
     ],
     [ReflectionKind.Enum]: [
         ts.SyntaxKind.EnumDeclaration,
-        ts.SyntaxKind.VariableDeclaration,
     ],
     [ReflectionKind.EnumMember]: [
         ts.SyntaxKind.EnumMember,
-        // These here so that @enum gets comments
-        ts.SyntaxKind.PropertyAssignment,
-        ts.SyntaxKind.PropertySignature,
     ],
     [ReflectionKind.Variable]: variablePropertyKinds,
     [ReflectionKind.Function]: [
@@ -71,15 +61,9 @@ const wantedKinds = {
     [ReflectionKind.Class]: [
         ts.SyntaxKind.ClassDeclaration,
         ts.SyntaxKind.BindingElement,
-        // If marked with @class
-        ts.SyntaxKind.VariableDeclaration,
-        ts.SyntaxKind.ExportAssignment,
-        ts.SyntaxKind.FunctionDeclaration,
     ],
     [ReflectionKind.Interface]: [
         ts.SyntaxKind.InterfaceDeclaration,
-        ts.SyntaxKind.TypeAliasDeclaration,
-        ts.SyntaxKind.ClassDeclaration, // type only exports
     ],
     [ReflectionKind.Constructor]: [ts.SyntaxKind.Constructor],
     [ReflectionKind.Property]: variablePropertyKinds,
@@ -106,9 +90,6 @@ const wantedKinds = {
     [ReflectionKind.SetSignature]: [ts.SyntaxKind.SetAccessor],
     [ReflectionKind.TypeAlias]: [
         ts.SyntaxKind.TypeAliasDeclaration,
-        ts.SyntaxKind.FunctionDeclaration, // type only exports
-        // Intentionally not included to avoid comments being copied for variable/alias combos
-        // ts.SyntaxKind.VariableDeclaration,
     ],
     [ReflectionKind.Reference]: [
         ts.SyntaxKind.NamespaceExport,
@@ -117,6 +98,72 @@ const wantedKinds = {
     // Non-TS kind, will never have comments.
     [ReflectionKind.Document]: [],
 };
+// These kinds are checked after wantedKinds if wantedKinds doesn't result in
+// discovering a comment. This is a rather unfortunate tradeoff between discovering
+// comments for values in unusual circumstances (#2970) and avoiding duplicate
+// comments being discovered for declaration merging nastiness (#3064)
+const backupWantedKinds = {
+    [ReflectionKind.Project]: [],
+    [ReflectionKind.Module]: [],
+    [ReflectionKind.Namespace]: [
+        // @namespace support
+        ts.SyntaxKind.VariableDeclaration,
+        ts.SyntaxKind.BindingElement,
+        ts.SyntaxKind.ExportAssignment,
+        ts.SyntaxKind.PropertyAccessExpression,
+        ts.SyntaxKind.PropertyDeclaration,
+        ts.SyntaxKind.PropertyAssignment,
+        ts.SyntaxKind.ShorthandPropertyAssignment,
+    ],
+    [ReflectionKind.Enum]: [
+        ts.SyntaxKind.VariableDeclaration,
+    ],
+    [ReflectionKind.EnumMember]: [
+        // These here so that @enum gets comments
+        ts.SyntaxKind.PropertyAssignment,
+        ts.SyntaxKind.PropertySignature,
+    ],
+    [ReflectionKind.Variable]: [],
+    [ReflectionKind.Function]: [
+        ts.SyntaxKind.FunctionDeclaration,
+        ts.SyntaxKind.BindingElement,
+        ts.SyntaxKind.VariableDeclaration,
+        ts.SyntaxKind.ExportAssignment,
+        ts.SyntaxKind.PropertyAccessExpression,
+        ts.SyntaxKind.PropertyDeclaration,
+        ts.SyntaxKind.PropertyAssignment,
+        ts.SyntaxKind.ShorthandPropertyAssignment,
+    ],
+    [ReflectionKind.Class]: [
+        // If marked with @class
+        ts.SyntaxKind.VariableDeclaration,
+        ts.SyntaxKind.ExportAssignment,
+        ts.SyntaxKind.FunctionDeclaration,
+    ],
+    [ReflectionKind.Interface]: [
+        ts.SyntaxKind.TypeAliasDeclaration,
+        ts.SyntaxKind.ClassDeclaration, // type only exports
+    ],
+    [ReflectionKind.Constructor]: [],
+    [ReflectionKind.Property]: [],
+    [ReflectionKind.Method]: [],
+    [ReflectionKind.CallSignature]: [],
+    [ReflectionKind.IndexSignature]: [],
+    [ReflectionKind.ConstructorSignature]: [],
+    [ReflectionKind.Parameter]: [],
+    [ReflectionKind.TypeLiteral]: [],
+    [ReflectionKind.TypeParameter]: [],
+    [ReflectionKind.Accessor]: [],
+    [ReflectionKind.GetSignature]: [],
+    [ReflectionKind.SetSignature]: [],
+    [ReflectionKind.TypeAlias]: [
+        ts.SyntaxKind.FunctionDeclaration, // type only exports
+        ts.SyntaxKind.VariableDeclaration, // type only exports
+    ],
+    [ReflectionKind.Reference]: [],
+    // Non-TS kind, will never have comments.
+    [ReflectionKind.Document]: [],
+};
 export function discoverFileComments(node, commentStyle) {
     const text = node.text;
     const comments = collectCommentRanges(ts.getLeadingCommentRanges(text, node.pos));
@@ -165,10 +212,20 @@ function checkCommentDeclarations(commentNodes, reverse, commentStyle) {
     return discovered;
 }
 export function discoverComment(symbol, kind, logger, commentStyle, checker, declarationWarnings) {
+    const discovered = discoverCommentWorker(symbol, kind, logger, commentStyle, checker, declarationWarnings, wantedKinds[kind]);
+    if (discovered) {
+        return discovered;
+    }
+    return discoverCommentWorker(symbol, kind, logger, commentStyle, checker, declarationWarnings, backupWantedKinds[kind]);
+}
+function discoverCommentWorker(symbol, kind, logger, commentStyle, checker, declarationWarnings, wanted) {
+    if (wanted.length === 0) {
+        return;
+    }
     // For a module comment, we want the first one defined in the file,
     // not the last one, since that will apply to the import or declaration.
     const reverse = !symbol.declarations?.some(ts.isSourceFile);
-    const wantedDeclarations = filter(symbol.declarations, (decl) => wantedKinds[kind].includes(decl.kind));
+    const wantedDeclarations = filter(symbol.declarations, (decl) => wanted.includes(decl.kind));
     const commentNodes = wantedDeclarations.flatMap((decl) => declarationToCommentNodes(decl, checker));
     // Special behavior here!
     // Signatures and symbols have two distinct discovery methods as of TypeDoc 0.26.

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

@@ -2,7 +2,7 @@ import ts from "typescript";
 import { Comment, ReflectionKind } from "../../models/index.js";
 import type { CommentStyle, JsDocCompatibility, ValidationOptions } from "../../utils/options/declaration.js";
 import type { FileRegistry } from "../../models/FileRegistry.js";
-import { type Logger } from "#utils";
+import { Logger } from "#utils";
 import type { Context } from "../context.js";
 export interface CommentParserConfig {
     blockTags: Set<string>;

package/dist/lib/converter/comments/index.js

@@ -4,7 +4,7 @@ import { lexBlockComment } from "./blockLexer.js";
 import { discoverComment, discoverFileComments, discoverNodeComment, discoverSignatureComment, } from "./discovery.js";
 import { lexLineComments } from "./lineLexer.js";
 import { parseComment } from "./parser.js";
-import { assertNever, i18n } from "#utils";
+import { assertNever, i18n, Logger, setUnion } from "#utils";
 const jsDocCommentKinds = [
     ts.SyntaxKind.JSDocPropertyTag,
     ts.SyntaxKind.JSDocCallbackTag,
@@ -21,16 +21,10 @@ export function clearCommentCache() {
     commentCache = new WeakMap();
     commentDiscoveryId = 0;
 }
-function getCommentWithCache(discovered, context) {
+function getCommentIgnoringCacheNoDiscoveryId(discovered, context) {
     if (!discovered)
         return;
     const { file, ranges, jsDoc } = discovered;
-    const cache = commentCache.get(file) || new Map();
-    if (cache.has(ranges[0].pos)) {
-        const clone = cache.get(ranges[0].pos).clone();
-        clone.inheritedFromParentDeclaration = discovered.inheritedFromParentDeclaration;
-        return clone;
-    }
     let comment;
     switch (ranges[0].kind) {
         case ts.SyntaxKind.MultiLineCommentTrivia:
@@ -42,8 +36,23 @@ function getCommentWithCache(discovered, context) {
         default:
             assertNever(ranges[0].kind);
     }
-    comment.discoveryId = ++commentDiscoveryId;
     comment.inheritedFromParentDeclaration = discovered.inheritedFromParentDeclaration;
+    return comment;
+}
+function getCommentWithCache(discovered, context) {
+    if (!discovered)
+        return;
+    const { file, ranges } = discovered;
+    const cache = commentCache.get(file) || new Map();
+    if (cache.has(ranges[0].pos)) {
+        const clone = cache.get(ranges[0].pos).clone();
+        clone.inheritedFromParentDeclaration = discovered.inheritedFromParentDeclaration;
+        return clone;
+    }
+    const comment = getCommentIgnoringCacheNoDiscoveryId(discovered, context);
+    if (!comment)
+        return;
+    comment.discoveryId = ++commentDiscoveryId;
     cache.set(ranges[0].pos, comment);
     commentCache.set(file, cache);
     return comment.clone();
@@ -99,14 +108,24 @@ export function getNodeComment(node, moduleComment, context) {
     return getCommentImpl(discoverNodeComment(node, context.config.commentStyle), moduleComment, context);
 }
 export function getFileComment(file, context) {
+    const quietContext = {
+        ...context,
+        logger: new Logger(),
+    };
     for (const commentSource of discoverFileComments(file, context.config.commentStyle)) {
-        const comment = getCommentWithCache(commentSource, context);
+        // First parse the comment without adding the parse to the cache
+        // and without logging any messages. If we end up not using this as
+        // a file comment we want to avoid parsing it with warnings here as
+        // it might be associated with a JSDoc parse which has special
+        // handling to allow modifier tags to be specified as {@mod}
+        // and if it gets added to the cache here we'll get unwanted warnings
+        const comment = getCommentIgnoringCacheNoDiscoveryId(commentSource, quietContext);
         if (comment?.getTag("@license") || comment?.getTag("@import")) {
             continue;
         }
         if (comment?.getTag("@module") ||
             comment?.hasModifier("@packageDocumentation")) {
-            return comment;
+            return getCommentWithCache(commentSource, context);
         }
         return;
     }
@@ -127,6 +146,33 @@ function getConstructorParamPropertyComment(symbol, context) {
 export function getSignatureComment(declaration, context) {
     return getCommentImpl(discoverSignatureComment(declaration, context.checker, context.config.commentStyle), false, context);
 }
+function buildJsDocCommentFromParts(declaration, parts, sourceComment, context) {
+    if (!parts) {
+        return undefined;
+    }
+    const comment = new Comment(Comment.cloneDisplayParts(parts));
+    comment.sourcePath = sourceComment.sourcePath;
+    for (let i = 0; i < comment.summary.length;) {
+        const part = comment.summary[i];
+        if (part.kind === "inline-tag" &&
+            !part.text.trim() &&
+            context.config.modifierTags.has(part.tag)) {
+            comment.modifierTags.add(part.tag);
+            comment.summary.splice(i, 1);
+        }
+        else if (part.kind === "inline-tag" &&
+            part.text.trim() &&
+            context.config.modifierTags.has(part.tag) &&
+            !context.config.inlineTags.has(part.tag)) {
+            context.logger.warn(i18n.inline_tag_0_not_parsed_as_modifier_tag_1(part.tag, part.text.trim()), declaration);
+            ++i;
+        }
+        else {
+            ++i;
+        }
+    }
+    return comment;
+}
 export function getJsDocComment(declaration, context) {
     const file = declaration.getSourceFile();
     // First, get the whole comment. We know we'll need all of it.
@@ -134,6 +180,15 @@ export function getJsDocComment(declaration, context) {
     while (!ts.isJSDoc(parent)) {
         parent = parent.parent;
     }
+    // Build a custom context to allow modifier tags to be written as inline
+    // tags as otherwise there's no way to specify them here #2916 #3050
+    const contextWithInline = {
+        ...context,
+        config: {
+            ...context.config,
+            inlineTags: setUnion(context.config.inlineTags, context.config.modifierTags),
+        },
+    };
     // Then parse it.
     const comment = getCommentWithCache({
         file,
@@ -146,12 +201,10 @@ export function getJsDocComment(declaration, context) {
         ],
         jsDoc: parent,
         inheritedFromParentDeclaration: false,
-    }, context);
+    }, contextWithInline);
     // And pull out the tag we actually care about.
     if (ts.isJSDocEnumTag(declaration)) {
-        const result = new Comment(comment.getTag("@enum")?.content);
-        result.sourcePath = comment.sourcePath;
-        return result;
+        return buildJsDocCommentFromParts(declaration, comment.getTag("@enum")?.content, comment, context);
     }
     if (ts.isJSDocTemplateTag(declaration) &&
         declaration.comment &&
@@ -183,8 +236,6 @@ export function getJsDocComment(declaration, context) {
         }
     }
     else {
-        const result = new Comment(Comment.cloneDisplayParts(tag.content));
-        result.sourcePath = comment.sourcePath;
-        return result;
+        return buildJsDocCommentFromParts(declaration, tag.content, comment, context);
     }
 }

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

@@ -1,6 +1,7 @@
 import ts from "typescript";
 import { ParameterReflection, type Reflection, ReflectionKind, SignatureReflection, TypeParameterReflection } from "../../models/index.js";
 import type { Context } from "../context.js";
+export declare function convertConstructSignatures(context: Context, symbol: ts.Symbol): void;
 export declare function createSignature(context: Context, kind: ReflectionKind.CallSignature | ReflectionKind.ConstructorSignature | ReflectionKind.GetSignature | ReflectionKind.SetSignature, signature: ts.Signature, symbol: ts.Symbol | undefined, declaration?: ts.SignatureDeclaration | ts.JSDocSignature): void;
 /**
  * Special cased constructor factory for functions tagged with `@class`

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

@@ -4,6 +4,19 @@ import { DeclarationReflection, IntrinsicType, ParameterReflection, PredicateTyp
 import { ConverterEvents } from "../converter-events.js";
 import { convertDefaultValue } from "../convert-expression.js";
 import { removeUndefined } from "../utils/reflections.js";
+export function convertConstructSignatures(context, symbol) {
+    const type = context.checker.getDeclaredTypeOfSymbol(symbol);
+    // These get added as a "constructor" member of this interface. This is a problem... but nobody
+    // has complained yet. We really ought to have a constructSignatures property on the reflection instead.
+    const constructSignatures = context.checker.getSignaturesOfType(type, ts.SignatureKind.Construct);
+    if (constructSignatures.length) {
+        const constructMember = new DeclarationReflection("constructor", ReflectionKind.Constructor, context.scope);
+        context.postReflectionCreation(constructMember, symbol, void 0);
+        context.finalizeDeclarationReflection(constructMember);
+        const constructContext = context.withScope(constructMember);
+        constructSignatures.forEach((sig) => createSignature(constructContext, ReflectionKind.ConstructorSignature, sig, symbol));
+    }
+}
 export function createSignature(context, kind, signature, symbol, declaration) {
     assert(context.scope instanceof DeclarationReflection);
     declaration ||= signature.getDeclaration();

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

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

package/dist/lib/converter/jsdoc.js

@@ -5,13 +5,44 @@ import { ok } from "assert";
 import ts from "typescript";
 import { DeclarationReflection, IntrinsicType, ReflectionKind, ReflectionType, SignatureReflection, } from "../models/index.js";
 import { ConverterEvents } from "./converter-events.js";
-import { convertParameterNodes, convertTemplateParameterNodes } from "./factories/signature.js";
+import { convertConstructSignatures, convertParameterNodes, convertTemplateParameterNodes, createSignature, } from "./factories/signature.js";
+import { i18n } from "#utils";
+import { convertIndexSignatures } from "./factories/index-signature.js";
+// This is almost convertTypeAliasAsInterface, but unfortunately needs to be separate
+// due to type parameters being different in JSDoc comments
+function convertJsDocAliasAsInterface(context, symbol, exportSymbol, declaration) {
+    const reflection = context.createDeclarationReflection(ReflectionKind.Interface, symbol, exportSymbol);
+    context.finalizeDeclarationReflection(reflection);
+    const rc = context.withScope(reflection);
+    const type = context.checker.getTypeAtLocation(declaration);
+    if (type.getFlags() & ts.TypeFlags.Union) {
+        context.logger.warn(i18n.converting_union_as_interface(), declaration);
+    }
+    // Interfaces have properties
+    for (const prop of type.getProperties()) {
+        context.converter.convertSymbol(rc, prop);
+    }
+    // And type parameters
+    convertTemplateParameters(rc, declaration.parent);
+    // And maybe call signatures
+    context.checker
+        .getSignaturesOfType(type, ts.SignatureKind.Call)
+        .forEach((sig) => createSignature(rc, ReflectionKind.CallSignature, sig, symbol));
+    // And maybe constructor signatures
+    convertConstructSignatures(rc, symbol);
+    // And finally, index signatures
+    convertIndexSignatures(rc, type);
+}
 export function convertJsDocAlias(context, symbol, declaration, exportSymbol) {
     if (declaration.typeExpression &&
         ts.isJSDocTypeLiteral(declaration.typeExpression)) {
         convertJsDocInterface(context, declaration, symbol, exportSymbol);
         return;
     }
+    const comment = context.getJsDocComment(declaration);
+    if (comment?.hasModifier("@interface")) {
+        return convertJsDocAliasAsInterface(context, symbol, exportSymbol, declaration);
+    }
     // If the typedef tag is just referring to another type-space symbol, with no type parameters
     // or appropriate forwarding type parameters, then we treat it as a re-export instead of creating
     // a type alias with an import type.
@@ -21,7 +52,7 @@ export function convertJsDocAlias(context, symbol, declaration, exportSymbol) {
         return;
     }
     const reflection = context.createDeclarationReflection(ReflectionKind.TypeAlias, symbol, exportSymbol);
-    reflection.comment = context.getJsDocComment(declaration);
+    reflection.comment = comment;
     reflection.type = context.converter.convertType(context.withScope(reflection), declaration.typeExpression?.type);
     convertTemplateParameters(context.withScope(reflection), declaration.parent);
     context.finalizeDeclarationReflection(reflection);

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

@@ -66,6 +66,7 @@ export declare class CommentPlugin extends ConverterComponent {
     accessor excludeNotDocumented: boolean;
     accessor excludeCategories: string[];
     accessor defaultCategory: string;
+    accessor suppressCommentWarningsInDeclarationFiles: boolean;
     private _excludeKinds;
     private get excludeNotDocumentedKinds();
     constructor(owner: Converter);
@@ -123,4 +124,5 @@ export declare class CommentPlugin extends ConverterComponent {
     private isHidden;
     private excludedByCategory;
     private validateParamTags;
+    private suppressCommentWarnings;
 }

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

@@ -154,6 +154,9 @@ let CommentPlugin = (() => {
     let _defaultCategory_decorators;
     let _defaultCategory_initializers = [];
     let _defaultCategory_extraInitializers = [];
+    let _suppressCommentWarningsInDeclarationFiles_decorators;
+    let _suppressCommentWarningsInDeclarationFiles_initializers = [];
+    let _suppressCommentWarningsInDeclarationFiles_extraInitializers = [];
     return class CommentPlugin extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -166,6 +169,7 @@ let CommentPlugin = (() => {
             _excludeNotDocumented_decorators = [Option("excludeNotDocumented")];
             _excludeCategories_decorators = [Option("excludeCategories")];
             _defaultCategory_decorators = [Option("defaultCategory")];
+            _suppressCommentWarningsInDeclarationFiles_decorators = [Option("suppressCommentWarningsInDeclarationFiles")];
             __esDecorate(this, null, _excludeTags_decorators, { kind: "accessor", name: "excludeTags", static: false, private: false, access: { has: obj => "excludeTags" in obj, get: obj => obj.excludeTags, set: (obj, value) => { obj.excludeTags = value; } }, metadata: _metadata }, _excludeTags_initializers, _excludeTags_extraInitializers);
             __esDecorate(this, null, _cascadedModifierTags_decorators, { kind: "accessor", name: "cascadedModifierTags", static: false, private: false, access: { has: obj => "cascadedModifierTags" in obj, get: obj => obj.cascadedModifierTags, set: (obj, value) => { obj.cascadedModifierTags = value; } }, metadata: _metadata }, _cascadedModifierTags_initializers, _cascadedModifierTags_extraInitializers);
             __esDecorate(this, null, _excludeInternal_decorators, { kind: "accessor", name: "excludeInternal", static: false, private: false, access: { has: obj => "excludeInternal" in obj, get: obj => obj.excludeInternal, set: (obj, value) => { obj.excludeInternal = value; } }, metadata: _metadata }, _excludeInternal_initializers, _excludeInternal_extraInitializers);
@@ -175,6 +179,7 @@ let CommentPlugin = (() => {
             __esDecorate(this, null, _excludeNotDocumented_decorators, { kind: "accessor", name: "excludeNotDocumented", static: false, private: false, access: { has: obj => "excludeNotDocumented" in obj, get: obj => obj.excludeNotDocumented, set: (obj, value) => { obj.excludeNotDocumented = value; } }, metadata: _metadata }, _excludeNotDocumented_initializers, _excludeNotDocumented_extraInitializers);
             __esDecorate(this, null, _excludeCategories_decorators, { kind: "accessor", name: "excludeCategories", static: false, private: false, access: { has: obj => "excludeCategories" in obj, get: obj => obj.excludeCategories, set: (obj, value) => { obj.excludeCategories = value; } }, metadata: _metadata }, _excludeCategories_initializers, _excludeCategories_extraInitializers);
             __esDecorate(this, null, _defaultCategory_decorators, { kind: "accessor", name: "defaultCategory", static: false, private: false, access: { has: obj => "defaultCategory" in obj, get: obj => obj.defaultCategory, set: (obj, value) => { obj.defaultCategory = value; } }, metadata: _metadata }, _defaultCategory_initializers, _defaultCategory_extraInitializers);
+            __esDecorate(this, null, _suppressCommentWarningsInDeclarationFiles_decorators, { kind: "accessor", name: "suppressCommentWarningsInDeclarationFiles", static: false, private: false, access: { has: obj => "suppressCommentWarningsInDeclarationFiles" in obj, get: obj => obj.suppressCommentWarningsInDeclarationFiles, set: (obj, value) => { obj.suppressCommentWarningsInDeclarationFiles = value; } }, metadata: _metadata }, _suppressCommentWarningsInDeclarationFiles_initializers, _suppressCommentWarningsInDeclarationFiles_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         #excludeTags_accessor_storage = __runInitializers(this, _excludeTags_initializers, void 0);
@@ -204,7 +209,10 @@ let CommentPlugin = (() => {
         #defaultCategory_accessor_storage = (__runInitializers(this, _excludeCategories_extraInitializers), __runInitializers(this, _defaultCategory_initializers, void 0));
         get defaultCategory() { return this.#defaultCategory_accessor_storage; }
         set defaultCategory(value) { this.#defaultCategory_accessor_storage = value; }
-        _excludeKinds = __runInitializers(this, _defaultCategory_extraInitializers);
+        #suppressCommentWarningsInDeclarationFiles_accessor_storage = (__runInitializers(this, _defaultCategory_extraInitializers), __runInitializers(this, _suppressCommentWarningsInDeclarationFiles_initializers, void 0));
+        get suppressCommentWarningsInDeclarationFiles() { return this.#suppressCommentWarningsInDeclarationFiles_accessor_storage; }
+        set suppressCommentWarningsInDeclarationFiles(value) { this.#suppressCommentWarningsInDeclarationFiles_accessor_storage = value; }
+        _excludeKinds = __runInitializers(this, _suppressCommentWarningsInDeclarationFiles_extraInitializers);
         get excludeNotDocumentedKinds() {
             this._excludeKinds ??= this.application.options
                 .getValue("excludeNotDocumentedKinds")
@@ -407,12 +415,13 @@ let CommentPlugin = (() => {
         onResolve(context, reflection) {
             if (reflection.comment) {
                 if (reflection.comment.label &&
-                    !/[A-Z_][A-Z0-9_]/.test(reflection.comment.label)) {
+                    !/[A-Z_][A-Z0-9_]/.test(reflection.comment.label) &&
+                    !this.suppressCommentWarnings(reflection.comment)) {
                     context.logger.warn(i18n.label_0_for_1_cannot_be_referenced(reflection.comment.label, reflection.getFriendlyFullName()));
                 }
                 for (const group of MUTUALLY_EXCLUSIVE_MODIFIERS) {
                     const intersect = setIntersection(group, reflection.comment.modifierTags);
-                    if (intersect.size > 1) {
+                    if (intersect.size > 1 && !this.suppressCommentWarnings(reflection.comment)) {
                         const [a, b] = intersect;
                         context.logger.warn(i18n.modifier_tag_0_is_mutually_exclusive_with_1_in_comment_for_2(a, b, reflection.getFriendlyFullName()));
                     }
@@ -637,12 +646,16 @@ let CommentPlugin = (() => {
             const paramTags = comment.blockTags.filter((tag) => tag.tag === "@param");
             removeIf(paramTags, (tag) => params.some((param) => param.name === tag.name));
             moveNestedParamTags(/* in-out */ paramTags, params, comment.sourcePath);
-            if (!comment.inheritedFromParentDeclaration) {
+            if (!comment.inheritedFromParentDeclaration && !this.suppressCommentWarnings(comment)) {
                 for (const tag of paramTags) {
                     this.application.logger.warn(i18n.signature_0_has_unused_param_with_name_1(signature.getFriendlyFullName(), tag.name ?? "(missing)"));
                 }
             }
         }
+        suppressCommentWarnings(comment) {
+            return this.suppressCommentWarningsInDeclarationFiles &&
+                /\.d\.(ts|mts|cts)$/.test(comment.sourcePath || "");
+        }
     };
 })();
 export { CommentPlugin };

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

@@ -14,6 +14,7 @@ export declare class ImplementsPlugin extends ConverterComponent {
      */
     private analyzeImplements;
     private analyzeInheritance;
+    private cleanUpImplements;
     private onResolveEnd;
     private onRevive;
     private resolve;

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

@@ -95,10 +95,6 @@ export class ImplementsPlugin extends ConverterComponent {
         // serialization/deserialization, might point to an unexpected location. (See the mixin
         // converter tests, I suspect this might actually be an indication of something else slightly
         // broken there, but don't want to spend more time with this right now.)
-        // #2982/#3007, even more unfortunately, we only want to keep the link if it is pointing
-        // to a reflection which will receive a link during rendering, we pick this based on it being
-        // the type of member we expect to point to.
-        const isValidRef = (ref) => !!ref.reflection?.parent?.kindOf(ReflectionKind.ClassOrInterface | ReflectionKind.Method | ReflectionKind.Constructor);
         for (const child of reflection.children || []) {
             if (child.inheritedFrom && !isValidRef(child.inheritedFrom)) {
                 child.inheritedFrom = ReferenceType.createBrokenReference(child.inheritedFrom.name, project, child.inheritedFrom.package);
@@ -116,6 +112,19 @@ export class ImplementsPlugin extends ConverterComponent {
             }
         }
     }
+    cleanUpImplements(project, reflection) {
+        // #3052, the same problem as #2978 applies for implements
+        for (const child of reflection.children || []) {
+            if (child.implementationOf && !isValidRef(child.implementationOf)) {
+                child.implementationOf = ReferenceType.createBrokenReference(child.implementationOf.name, project, child.implementationOf.package);
+            }
+            for (const childSig of child.getAllSignatures()) {
+                if (childSig.implementationOf && !isValidRef(childSig.implementationOf)) {
+                    childSig.implementationOf = ReferenceType.createBrokenReference(childSig.implementationOf.name, project, childSig.implementationOf.package);
+                }
+            }
+        }
+    }
     onResolveEnd(context) {
         this.resolve(context.project);
     }
@@ -184,6 +193,10 @@ export class ImplementsPlugin extends ConverterComponent {
             reflection.extendedTypes) {
             this.analyzeInheritance(project, reflection);
         }
+        if (reflection.kindOf(ReflectionKind.ClassOrInterface) &&
+            (reflection.extendedTypes || reflection.implementedTypes)) {
+            this.cleanUpImplements(project, reflection);
+        }
     }
     getExtensionInfo(context, reflection) {
         if (!reflection || !reflection.kindOf(ReflectionKind.Inheritable)) {
@@ -417,3 +430,9 @@ function findMatchingMember(toMatch, container) {
     return container.children?.find((child) => child.name == toMatch.name &&
         child.flags.isStatic === toMatch.flags.isStatic);
 }
+// #2982/#3007 unfortunately, we only want to keep the link if it is pointing
+// to a reflection which will receive a link during rendering, we pick this based on it being
+// the type of member we expect to point to.
+function isValidRef(ref) {
+    return !!ref.reflection?.parent?.kindOf(ReflectionKind.ClassOrInterface | ReflectionKind.Method | ReflectionKind.Constructor);
+}

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

@@ -246,5 +246,9 @@ regionTagREsByExt["php"] = regionTagREsByExt["cs"];
 regionTagREsByExt["ps1"] = regionTagREsByExt["cs"];
 regionTagREsByExt["py"] = regionTagREsByExt["cs"];
 regionTagREsByExt["js"] = regionTagREsByExt["ts"];
+regionTagREsByExt["mjs"] = regionTagREsByExt["ts"];
 regionTagREsByExt["mts"] = regionTagREsByExt["ts"];
+regionTagREsByExt["cjs"] = regionTagREsByExt["ts"];
 regionTagREsByExt["cts"] = regionTagREsByExt["ts"];
+regionTagREsByExt["jsx"] = regionTagREsByExt["ts"];
+regionTagREsByExt["tsx"] = regionTagREsByExt["ts"];

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

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import ts from "typescript";
-import { DeclarationReflection, SignatureReflection } from "../../models/index.js";
+import { DeclarationReflection, ReflectionKind, SignatureReflection } from "../../models/index.js";
 import { ConverterComponent } from "../components.js";
 import { getCommonDirectory, normalizePath, Option } from "../../utils/index.js";
 import { isNamedNode } from "../utils/nodes.js";
@@ -120,7 +120,7 @@ let SourcePlugin = (() => {
          * @param reflection  The reflection that is currently processed.
          */
         onDeclaration(context, reflection) {
-            if (this.disableSources)
+            if (this.disableSources || reflection.kindOf(ReflectionKind.TypeLiteral))
                 return;
             const symbol = context.getSymbolFromReflection(reflection);
             for (const node of symbol?.declarations || []) {
@@ -139,7 +139,7 @@ let SourcePlugin = (() => {
             }
         }
         onSignature(_context, reflection, sig) {
-            if (this.disableSources || !sig)
+            if (this.disableSources || !sig || reflection.parent.kindOf(ReflectionKind.TypeLiteral))
                 return;
             const sourceFile = sig.getSourceFile();
             const fileName = normalizePath(sourceFile.fileName);

package/dist/lib/converter/symbols.js

@@ -4,7 +4,7 @@ import { DeclarationReflection, IntrinsicType, LiteralType, ReferenceReflection,
 import { getEnumFlags, hasAllFlags, hasAnyFlag, i18n, removeFlag } from "#utils";
 import { convertDefaultValue } from "./convert-expression.js";
 import { convertIndexSignatures } from "./factories/index-signature.js";
-import { convertTypeParameters, createConstructSignatureWithType, createSignature, createTypeParamReflection, } from "./factories/signature.js";
+import { convertConstructSignatures, convertTypeParameters, createConstructSignatureWithType, createSignature, createTypeParamReflection, } from "./factories/signature.js";
 import { convertJsDocAlias, convertJsDocCallback } from "./jsdoc.js";
 import { getHeritageTypes } from "./utils/nodes.js";
 import { removeUndefined } from "./utils/reflections.js";
@@ -522,19 +522,6 @@ function convertConstructor(context, symbol) {
         createSignature(reflectionContext, ReflectionKind.ConstructorSignature, sig, symbol);
     }
 }
-function convertConstructSignatures(context, symbol) {
-    const type = context.checker.getDeclaredTypeOfSymbol(symbol);
-    // These get added as a "constructor" member of this interface. This is a problem... but nobody
-    // has complained yet. We really ought to have a constructSignatures property on the reflection instead.
-    const constructSignatures = context.checker.getSignaturesOfType(type, ts.SignatureKind.Construct);
-    if (constructSignatures.length) {
-        const constructMember = new DeclarationReflection("constructor", ReflectionKind.Constructor, context.scope);
-        context.postReflectionCreation(constructMember, symbol, void 0);
-        context.finalizeDeclarationReflection(constructMember);
-        const constructContext = context.withScope(constructMember);
-        constructSignatures.forEach((sig) => createSignature(constructContext, ReflectionKind.ConstructorSignature, sig, symbol));
-    }
-}
 function convertAlias(context, symbol, exportSymbol) {
     // If this is a namespace marked as a primary export or directly within one
     // marked as a primary export then we should convert it immediately rather than deferring

package/dist/lib/converter/types.js

@@ -477,7 +477,7 @@ const referenceConverter = {
             return convertTypeInlined(context, type);
         }
         const ref = context.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
-        if (type.flags & ts.TypeFlags.Substitution) {
+        if ((type.flags & ts.TypeFlags.Substitution) && name === "NoInfer" && ref.package === "typescript") {
             // NoInfer<T>
             ref.typeArguments = [
                 convertType(context, type.baseType),