typedoc 0.28.0-beta.0 → 0.28.0-beta.2

package/dist/index.d.ts

@@ -36,12 +36,12 @@ export { type CommentParserConfig, Context, Converter, type ConverterEvents, typ
 export * from "./lib/models/index.js";
 /** @primaryExport */
 export * as Configuration from "./lib/utils/options/index.js";
-export { BaseRouter, CategoryRouter, DefaultTheme, DefaultThemeRenderContext, GroupRouter, IndexEvent, KindDirRouter, KindRouter, MarkdownEvent, PageEvent, PageKind, Renderer, RendererEvent, Slugger, StructureDirRouter, StructureRouter, Theme, UrlMapping, } from "./lib/output/index.js";
+export { BaseRouter, CategoryRouter, DefaultTheme, DefaultThemeRenderContext, GroupRouter, IndexEvent, KindDirRouter, KindRouter, MarkdownEvent, PageEvent, PageKind, Renderer, RendererEvent, Slugger, StructureDirRouter, StructureRouter, Theme, } from "./lib/output/index.js";
 export type { Icons, NavigationElement, PageDefinition, PageHeading, RendererEvents, RendererHooks, RenderTemplate, Router, } from "./lib/output/index.js";
 export { Outputs } from "./lib/output/output.js";
 export { ArgumentsReader, CommentStyle, EntryPointStrategy, normalizePath, Option, OptionDefaults, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, ValidatingFileRegistry, } from "./lib/utils/index.js";
 export type { ArrayDeclarationOption, BooleanDeclarationOption, DeclarationOption, DeclarationOptionBase, DeclarationOptionToOptionType, DocumentationEntryPoint, FancyConsoleLogger, FlagsDeclarationOption, JsDocCompatibility, KeyToDeclaration, ManuallyValidatedOption, MapDeclarationOption, MixedDeclarationOption, NumberDeclarationOption, ObjectDeclarationOption, OptionsReader, OutputSpecification, ParameterTypeToOptionTypeMap, SortStrategy, StringDeclarationOption, TypeDocOptionMap, TypeDocOptions, TypeDocOptionValues, ValidationOptions, } from "./lib/utils/index.js";
-export { type ComponentPath, ConsoleLogger, type DeclarationReference, type EnumKeys, EventDispatcher, EventHooks, type GlobString, i18n, JSX, Logger, LogLevel, type Meaning, type MeaningKeyword, type MinimalNode, MinimalSourceFile, type NormalizedPath, type NormalizedPathOrModule, type SymbolReference, translateTagName, } from "#utils";
+export { type ComponentPath, ConsoleLogger, type DeclarationReference, type EnumKeys, EventDispatcher, EventHooks, type GlobString, i18n, JSX, Logger, LogLevel, type Meaning, type MeaningKeyword, type MinimalNode, MinimalSourceFile, type NormalizedPath, type NormalizedPathOrModule, type SymbolReference, type TranslatedString, translateTagName, } from "#utils";
 export { type Deserializable, Deserializer, type DeserializerComponent, JSONOutput, SerializeEvent, Serializer, type SerializerComponent, type SerializerEvents, } from "./lib/serialization/index.js";
 export * as Internationalization from "./lib/internationalization/index.js";
 export type { TranslatableStrings } from "./lib/internationalization/internationalization.js";

package/dist/index.js

@@ -36,7 +36,7 @@ export { Context, Converter, } from "./lib/converter/index.js";
 export * from "./lib/models/index.js";
 /** @primaryExport */
 export * as Configuration from "./lib/utils/options/index.js";
-export { BaseRouter, CategoryRouter, DefaultTheme, DefaultThemeRenderContext, GroupRouter, IndexEvent, KindDirRouter, KindRouter, MarkdownEvent, PageEvent, PageKind, Renderer, RendererEvent, Slugger, StructureDirRouter, StructureRouter, Theme, UrlMapping, } from "./lib/output/index.js";
+export { BaseRouter, CategoryRouter, DefaultTheme, DefaultThemeRenderContext, GroupRouter, IndexEvent, KindDirRouter, KindRouter, MarkdownEvent, PageEvent, PageKind, Renderer, RendererEvent, Slugger, StructureDirRouter, StructureRouter, Theme, } from "./lib/output/index.js";
 export { Outputs } from "./lib/output/output.js";
 export { ArgumentsReader, CommentStyle, EntryPointStrategy, normalizePath, Option, OptionDefaults, Options, PackageJsonReader, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, ValidatingFileRegistry, } from "./lib/utils/index.js";
 export { ConsoleLogger, EventDispatcher, EventHooks, i18n, JSX, Logger, LogLevel, MinimalSourceFile, translateTagName, } from "#utils";

package/dist/lib/application.d.ts

@@ -4,7 +4,7 @@ import { Renderer } from "./output/renderer.js";
 import { type ProjectReflection } from "./models/index.js";
 import { AbstractComponent, type OptionsReader } from "./utils/index.js";
 import { Options } from "./utils/index.js";
-import type { TypeDocOptions } from "./utils/options/declaration.js";
+import { type TypeDocOptions } from "./utils/options/declaration.js";
 import { type GlobString, Logger } from "#utils";
 import { type DocumentationEntryPoint, EntryPointStrategy } from "./utils/entry-point.js";
 import { FileRegistry } from "./models/FileRegistry.js";

package/dist/lib/application.js

@@ -40,6 +40,7 @@ import { Renderer } from "./output/renderer.js";
 import { ReflectionSymbolId } from "./models/index.js";
 import { AbstractComponent, FancyConsoleLogger, loadPlugins, PackageJsonReader, TSConfigReader, TypeDocReader, writeFile, } from "./utils/index.js";
 import { Option, Options } from "./utils/index.js";
+import { rootPackageOptions } from "./utils/options/declaration.js";
 import { i18n, Logger, LogLevel, unique } from "#utils";
 import { ok } from "assert";
 import { EntryPointStrategy, getEntryPoints, getPackageDirectories, getWatchEntryPoints, inferEntryPoints, } from "./utils/entry-point.js";
@@ -593,6 +594,11 @@ let Application = (() => {
             const origFiles = this.files;
             const origOptions = this.options;
             const projects = [];
+            for (const opt of Object.keys(this.options.getValue("packageOptions"))) {
+                if (rootPackageOptions.includes(opt)) {
+                    this.logger.warn(i18n.package_option_0_should_be_specified_at_root(opt));
+                }
+            }
             const projectsToConvert = [];
             // Generate a json file for each package
             for (const dir of packageDirs) {

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

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { DeclarationReflection, type DocumentReflection, type ProjectReflection, type Reflection, ReflectionKind } from "../models/index.js";
+import { Comment, DeclarationReflection, type DocumentReflection, type ProjectReflection, ReferenceType, type Reflection, ReflectionKind } from "../models/index.js";
 import type { Converter } from "./converter.js";
 import { type NormalizedPath } from "#utils";
 /**
@@ -35,6 +35,8 @@ export declare class Context {
     convertingTypeNode: boolean;
     convertingClassOrInterface: boolean;
     shouldBeStatic: boolean;
+    inlineType: Set<string>;
+    preventInline: Set<string>;
     private reflectionIdToSymbolMap;
     /**
      * Create a new Context instance.
@@ -58,6 +60,13 @@ export declare class Context {
     createDeclarationReflection(kind: ReflectionKind, symbol: ts.Symbol | undefined, exportSymbol: ts.Symbol | undefined, nameOverride?: string): DeclarationReflection;
     postReflectionCreation(reflection: Reflection, symbol: ts.Symbol | undefined, exportSymbol: ts.Symbol | undefined): void;
     finalizeDeclarationReflection(reflection: DeclarationReflection): void;
+    /**
+     * Create a {@link ReferenceType} which points to the provided symbol.
+     *
+     * @privateRemarks
+     * This is available on Context so that it can be monkey-patched by typedoc-plugin-missing-exports
+     */
+    createSymbolReference(symbol: ts.Symbol, context: Context, name?: string): ReferenceType;
     addChild(reflection: DeclarationReflection | DocumentReflection): void;
     shouldIgnore(symbol: ts.Symbol): boolean;
     /**
@@ -72,10 +81,11 @@ export declare class Context {
     getSymbolFromReflection(reflection: Reflection): ts.Symbol | undefined;
     /** @internal */
     setActiveProgram(program: ts.Program | undefined): void;
-    getComment(symbol: ts.Symbol, kind: ReflectionKind): import("../models/Comment.js").Comment | undefined;
-    getNodeComment(node: ts.Node, moduleComment: boolean): import("../models/Comment.js").Comment | undefined;
-    getFileComment(node: ts.SourceFile): import("../models/Comment.js").Comment | undefined;
-    getJsDocComment(declaration: ts.JSDocPropertyLikeTag | ts.JSDocCallbackTag | ts.JSDocTypedefTag | ts.JSDocTemplateTag | ts.JSDocEnumTag): import("../models/Comment.js").Comment | undefined;
-    getSignatureComment(declaration: ts.SignatureDeclaration | ts.JSDocSignature): import("../models/Comment.js").Comment | undefined;
+    getComment(symbol: ts.Symbol, kind: ReflectionKind): Comment | undefined;
+    getNodeComment(node: ts.Node, moduleComment: boolean): Comment | undefined;
+    getFileComment(node: ts.SourceFile): Comment | undefined;
+    getJsDocComment(declaration: ts.JSDocPropertyLikeTag | ts.JSDocCallbackTag | ts.JSDocTypedefTag | ts.JSDocTemplateTag | ts.JSDocEnumTag): Comment | undefined;
+    getSignatureComment(declaration: ts.SignatureDeclaration | ts.JSDocSignature): Comment | undefined;
+    shouldInline(symbol: ts.Symbol, name: string): boolean;
     withScope(scope: Reflection): Context;
 }

package/dist/lib/converter/context.js

@@ -1,12 +1,12 @@
 import { ok as assert } from "assert";
 import ts from "typescript";
-import { ContainerReflection, DeclarationReflection, ReflectionFlag, ReflectionKind, } from "../models/index.js";
+import { Comment, ContainerReflection, DeclarationReflection, ReferenceType, ReflectionFlag, ReflectionKind, } from "../models/index.js";
 import { isNamedNode } from "./utils/nodes.js";
 import { ConverterEvents } from "./converter-events.js";
 import { resolveAliasedSymbol } from "./utils/symbols.js";
 import { getComment, getFileComment, getJsDocComment, getNodeComment, getSignatureComment } from "./comments/index.js";
-import { getHumanName } from "../utils/tsutils.js";
-import { normalizePath } from "#node-utils";
+import { getHumanName, getQualifiedName } from "../utils/tsutils.js";
+import { findPackageForPath, normalizePath } from "#node-utils";
 import { createSymbolId } from "./factories/symbol-id.js";
 import { removeIf } from "#utils";
 /**
@@ -47,6 +47,8 @@ export class Context {
     convertingTypeNode = false; // Inherited by withScope
     convertingClassOrInterface = false; // Not inherited
     shouldBeStatic = false; // Not inherited
+    inlineType = new Set(); // Inherited by withScope
+    preventInline = new Set(); // Inherited by withScope
     reflectionIdToSymbolMap = new Map();
     /**
      * Create a new Context instance.
@@ -165,6 +167,21 @@ export class Context {
             this.converter.processDocumentTags(reflection, reflection);
         }
     }
+    /**
+     * Create a {@link ReferenceType} which points to the provided symbol.
+     *
+     * @privateRemarks
+     * This is available on Context so that it can be monkey-patched by typedoc-plugin-missing-exports
+     */
+    createSymbolReference(symbol, context, name) {
+        const ref = ReferenceType.createUnresolvedReference(name ?? symbol.name, createSymbolId(symbol), context.project, getQualifiedName(symbol, name ?? symbol.name));
+        ref.refersToTypeParameter = !!(symbol.flags & ts.SymbolFlags.TypeParameter);
+        const symbolPath = symbol.declarations?.[0]?.getSourceFile().fileName;
+        if (!symbolPath)
+            return ref;
+        ref.package = findPackageForPath(symbolPath)?.[0];
+        return ref;
+    }
     addChild(reflection) {
         if (this.scope instanceof ContainerReflection) {
             this.scope.addChild(reflection);
@@ -233,13 +250,31 @@ export class Context {
     getSignatureComment(declaration) {
         return getSignatureComment(declaration, this.converter.config, this.logger, this.checker, this.project.files);
     }
+    shouldInline(symbol, name) {
+        if (this.preventInline.has(name))
+            return false;
+        if (this.inlineType.has(name))
+            return true;
+        return this
+            .getComment(symbol, ReflectionKind.Interface)
+            ?.hasModifier("@inline") ?? false;
+    }
     withScope(scope) {
-        // TODO: This will be important for #2862
-        // assert(scope.parent === this.scope, "Incorrect context used for withScope");
+        assert(scope.parent === this.scope || scope === this.scope, "Incorrect context used for withScope");
         const context = new Context(this.converter, this.programs, this.project, scope);
         context.convertingTypeNode = this.convertingTypeNode;
         context.setActiveProgram(this._program);
         context.reflectionIdToSymbolMap = this.reflectionIdToSymbolMap;
+        context.preventInline = new Set(this.preventInline);
+        context.inlineType = new Set(this.inlineType);
+        for (const tag of scope.comment?.blockTags || []) {
+            if (tag.tag === "@preventInline") {
+                context.preventInline.add(Comment.combineDisplayParts(tag.content));
+            }
+            else if (tag.tag === "@inlineType") {
+                context.inlineType.add(Comment.combineDisplayParts(tag.content));
+            }
+        }
         return context;
     }
 }

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

@@ -24,6 +24,7 @@ export function convertIndexSignatures(context, type) {
         }
         // Otherwise create a new one
         const index = new SignatureReflection("__index", ReflectionKind.IndexSignature, context.scope);
+        const ic = context.withScope(index);
         if (indexInfo.isReadonly) {
             index.setFlag(ReflectionFlag.Readonly);
         }
@@ -36,8 +37,8 @@ export function convertIndexSignatures(context, type) {
         index.parameters = [
             new ParameterReflection(indexInfo.declaration?.parameters[0].name.getText() ?? "key", ReflectionKind.Parameter, index),
         ];
-        index.parameters[0].type = context.converter.convertType(context.withScope(index.parameters[0]), indexInfo.keyType);
-        index.type = context.converter.convertType(context.withScope(index), indexInfo.type);
+        index.parameters[0].type = context.converter.convertType(ic.withScope(index.parameters[0]), indexInfo.keyType);
+        index.type = context.converter.convertType(ic, indexInfo.type);
         context.registerReflection(index, indexInfo.declaration?.symbol);
         context.scope.indexSignatures ||= [];
         context.scope.indexSignatures.push(index);

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

@@ -16,7 +16,6 @@ export function createSignature(context, kind, signature, symbol, declaration) {
     if (context.shouldBeStatic) {
         sigRef.setFlag(ReflectionFlag.Static);
     }
-    const sigRefCtx = context.withScope(sigRef);
     if (symbol && declaration) {
         context.project.registerSymbolId(sigRef, createSymbolId(symbol, declaration));
     }
@@ -34,6 +33,7 @@ export function createSignature(context, kind, signature, symbol, declaration) {
             }
         }
     }
+    const sigRefCtx = context.withScope(sigRef);
     sigRef.typeParameters = convertTypeParameters(sigRefCtx, sigRef, signature.typeParameters);
     const parameterSymbols = signature.thisParameter
         ? [signature.thisParameter, ...signature.parameters]

package/dist/lib/converter/factories/symbol-id.js

@@ -43,6 +43,7 @@ export function createSymbolId(symbol, declaration) {
     });
     id.pos = pos;
     id.transientId = transientId;
+    id.fileName = normalizePath(sourceFileName);
     return id;
 }
 function resolveDeclarationMaps(file) {

package/dist/lib/converter/jsdoc.js

@@ -53,12 +53,13 @@ function convertJsDocSignature(context, node) {
         return new IntrinsicType("Function");
     }
     const reflection = new DeclarationReflection("__type", ReflectionKind.TypeLiteral, context.scope);
+    const rc = context.withScope(reflection);
     context.registerReflection(reflection, symbol);
     context.converter.trigger(ConverterEvents.CREATE_DECLARATION, context, reflection);
     const signature = new SignatureReflection("__type", ReflectionKind.CallSignature, reflection);
     context.project.registerSymbolId(signature, createSymbolId(symbol, node));
     context.registerReflection(signature, void 0);
-    const signatureCtx = context.withScope(signature);
+    const signatureCtx = rc.withScope(signature);
     reflection.signatures = [signature];
     signature.type = context.converter.convertType(signatureCtx, node.type?.typeExpression?.type);
     signature.parameters = convertParameterNodes(signatureCtx, signature, node.parameters);

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

@@ -45,6 +45,6 @@ export class MergeModuleWithPlugin extends ConverterComponent {
             tempRefl = tempRefl.parent;
         }
         this.application.logger.verbose(`Merging ${refl.getFullName()} into ${target.getFullName()}`);
-        project.mergeModules(refl, target);
+        project.mergeReflections(refl, target);
     }
 }

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

@@ -37,7 +37,8 @@ import { ConverterComponent } from "../components.js";
 import { ApplicationEvents } from "../../application-events.js";
 import { ConverterEvents } from "../converter-events.js";
 import { i18n, MinimalSourceFile } from "#utils";
-import { discoverInParentDir, discoverPackageJson, getCommonDirectory, nicePath, normalizePath, Option, readFile, } from "#node-utils";
+import { discoverPackageJson, getCommonDirectory, nicePath, normalizePath, Option, readFile, } from "#node-utils";
+import { existsSync } from "fs";
 /**
  * A handler that tries to find the package.json and readme.md files of the
  * current project.
@@ -117,8 +118,9 @@ let PackagePlugin = (() => {
             this.packageJson = undefined;
             const dirName = this.application.options.packageDir ??
                 Path.resolve(getCommonDirectory(this.entryPoints.map(g => `${g}/`)));
-            this.application.logger.verbose(`Begin readme.md/package.json search at ${nicePath(dirName)}`);
-            this.packageJson = discoverPackageJson(dirName)?.content;
+            this.application.logger.verbose(`Begin package.json search at ${nicePath(dirName)}`);
+            const packageJson = discoverPackageJson(dirName);
+            this.packageJson = packageJson?.content;
             // Path will be resolved already. This is kind of ugly, but...
             if (this.readme.endsWith("none")) {
                 return; // No readme, we're done
@@ -134,12 +136,20 @@ let PackagePlugin = (() => {
                     this.application.logger.error(i18n.provided_readme_at_0_could_not_be_read(nicePath(this.readme)));
                 }
             }
-            else {
+            else if (packageJson) {
                 // No readme provided, automatically find the readme
-                const result = discoverInParentDir("readme.md", dirName, (content) => content);
-                if (result) {
-                    this.readmeFile = normalizePath(result.file);
-                    this.readmeContents = result.content;
+                const possibleReadmePaths = [
+                    "README.md",
+                    "readme.md",
+                    "Readme.md",
+                ].map(name => Path.join(Path.dirname(packageJson.file), name));
+                const readmePath = possibleReadmePaths.find(path => {
+                    this.application.watchFile(path);
+                    return existsSync(path);
+                });
+                if (readmePath) {
+                    this.readmeFile = normalizePath(readmePath);
+                    this.readmeContents = readFile(readmePath);
                     this.application.watchFile(this.readmeFile);
                 }
             }

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

@@ -113,8 +113,8 @@ let SourcePlugin = (() => {
             this.owner.on(ConverterEvents.RESOLVE_BEGIN, this.onBeginResolve.bind(this));
         }
         onEnd() {
-            // Should probably clear repositories/ignoredPaths here, but these aren't likely to change between runs...
             this.fileNames.clear();
+            delete this.repositories;
         }
         /**
          * Triggered when the converter has created a declaration reflection.

package/dist/lib/converter/symbols.js

@@ -116,7 +116,8 @@ function _convertSymbolNow(context, symbol, exportSymbol) {
 export function convertSymbol(context, symbol, exportSymbol) {
     // #1795, defer conversion of symbols named `default` so that if a function
     // is default exported and also exported with a name, the name takes precedence
-    if ((exportSymbol?.name ?? symbol.name) === "default") {
+    if ((exportSymbol?.name ?? symbol.name) === "default" &&
+        context.scope.kindOf(ReflectionKind.ExportContainer)) {
         context.converter.deferConversion(() => {
             _convertSymbolNow(context, symbol, exportSymbol);
         });
@@ -164,6 +165,9 @@ function convertNamespace(context, symbol, exportSymbol) {
             return;
         }
     }
+    if (symbol.declarations?.some(ts.isFunctionDeclaration)) {
+        exportFlags |= ts.SymbolFlags.PropertyOrAccessor;
+    }
     // #2364, @namespace on a variable might be merged with a namespace containing types.
     const existingReflection = context.getReflectionFromSymbol(exportSymbol || symbol);
     let reflection;
@@ -201,6 +205,7 @@ function convertTypeAlias(context, symbol, exportSymbol) {
             return convertTypeAliasAsInterface(context, symbol, exportSymbol, declaration);
         }
         const reflection = context.createDeclarationReflection(ReflectionKind.TypeAlias, symbol, exportSymbol);
+        context.finalizeDeclarationReflection(reflection);
         if (reflection.comment?.hasModifier("@useDeclaredType")) {
             reflection.comment.removeModifier("@useDeclaredType");
             reflection.type = context.converter.convertType(context.withScope(reflection), context.checker.getDeclaredTypeOfSymbol(symbol));
@@ -211,9 +216,17 @@ function convertTypeAlias(context, symbol, exportSymbol) {
         if (reflection.type.type === "union") {
             attachUnionComments(context, declaration, reflection.type);
         }
-        context.finalizeDeclarationReflection(reflection);
-        // Do this after finalization so that the CommentPlugin can get @typeParam tags
-        // from the parent comment. Ugly, but works for now. Should be cleaned up eventually.
+        else if (reflection.type.type === "reflection" && reflection.type.declaration.children) {
+            // #2817 lift properties of object literal types up to the reflection level.
+            const typeDecl = reflection.type.declaration;
+            reflection.project.mergeReflections(typeDecl, reflection);
+            delete reflection.type;
+            // When created any signatures will be created with __type as their
+            // name, rename them so that they have the alias's name as their name
+            for (const sig of reflection.signatures || []) {
+                sig.name = reflection.name;
+            }
+        }
         reflection.typeParameters = declaration.typeParameters?.map((param) => createTypeParamReflection(param, context.withScope(reflection)));
     }
     else if (ts.isJSDocTypedefTag(declaration) ||
@@ -551,7 +564,10 @@ function convertVariable(context, symbol, exportSymbol) {
     }
     if (type.getCallSignatures().length &&
         !type.getConstructSignatures().length) {
-        return convertVariableAsFunction(context, symbol, exportSymbol);
+        if (comment?.hasModifier("@function") ||
+            (declaration && shouldAutomaticallyConvertAsFunction(declaration))) {
+            return convertVariableAsFunction(context, symbol, exportSymbol);
+        }
     }
     const reflection = context.createDeclarationReflection(context.scope.kindOf(ReflectionKind.VariableContainer)
         ? ReflectionKind.Variable
@@ -625,6 +641,7 @@ function convertVariableAsFunction(context, symbol, exportSymbol) {
     for (const signature of type.getCallSignatures()) {
         createSignature(reflectionContext, ReflectionKind.CallSignature, signature, symbol);
     }
+    reflection.comment?.removeModifier("@function");
     // #2824 If there is only one signature, and there isn't a comment
     // on the signature already, treat the comment on the variable
     // as if it belongs to the signature instead.
@@ -648,7 +665,8 @@ function convertFunctionProperties(context, symbol, type) {
     const nsFlags = ts.SymbolFlags.ValueModule | ts.SymbolFlags.NamespaceModule;
     if (type.getProperties().length &&
         (hasAllFlags(symbol.flags, nsFlags) ||
-            !hasAnyFlag(symbol.flags, nsFlags))) {
+            !hasAnyFlag(symbol.flags, nsFlags)) &&
+        !symbol.declarations?.some(ts.isModuleDeclaration)) {
         convertSymbols(context, type.getProperties());
         return ts.SymbolFlags.NamespaceModule;
     }
@@ -768,3 +786,38 @@ function setModifiers(symbol, declaration, reflection) {
 function setSymbolModifiers(symbol, reflection) {
     reflection.setFlag(ReflectionFlag.Optional, hasAllFlags(symbol.flags, ts.SymbolFlags.Optional));
 }
+function shouldAutomaticallyConvertAsFunction(node) {
+    // const fn = () => {}
+    if (ts.isVariableDeclaration(node)) {
+        if (node.type || !node.initializer)
+            return false;
+        return isFunctionLikeInitializer(node.initializer);
+    }
+    // { fn: () => {} }
+    if (ts.isPropertyAssignment(node)) {
+        return isFunctionLikeInitializer(node.initializer);
+    }
+    // exports.fn = () => {}
+    // exports.fn ||= () => {}
+    // exports.fn ??= () => {}
+    if (ts.isPropertyAccessExpression(node)) {
+        if (ts.isBinaryExpression(node.parent) &&
+            [ts.SyntaxKind.EqualsToken, ts.SyntaxKind.BarBarEqualsToken, ts.SyntaxKind.QuestionQuestionEqualsToken]
+                .includes(node.parent.operatorToken.kind)) {
+            return isFunctionLikeInitializer(node.parent.right);
+        }
+    }
+    return false;
+}
+function isFunctionLikeInitializer(node) {
+    if (ts.isFunctionExpression(node) || ts.isArrowFunction(node)) {
+        return true;
+    }
+    if (ts.isSatisfiesExpression(node)) {
+        return isFunctionLikeInitializer(node.expression);
+    }
+    if (ts.isAsExpression(node)) {
+        return isFunctionLikeInitializer(node.expression);
+    }
+    return false;
+}

package/dist/lib/converter/types.js

@@ -8,7 +8,6 @@ import { convertParameterNodes, convertTypeParameterNodes, createSignature } fro
 import { convertSymbol } from "./symbols.js";
 import { isObjectType, isTypeReference } from "./utils/nodes.js";
 import { removeUndefined } from "./utils/reflections.js";
-import { createSymbolReference } from "./factories/types.js";
 import { createSymbolId } from "./factories/symbol-id.js";
 const converters = new Map();
 export function loadConverters() {
@@ -189,7 +188,7 @@ const exprWithTypeArgsConverter = {
             return convertType(context, context.checker.getTypeAtLocation(node));
         }
         const parameters = node.typeArguments?.map((type) => convertType(context, type)) ?? [];
-        const ref = createSymbolReference(context.resolveAliasedSymbol(targetSymbol), context);
+        const ref = context.createSymbolReference(context.resolveAliasedSymbol(targetSymbol), context);
         ref.typeArguments = parameters;
         return ref;
     },
@@ -239,12 +238,12 @@ const importType = {
         if (!symbol) {
             return new IntrinsicType("any");
         }
-        return createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
+        return context.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
     },
     convertType(context, type) {
         const symbol = type.getSymbol();
         assert(symbol, "Missing symbol when converting import type"); // Should be a compiler error
-        return createSymbolReference(context.resolveAliasedSymbol(symbol), context, "__module");
+        return context.createSymbolReference(context.resolveAliasedSymbol(symbol), context, "__module");
     },
 };
 const indexedAccessConverter = {
@@ -413,7 +412,7 @@ const queryConverter = {
             // on a variable typed as `any` with a name that doesn't exist.
             return new QueryType(ReferenceType.createBrokenReference(node.exprName.getText(), context.project));
         }
-        const ref = createSymbolReference(context.resolveAliasedSymbol(querySymbol), context, node.exprName.getText());
+        const ref = context.createSymbolReference(context.resolveAliasedSymbol(querySymbol), context, node.exprName.getText());
         ref.preferValues = true;
         return new QueryType(ref);
     },
@@ -422,7 +421,7 @@ const queryConverter = {
         // an instantiation expression we get the user's exprName.
         const symbol = context.getSymbolAtLocation(node.exprName) || type.getSymbol();
         assert(symbol, `Query type failed to get a symbol for: ${context.checker.typeToString(type)}. This is a bug.`);
-        const ref = createSymbolReference(context.resolveAliasedSymbol(symbol), context);
+        const ref = context.createSymbolReference(context.resolveAliasedSymbol(symbol), context);
         ref.preferValues = true;
         return new QueryType(ref);
     },
@@ -436,20 +435,18 @@ const referenceConverter = {
             return new ArrayType(convertType(context, node.typeArguments?.[0]));
         }
         const symbol = context.expectSymbolAtLocation(node.typeName);
+        const name = node.typeName.getText();
         // Ignore @inline if there are type arguments, as they won't be resolved
         // in the type we just retrieved from node.typeName.
         if (!node.typeArguments &&
-            context
-                .getComment(symbol, ReflectionKind.Interface)
-                ?.hasModifier("@inline")) {
+            context.shouldInline(symbol, name)) {
             // typeLiteralConverter doesn't use the node, so we can get away with lying here.
             // This might not actually be safe, it appears that it is in the relatively small
             // amount of testing I've done with it, but I wouldn't be surprised if someone manages
             // to find a crash.
             return typeLiteralConverter.convertType(context, type, null, undefined);
         }
-        const name = node.typeName.getText();
-        const ref = createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
+        const ref = context.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
         ref.typeArguments = node.typeArguments?.map((type) => convertType(context, type));
         return ref;
     },
@@ -465,15 +462,6 @@ const referenceConverter = {
             ref.refersToTypeParameter = true;
             return ref;
         }
-        if (context
-            .getComment(symbol, ReflectionKind.Interface)
-            ?.hasModifier("@inline")) {
-            // typeLiteralConverter doesn't use the node, so we can get away with lying here.
-            // This might not actually be safe, it appears that it is in the relatively small
-            // amount of testing I've done with it, but I wouldn't be surprised if someone manages
-            // to find a crash.
-            return typeLiteralConverter.convertType(context, type, null, undefined);
-        }
         let name;
         if (ts.isIdentifier(node.typeName)) {
             name = node.typeName.text;
@@ -481,7 +469,14 @@ const referenceConverter = {
         else {
             name = node.typeName.right.text;
         }
-        const ref = createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
+        if (context.shouldInline(symbol, name)) {
+            // typeLiteralConverter doesn't use the node, so we can get away with lying here.
+            // This might not actually be safe, it appears that it is in the relatively small
+            // amount of testing I've done with it, but I wouldn't be surprised if someone manages
+            // to find a crash.
+            return typeLiteralConverter.convertType(context, type, null, undefined);
+        }
+        const ref = context.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
         if (type.flags & ts.TypeFlags.Substitution) {
             // NoInfer<T>
             ref.typeArguments = [

package/dist/lib/internationalization/locales/en.cjs

@@ -16,6 +16,7 @@ module.exports = {
     no_entry_points_for_packages: "No entry points provided to packages mode, documentation cannot be generated",
     failed_to_find_packages: "Failed to find any packages, ensure you have provided at least one directory as an entry point containing package.json",
     nested_packages_unsupported_0: "Project at {0} has entryPointStrategy set to packages, but nested packages are not supported",
+    package_option_0_should_be_specified_at_root: "The packageOptions option sets option {0}, which only has an affect at the root level",
     previous_error_occurred_when_reading_options_for_0: "The previous error occurred when reading options for the package at {0}",
     converting_project_at_0: "Converting project at {0}",
     failed_to_convert_packages: "Failed to convert one or more packages, result will not be merged together",
@@ -193,6 +194,7 @@ module.exports = {
     help_basePath: "Specifies the base path to be used when displaying file paths",
     help_excludeTags: "Remove the listed block/modifier tags from doc comments",
     help_notRenderedTags: "Tags which will be preserved in doc comments, but not rendered when creating output",
+    help_cascadedModifierTags: "Modifier tags which should be copied to all children of the parent reflection",
     help_readme: "Path to the readme file that should be displayed on the index page. Pass `none` to disable the index page and start the documentation on the globals page",
     help_cname: "Set the CNAME file text, it's useful for custom domains on GitHub Pages",
     help_favicon: "Path to favicon to include as the site icon",

package/dist/lib/internationalization/locales/en.d.cts

@@ -13,6 +13,7 @@ declare const _default: {
     readonly no_entry_points_for_packages: "No entry points provided to packages mode, documentation cannot be generated";
     readonly failed_to_find_packages: "Failed to find any packages, ensure you have provided at least one directory as an entry point containing package.json";
     readonly nested_packages_unsupported_0: "Project at {0} has entryPointStrategy set to packages, but nested packages are not supported";
+    readonly package_option_0_should_be_specified_at_root: "The packageOptions option sets option {0}, which only has an affect at the root level";
     readonly previous_error_occurred_when_reading_options_for_0: "The previous error occurred when reading options for the package at {0}";
     readonly converting_project_at_0: "Converting project at {0}";
     readonly failed_to_convert_packages: "Failed to convert one or more packages, result will not be merged together";
@@ -180,6 +181,7 @@ declare const _default: {
     readonly help_basePath: "Specifies the base path to be used when displaying file paths";
     readonly help_excludeTags: "Remove the listed block/modifier tags from doc comments";
     readonly help_notRenderedTags: "Tags which will be preserved in doc comments, but not rendered when creating output";
+    readonly help_cascadedModifierTags: "Modifier tags which should be copied to all children of the parent reflection";
     readonly help_readme: "Path to the readme file that should be displayed on the index page. Pass `none` to disable the index page and start the documentation on the globals page";
     readonly help_cname: "Set the CNAME file text, it's useful for custom domains on GitHub Pages";
     readonly help_favicon: "Path to favicon to include as the site icon";

package/dist/lib/internationalization/locales/zh.cjs

@@ -63,7 +63,8 @@ module.exports = localeUtils.buildIncompleteTranslation({
     failed_to_resolve_link_to_0_in_document_1_may_have_meant_2: "无法解析文档 {1} 中指向 “{0}” 的链接。您可能想要 “{2}”",
     type_0_defined_in_1_is_referenced_by_2_but_not_included_in_docs: "{0} 在 {1} 中定义，被 {2} 引用，但未包含在文档中",
     reflection_0_kind_1_defined_in_2_does_not_have_any_documentation: "{0} ({1})，在 {2} 中定义，没有任何文档",
-    invalid_intentionally_not_exported_symbols_0: "以下符号被标记为有意不导出，但未在文档中引用，或已被导出：\n{0}",
+    invalid_intentionally_not_documented_names_0: "以下的限定反射名称被设定为刻意无文档说明，但它们要么未在文档中被引用，要么已有文档说明：\n\t{0}",
+    invalid_intentionally_not_exported_symbols_0: "以下符号被设定为刻意非导出，但它们要么未在文档中被引用，要么已为导出符号：\n{0}",
     reflection_0_has_unused_mergeModuleWith_tag: "{0} 中存在无法解析的 @mergeModuleWith 标签",
     reflection_0_links_to_1_with_text_2_but_resolved_to_3: "“{0}”中的链接“{2}”指向“{1}”，目标虽然存在但并没有直接的链接，因此将改为链接至“{3}”。",
     // conversion plugins
@@ -194,6 +195,7 @@ module.exports = localeUtils.buildIncompleteTranslation({
     help_basePath: "指定显示文件路径时使用的基本路径",
     help_excludeTags: "从文档注释中删除列出的块级/修饰符标签",
     help_notRenderedTags: "保留在文档注释中但在创建输出时不渲染的标签",
+    help_cascadedModifierTags: "需要从父反射复制至所有子反射的修饰符标签",
     help_readme: "应显示在索引页上的自述文件路径。传递“none”以禁用索引页并在全局页上启动文档",
     help_cname: "设置 CNAME 文件文本，这对于 GitHub Pages 上的自定义域很有用",
     help_favicon: "作为站点图标包含的 favicon 的路径",
@@ -222,6 +224,7 @@ module.exports = localeUtils.buildIncompleteTranslation({
     help_searchGroupBoosts: "配置搜索以增强所选种类（例如“类别”）的相关性",
     help_useFirstParagraphOfCommentAsSummary: "如果设置，且没有指定 @summary 标签，TypeDoc 会使用注释的第一行作为在模块/命名空间一览里的概述",
     help_jsDocCompatibility: "设置注释解析的兼容性选项，以增加与 JSDoc 注释的相似度",
+    help_suppressCommentWarningsInDeclarationFiles: "阻止 .d.ts 文件的注释中因为存在未指定的标签而弹出的警告。",
     help_commentStyle: "确定 TypeDoc 如何搜索注释",
     help_useTsLinkResolution: "使用 TypeScript 的链接解析来确定 @link 标签指向的位置。这仅适用于 JSDoc 样式注释",
     help_preserveLinkText: "如果设置，不带链接文本的 @link 标签将使用文本内容作为链接。如果未设置，将使用目标反射名称",
@@ -246,8 +249,10 @@ module.exports = localeUtils.buildIncompleteTranslation({
     help_logLevel: "指定应使用什么级别的日志记录",
     help_treatWarningsAsErrors: "如果设置，所有警告都将被视为错误",
     help_treatValidationWarningsAsErrors: "如果设置，验证期间发出的警告将被视为错误。此选项不能用于禁用验证警告的 treatWarningsAsErrors",
-    help_intentionallyNotExported: "不应产生“引用但未记录”警告的类型列表",
-    help_requiredToBeDocumented: "必须记录的反射类型列表",
+    help_intentionallyNotExported: "不会因为“引用但并未导出”而产生警告的符号列表",
+    help_requiredToBeDocumented: "需要有文档说明的反射类型列表",
+    help_packagesRequiringDocumentation: "需要有文档说明的包的列表",
+    help_intentionallyNotDocumented: "不会因为无文档说明而产生警告的完整反射名称列表",
     help_validation: "指定 TypeDoc 应对生成的文档执行哪些验证步骤",
     // ==================================================================
     // Option validation