typedoc 0.25.1 → 0.25.3

package/dist/lib/application.js

@@ -96,6 +96,7 @@ const application_events_1 = require("./application-events");
 const tsconfig_1 = require("./utils/tsconfig");
 const fs_1 = require("./utils/fs");
 const abstract_1 = require("./models/reflections/abstract");
+const ReflectionSymbolId_1 = require("./models/reflections/ReflectionSymbolId");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const packageInfo = require("../../package.json");
 const supportedVersionMajorMinor = packageInfo.peerDependencies.typescript
@@ -451,19 +452,25 @@ let Application = (() => {
             }
             const origOptions = this.options;
             const projects = [];
+            const projectsToConvert = [];
             // Generate a json file for each package
             for (const dir of packageDirs) {
-                this.logger.info(`Converting project at ${(0, paths_1.nicePath)(dir)}`);
+                this.logger.verbose(`Reading project at ${(0, paths_1.nicePath)(dir)}`);
                 const opts = origOptions.copyForPackage(dir);
+                await opts.read(this.logger, dir);
                 // Invalid links should only be reported after everything has been merged.
                 opts.setValue("validation", { invalidLink: false });
-                await opts.read(this.logger, dir);
                 if (opts.getValue("entryPointStrategy") ===
                     entry_point_1.EntryPointStrategy.Packages) {
                     this.logger.error(`Project at ${(0, paths_1.nicePath)(dir)} has entryPointStrategy set to packages, but nested packages are not supported.`);
                     continue;
                 }
-                this.options = opts;
+                (0, ReflectionSymbolId_1.addInferredDeclarationMapPaths)(opts.getCompilerOptions(), opts.getFileNames());
+                projectsToConvert.push({ dir, options: opts });
+            }
+            for (const { dir, options } of projectsToConvert) {
+                this.logger.info(`Converting project at ${(0, paths_1.nicePath)(dir)}`);
+                this.options = options;
                 const project = await this.convert();
                 if (project) {
                     this.validate(project);

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

@@ -28,8 +28,14 @@ const variablePropertyKinds = [
 // the JSDoc converter because we only want part of the comment when
 // getting them.
 const wantedKinds = {
-    [models_1.ReflectionKind.Project]: [typescript_1.default.SyntaxKind.SourceFile],
-    [models_1.ReflectionKind.Module]: [typescript_1.default.SyntaxKind.SourceFile],
+    [models_1.ReflectionKind.Project]: [
+        typescript_1.default.SyntaxKind.SourceFile,
+        typescript_1.default.SyntaxKind.ModuleDeclaration,
+    ],
+    [models_1.ReflectionKind.Module]: [
+        typescript_1.default.SyntaxKind.SourceFile,
+        typescript_1.default.SyntaxKind.ModuleDeclaration,
+    ],
     [models_1.ReflectionKind.Namespace]: [
         typescript_1.default.SyntaxKind.ModuleDeclaration,
         typescript_1.default.SyntaxKind.SourceFile,

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

@@ -74,7 +74,15 @@ function getComment(symbol, kind, config, logger, commentStyle, checker) {
         declarations.every((d) => jsDocCommentKinds.includes(d.kind))) {
         return getJsDocComment(declarations[0], config, logger, checker);
     }
-    const comment = getCommentImpl((0, discovery_1.discoverComment)(symbol, kind, logger, commentStyle), config, logger, declarations.some(typescript_1.default.isSourceFile), checker);
+    const isModule = declarations.some((decl) => {
+        if (typescript_1.default.isSourceFile(decl))
+            return true;
+        if (typescript_1.default.isModuleDeclaration(decl) && typescript_1.default.isStringLiteral(decl.name)) {
+            return true;
+        }
+        return false;
+    });
+    const comment = getCommentImpl((0, discovery_1.discoverComment)(symbol, kind, logger, commentStyle), config, logger, isModule, checker);
     if (!comment && kind === models_1.ReflectionKind.Property) {
         return getConstructorParamPropertyComment(symbol, config, logger, commentStyle, checker);
     }

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

@@ -21,6 +21,7 @@ function convertIndexSignature(context, symbol) {
         const param = indexDeclaration.parameters[0];
         (0, assert_1.default)(param && typescript_1.default.isParameter(param));
         const index = new models_1.SignatureReflection("__index", models_1.ReflectionKind.IndexSignature, context.scope);
+        index.comment = context.getComment(indexSymbol, index.kind);
         index.parameters = [
             new models_1.ParameterReflection(param.name.getText(), models_1.ReflectionKind.Parameter, index),
         ];

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

@@ -5,3 +5,4 @@ export declare function createSignature(context: Context, kind: ReflectionKind.C
 export declare function convertParameterNodes(context: Context, sigRef: SignatureReflection, parameters: readonly (ts.JSDocParameterTag | ts.ParameterDeclaration)[]): ParameterReflection[];
 export declare function convertTypeParameterNodes(context: Context, parameters: readonly ts.TypeParameterDeclaration[] | undefined): TypeParameterReflection[] | undefined;
 export declare function createTypeParamReflection(param: ts.TypeParameterDeclaration, context: Context): TypeParameterReflection;
+export declare function convertTemplateParameterNodes(context: Context, nodes: readonly ts.JSDocTemplateTag[] | undefined): TypeParameterReflection[] | undefined;

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

@@ -3,7 +3,7 @@ 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;
+exports.convertTemplateParameterNodes = exports.createTypeParamReflection = exports.convertTypeParameterNodes = exports.convertParameterNodes = exports.createSignature = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 const assert_1 = __importDefault(require("assert"));
 const models_1 = require("../../models");
@@ -195,6 +195,33 @@ function createTypeParamReflection(param, context) {
     return paramRefl;
 }
 exports.createTypeParamReflection = createTypeParamReflection;
+function convertTemplateParameterNodes(context, nodes) {
+    return nodes?.flatMap((node) => {
+        return node.typeParameters.map((param, index) => {
+            const paramRefl = new models_1.TypeParameterReflection(param.name.text, context.scope, getVariance(param.modifiers));
+            const paramScope = context.withScope(paramRefl);
+            paramRefl.type =
+                index || !node.constraint
+                    ? void 0
+                    : context.converter.convertType(paramScope, node.constraint.type);
+            paramRefl.default = param.default
+                ? context.converter.convertType(paramScope, param.default)
+                : void 0;
+            if (param.modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.ConstKeyword)) {
+                paramRefl.flags.setFlag(models_1.ReflectionFlag.Const, true);
+            }
+            context.registerReflection(paramRefl, param.symbol);
+            if (typescript_1.default.isJSDocTemplateTag(param.parent)) {
+                paramRefl.comment = context.getJsDocComment(param.parent);
+            }
+            context.trigger(converter_events_1.ConverterEvents.CREATE_TYPE_PARAMETER, paramRefl, param);
+            return paramRefl;
+        });
+    });
+    const params = (nodes ?? []).flatMap((tag) => tag.typeParameters);
+    return convertTypeParameterNodes(context, params);
+}
+exports.convertTemplateParameterNodes = convertTemplateParameterNodes;
 function getVariance(modifiers) {
     const hasIn = modifiers?.some((mod) => mod.kind === typescript_1.default.SyntaxKind.InKeyword);
     const hasOut = modifiers?.some((mod) => mod.kind === typescript_1.default.SyntaxKind.OutKeyword);

package/dist/lib/converter/jsdoc.js

@@ -70,16 +70,12 @@ function convertJsDocSignature(context, node) {
     reflection.signatures = [signature];
     signature.type = context.converter.convertType(signatureCtx, node.type?.typeExpression?.type);
     signature.parameters = (0, signature_1.convertParameterNodes)(signatureCtx, signature, node.parameters);
-    signature.typeParameters = convertTemplateParameterNodes(context.withScope(reflection), node.typeParameters);
+    signature.typeParameters = (0, signature_1.convertTemplateParameterNodes)(context.withScope(reflection), node.typeParameters);
     return new models_1.ReflectionType(reflection);
 }
 function convertTemplateParameters(context, node) {
     (0, assert_1.ok)(context.scope instanceof models_1.DeclarationReflection);
-    context.scope.typeParameters = convertTemplateParameterNodes(context, node.tags?.filter(typescript_1.default.isJSDocTemplateTag));
-}
-function convertTemplateParameterNodes(context, nodes) {
-    const params = (nodes ?? []).flatMap((tag) => tag.typeParameters);
-    return (0, signature_1.convertTypeParameterNodes)(context, params);
+    context.scope.typeParameters = (0, signature_1.convertTemplateParameterNodes)(context, node.tags?.filter(typescript_1.default.isJSDocTemplateTag));
 }
 function getTypedefReExportTarget(context, declaration) {
     const typeExpression = declaration.typeExpression;

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

@@ -291,7 +291,7 @@ let CommentPlugin = (() => {
             const comment = reflection.comment;
             if (!comment)
                 return;
-            if (reflection.kindOf(models_1.ReflectionKind.Module)) {
+            if (reflection.kindOf(models_1.ReflectionKind.SomeModule)) {
                 const tag = comment.getTag("@module");
                 if (tag) {
                     // If no name is specified, this is a flag to mark a comment as a module comment

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

@@ -10,6 +10,7 @@ export declare class GroupPlugin extends ConverterComponent {
     sortFunction: (reflections: DeclarationReflection[]) => void;
     accessor boosts: Record<string, number>;
     accessor groupOrder: string[];
+    accessor sortEntryPoints: boolean;
     usedBoosts: Set<string>;
     static WEIGHTS: string[];
     /**

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

@@ -63,7 +63,7 @@ const models_1 = require("../../models");
  * The handler sets the `groups` property of all container reflections.
  */
 let GroupPlugin = (() => {
-    var _GroupPlugin_boosts_accessor_storage, _GroupPlugin_groupOrder_accessor_storage;
+    var _GroupPlugin_boosts_accessor_storage, _GroupPlugin_groupOrder_accessor_storage, _GroupPlugin_sortEntryPoints_accessor_storage;
     let _classDecorators = [(0, components_1.Component)({ name: "group" })];
     let _classDescriptor;
     let _classExtraInitializers = [];
@@ -74,18 +74,23 @@ let GroupPlugin = (() => {
     let _boosts_initializers = [];
     let _groupOrder_decorators;
     let _groupOrder_initializers = [];
+    let _sortEntryPoints_decorators;
+    let _sortEntryPoints_initializers = [];
     var GroupPlugin = _classThis = class extends _classSuper {
         constructor() {
             super(...arguments);
             this.sortFunction = (__runInitializers(this, _instanceExtraInitializers), void 0);
             _GroupPlugin_boosts_accessor_storage.set(this, __runInitializers(this, _boosts_initializers, void 0));
             _GroupPlugin_groupOrder_accessor_storage.set(this, __runInitializers(this, _groupOrder_initializers, void 0));
+            _GroupPlugin_sortEntryPoints_accessor_storage.set(this, __runInitializers(this, _sortEntryPoints_initializers, void 0));
             this.usedBoosts = new Set();
         }
         get boosts() { return __classPrivateFieldGet(this, _GroupPlugin_boosts_accessor_storage, "f"); }
         set boosts(value) { __classPrivateFieldSet(this, _GroupPlugin_boosts_accessor_storage, value, "f"); }
         get groupOrder() { return __classPrivateFieldGet(this, _GroupPlugin_groupOrder_accessor_storage, "f"); }
         set groupOrder(value) { __classPrivateFieldSet(this, _GroupPlugin_groupOrder_accessor_storage, value, "f"); }
+        get sortEntryPoints() { return __classPrivateFieldGet(this, _GroupPlugin_sortEntryPoints_accessor_storage, "f"); }
+        set sortEntryPoints(value) { __classPrivateFieldSet(this, _GroupPlugin_sortEntryPoints_accessor_storage, value, "f"); }
         /**
          * Create a new GroupPlugin instance.
          */
@@ -132,7 +137,10 @@ let GroupPlugin = (() => {
             if (reflection.children &&
                 reflection.children.length > 0 &&
                 !reflection.groups) {
-                this.sortFunction(reflection.children);
+                if (this.sortEntryPoints ||
+                    !reflection.children.some((c) => c.kindOf(index_1.ReflectionKind.Module))) {
+                    this.sortFunction(reflection.children);
+                }
                 reflection.groups = this.getReflectionGroups(reflection.children);
             }
         }
@@ -226,13 +234,16 @@ let GroupPlugin = (() => {
     };
     _GroupPlugin_boosts_accessor_storage = new WeakMap();
     _GroupPlugin_groupOrder_accessor_storage = new WeakMap();
+    _GroupPlugin_sortEntryPoints_accessor_storage = new WeakMap();
     __setFunctionName(_classThis, "GroupPlugin");
     (() => {
         const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
         _boosts_decorators = [(0, utils_1.Option)("searchGroupBoosts")];
         _groupOrder_decorators = [(0, utils_1.Option)("groupOrder")];
+        _sortEntryPoints_decorators = [(0, utils_1.Option)("sortEntryPoints")];
         __esDecorate(_classThis, null, _boosts_decorators, { kind: "accessor", name: "boosts", static: false, private: false, access: { has: obj => "boosts" in obj, get: obj => obj.boosts, set: (obj, value) => { obj.boosts = value; } }, metadata: _metadata }, _boosts_initializers, _instanceExtraInitializers);
         __esDecorate(_classThis, null, _groupOrder_decorators, { kind: "accessor", name: "groupOrder", static: false, private: false, access: { has: obj => "groupOrder" in obj, get: obj => obj.groupOrder, set: (obj, value) => { obj.groupOrder = value; } }, metadata: _metadata }, _groupOrder_initializers, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _sortEntryPoints_decorators, { kind: "accessor", name: "sortEntryPoints", static: false, private: false, access: { has: obj => "sortEntryPoints" in obj, get: obj => obj.sortEntryPoints, set: (obj, value) => { obj.sortEntryPoints = value; } }, metadata: _metadata }, _sortEntryPoints_initializers, _instanceExtraInitializers);
         __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
         GroupPlugin = _classThis = _classDescriptor.value;
         if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });

package/dist/lib/converter/symbols.js

@@ -572,7 +572,10 @@ function convertAccessor(context, symbol, exportSymbol) {
 }
 function isInherited(context, symbol) {
     const parentSymbol = context.project.getSymbolFromReflection(context.scope);
-    (0, assert_1.default)(parentSymbol, `No parent symbol found for ${symbol.name} in ${context.scope.name}`);
+    // It'd be nice to be able to assert that this is true, but sometimes object
+    // types don't get symbols if they are inferred.
+    if (!parentSymbol)
+        return false;
     const parents = parentSymbol.declarations?.slice() || [];
     const constructorDecls = parents.flatMap((parent) => typescript_1.default.isClassDeclaration(parent)
         ? parent.members.filter(typescript_1.default.isConstructorDeclaration)

package/dist/lib/converter/types.js

@@ -164,13 +164,14 @@ const constructorConverter = {
         return new models_1.ReflectionType(reflection);
     },
     convertType(context, type) {
-        if (!type.symbol) {
+        const symbol = type.getSymbol();
+        if (!symbol) {
             return new models_1.IntrinsicType("Function");
         }
         const reflection = new models_1.DeclarationReflection("__type", models_1.ReflectionKind.Constructor, context.scope);
-        context.registerReflection(reflection, type.symbol);
+        context.registerReflection(reflection, symbol);
         context.trigger(converter_events_1.ConverterEvents.CREATE_DECLARATION, reflection);
-        (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.ConstructorSignature, type.getConstructSignatures()[0], type.symbol);
+        (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.ConstructorSignature, type.getConstructSignatures()[0], symbol);
         return new models_1.ReflectionType(reflection);
     },
 };
@@ -212,11 +213,12 @@ const functionTypeConverter = {
         return new models_1.ReflectionType(reflection);
     },
     convertType(context, type) {
-        if (!type.symbol) {
+        const symbol = type.getSymbol();
+        if (!symbol) {
             return new models_1.IntrinsicType("Function");
         }
         const reflection = new models_1.DeclarationReflection("__type", models_1.ReflectionKind.TypeLiteral, context.scope);
-        context.registerReflection(reflection, type.symbol);
+        context.registerReflection(reflection, symbol);
         context.trigger(converter_events_1.ConverterEvents.CREATE_DECLARATION, reflection);
         (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.CallSignature, type.getCallSignatures()[0], type.getSymbol());
         return new models_1.ReflectionType(reflection);
@@ -251,7 +253,7 @@ const inferredConverter = {
         return new models_1.InferredType(node.typeParameter.name.text, maybeConvertType(context, node.typeParameter.constraint));
     },
     convertType(context, type) {
-        return new models_1.InferredType(type.symbol.name, maybeConvertType(context, type.getConstraint()));
+        return new models_1.InferredType(type.getSymbol().name, maybeConvertType(context, type.getConstraint()));
     },
 };
 const intersectionConverter = {
@@ -372,22 +374,22 @@ const typeLiteralConverter = {
         return new models_1.ReflectionType(reflection);
     },
     convertType(context, type) {
-        if (!type.symbol) {
-            return new models_1.IntrinsicType("Object");
-        }
+        const symbol = type.getSymbol();
         const reflection = new models_1.DeclarationReflection("__type", models_1.ReflectionKind.TypeLiteral, context.scope);
-        context.registerReflection(reflection, type.symbol);
+        context.registerReflection(reflection, symbol);
         context.trigger(converter_events_1.ConverterEvents.CREATE_DECLARATION, reflection);
         for (const prop of context.checker.getPropertiesOfType(type)) {
             (0, symbols_1.convertSymbol)(context.withScope(reflection), prop);
         }
         for (const signature of type.getCallSignatures()) {
-            (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.CallSignature, signature, type.symbol);
+            (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.CallSignature, signature, symbol);
         }
         for (const signature of type.getConstructSignatures()) {
-            (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.ConstructorSignature, signature, type.symbol);
+            (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.ConstructorSignature, signature, symbol);
+        }
+        if (symbol) {
+            (0, index_signature_1.convertIndexSignature)(context.withScope(reflection), symbol);
         }
-        (0, index_signature_1.convertIndexSignature)(context.withScope(reflection), type.symbol);
         return new models_1.ReflectionType(reflection);
     },
 };

package/dist/lib/models/reflections/ReflectionSymbolId.d.ts

@@ -27,3 +27,4 @@ export declare class ReflectionSymbolId {
         qualifiedName: string;
     };
 }
+export declare function addInferredDeclarationMapPaths(opts: ts.CompilerOptions, files: readonly string[]): void;

package/dist/lib/models/reflections/ReflectionSymbolId.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReflectionSymbolId = void 0;
+exports.addInferredDeclarationMapPaths = exports.ReflectionSymbolId = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const typescript_1 = __importDefault(require("typescript"));
@@ -20,7 +20,7 @@ class ReflectionSymbolId {
     constructor(symbol, declaration) {
         if ("name" in symbol) {
             declaration ??= symbol?.declarations?.[0];
-            this.fileName = (0, paths_1.normalizePath)(declaration?.getSourceFile().fileName ?? "\0");
+            this.fileName = (0, paths_1.normalizePath)(declaration?.getSourceFile().fileName ?? "");
             if (symbol.declarations?.some(typescript_1.default.isSourceFile)) {
                 this.qualifiedName = "";
             }
@@ -44,21 +44,19 @@ class ReflectionSymbolId {
         }
     }
     toObject(serializer) {
+        const sourceFileName = (0, path_1.isAbsolute)(this.fileName)
+            ? (0, paths_1.normalizePath)((0, path_1.relative)(serializer.projectRoot, resolveDeclarationMaps(this.fileName)))
+            : this.fileName;
         return {
-            sourceFileName: (0, path_1.isAbsolute)(this.fileName)
-                ? (0, paths_1.normalizePath)((0, path_1.relative)(serializer.projectRoot, resolveDeclarationMaps(this.fileName)))
-                : this.fileName,
+            sourceFileName,
             qualifiedName: this.qualifiedName,
         };
     }
 }
 exports.ReflectionSymbolId = ReflectionSymbolId;
 const declarationMapCache = new Map();
-/**
- * See also getTsSourceFromJsSource in package-manifest.ts.
- */
 function resolveDeclarationMaps(file) {
-    if (!file.endsWith(".d.ts"))
+    if (!/\.d\.[cm]?ts$/.test(file))
         return file;
     if (declarationMapCache.has(file))
         return declarationMapCache.get(file);
@@ -93,3 +91,12 @@ function resolveDeclarationMaps(file) {
     }
     return file;
 }
+function addInferredDeclarationMapPaths(opts, files) {
+    const rootDir = opts.rootDir || (0, fs_2.getCommonDirectory)(files);
+    const declDir = opts.declarationDir || opts.outDir || rootDir;
+    for (const file of files) {
+        const mapFile = (0, path_1.resolve)(declDir, (0, path_1.relative)(rootDir, file)).replace(/\.([cm]?[tj]s)x?$/, ".d.$1");
+        declarationMapCache.set(mapFile, file);
+    }
+}
+exports.addInferredDeclarationMapPaths = addInferredDeclarationMapPaths;